1 /****************************************************************************** 2 * 3 * Copyright (C) 2004-2012 Broadcom Corporation 4 * 5 * Licensed under the Apache License, Version 2.0 (the "License"); 6 * you may not use this file except in compliance with the License. 7 * You may obtain a copy of the License at: 8 * 9 * http://www.apache.org/licenses/LICENSE-2.0 10 * 11 * Unless required by applicable law or agreed to in writing, software 12 * distributed under the License is distributed on an "AS IS" BASIS, 13 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 14 * See the License for the specific language governing permissions and 15 * limitations under the License. 16 * 17 ******************************************************************************/ 18 19 /****************************************************************************** 20 * 21 * This file contains action functions for advanced audio/video main state 22 * machine. 23 * 24 ******************************************************************************/ 25 26 #include "bt_target.h" 27 #if defined(BTA_AV_INCLUDED) && (BTA_AV_INCLUDED == TRUE) 28 29 #include <string.h> 30 #include "bta_av_api.h" 31 #include "bta_av_int.h" 32 #include "avdt_api.h" 33 #include "bd.h" 34 #include "utl.h" 35 #include "l2c_api.h" 36 #if( defined BTA_AR_INCLUDED ) && (BTA_AR_INCLUDED == TRUE) 37 #include "bta_ar_api.h" 38 #endif 39 40 /***************************************************************************** 41 ** Constants 42 *****************************************************************************/ 43 /* the timer in milliseconds to wait for open req after setconfig for incoming connections */ 44 #ifndef BTA_AV_SIG_TIME_VAL 45 #define BTA_AV_SIG_TIME_VAL 8000 46 #endif 47 48 /* In millisec to wait for signalling from SNK when it is initiated from SNK. */ 49 /* If not, we will start signalling from SRC. */ 50 #ifndef BTA_AV_ACP_SIG_TIME_VAL 51 #define BTA_AV_ACP_SIG_TIME_VAL 2000 52 #endif 53 54 static void bta_av_acp_sig_timer_cback (TIMER_LIST_ENT *p_tle); 55 56 /******************************************************************************* 57 ** 58 ** Function bta_av_get_rcb_by_shdl 59 ** 60 ** Description find the RCB associated with the given SCB handle. 61 ** 62 ** Returns tBTA_AV_RCB 63 ** 64 *******************************************************************************/ 65 tBTA_AV_RCB * bta_av_get_rcb_by_shdl(UINT8 shdl) 66 { 67 tBTA_AV_RCB *p_rcb = NULL; 68 int i; 69 70 for (i=0; i<BTA_AV_NUM_RCB; i++) 71 { 72 if (bta_av_cb.rcb[i].shdl == shdl && bta_av_cb.rcb[i].handle != BTA_AV_RC_HANDLE_NONE) 73 { 74 p_rcb = &bta_av_cb.rcb[i]; 75 break; 76 } 77 } 78 return p_rcb; 79 } 80 #define BTA_AV_STS_NO_RSP 0xFF /* a number not used by tAVRC_STS */ 81 82 /******************************************************************************* 83 ** 84 ** Function bta_av_del_rc 85 ** 86 ** Description delete the given AVRC handle. 87 ** 88 ** Returns void 89 ** 90 *******************************************************************************/ 91 void bta_av_del_rc(tBTA_AV_RCB *p_rcb) 92 { 93 tBTA_AV_SCB *p_scb; 94 UINT8 rc_handle; /* connected AVRCP handle */ 95 96 if(p_rcb->handle != BTA_AV_RC_HANDLE_NONE) 97 { 98 if(p_rcb->shdl) 99 { 100 p_scb = bta_av_cb.p_scb[p_rcb->shdl - 1]; 101 if(p_scb) 102 { 103 APPL_TRACE_DEBUG3("bta_av_del_rc shdl:%d, srch:%d rc_handle:%d", p_rcb->shdl, 104 p_scb->rc_handle, p_rcb->handle); 105 if(p_scb->rc_handle == p_rcb->handle) 106 p_scb->rc_handle = BTA_AV_RC_HANDLE_NONE; 107 /* just in case the RC timer is active 108 if(bta_av_cb.features & BTA_AV_FEAT_RCCT && p_scb->chnl == BTA_AV_CHNL_AUDIO) */ 109 bta_sys_stop_timer(&p_scb->timer); 110 } 111 } 112 113 APPL_TRACE_EVENT4("bta_av_del_rc handle: %d status=0x%x, rc_acp_handle:%d, idx:%d", 114 p_rcb->handle, p_rcb->status, bta_av_cb.rc_acp_handle, bta_av_cb.rc_acp_idx); 115 rc_handle = p_rcb->handle; 116 if(!(p_rcb->status & BTA_AV_RC_CONN_MASK) || 117 ((p_rcb->status & BTA_AV_RC_ROLE_MASK) == BTA_AV_RC_ROLE_INT) ) 118 { 119 p_rcb->status = 0; 120 p_rcb->handle = BTA_AV_RC_HANDLE_NONE; 121 p_rcb->shdl = 0; 122 p_rcb->lidx = 0; 123 } 124 /* else ACP && connected. do not clear the handle yet */ 125 AVRC_Close(rc_handle); 126 if (rc_handle == bta_av_cb.rc_acp_handle) 127 bta_av_cb.rc_acp_handle = BTA_AV_RC_HANDLE_NONE; 128 APPL_TRACE_EVENT4("end del_rc handle: %d status=0x%x, rc_acp_handle:%d, lidx:%d", 129 p_rcb->handle, p_rcb->status, bta_av_cb.rc_acp_handle, p_rcb->lidx); 130 } 131 } 132 133 134 /******************************************************************************* 135 ** 136 ** Function bta_av_close_all_rc 137 ** 138 ** Description close the all AVRC handle. 139 ** 140 ** Returns void 141 ** 142 *******************************************************************************/ 143 static void bta_av_close_all_rc(tBTA_AV_CB *p_cb) 144 { 145 int i; 146 147 for(i=0; i<BTA_AV_NUM_RCB; i++) 148 { 149 if ((p_cb->disabling == TRUE) || (bta_av_cb.rcb[i].shdl != 0)) 150 bta_av_del_rc(&bta_av_cb.rcb[i]); 151 } 152 } 153 154 /******************************************************************************* 155 ** 156 ** Function bta_av_del_sdp_rec 157 ** 158 ** Description delete the given SDP record handle. 159 ** 160 ** Returns void 161 ** 162 *******************************************************************************/ 163 static void bta_av_del_sdp_rec(UINT32 *p_sdp_handle) 164 { 165 if(*p_sdp_handle != 0) 166 { 167 SDP_DeleteRecord(*p_sdp_handle); 168 *p_sdp_handle = 0; 169 } 170 } 171 172 /******************************************************************************* 173 ** 174 ** Function bta_av_avrc_sdp_cback 175 ** 176 ** Description AVRCP service discovery callback. 177 ** 178 ** Returns void 179 ** 180 *******************************************************************************/ 181 static void bta_av_avrc_sdp_cback(UINT16 status) 182 { 183 BT_HDR *p_msg; 184 185 if ((p_msg = (BT_HDR *) GKI_getbuf(sizeof(BT_HDR))) != NULL) 186 { 187 p_msg->event = BTA_AV_SDP_AVRC_DISC_EVT; 188 bta_sys_sendmsg(p_msg); 189 } 190 } 191 192 /******************************************************************************* 193 ** 194 ** Function bta_av_rc_ctrl_cback 195 ** 196 ** Description AVRCP control callback. 197 ** 198 ** Returns void 199 ** 200 *******************************************************************************/ 201 static void bta_av_rc_ctrl_cback(UINT8 handle, UINT8 event, UINT16 result, BD_ADDR peer_addr) 202 { 203 tBTA_AV_RC_CONN_CHG *p_msg; 204 UINT16 msg_event = 0; 205 206 #if (defined(BTA_AV_MIN_DEBUG_TRACES) && BTA_AV_MIN_DEBUG_TRACES == TRUE) 207 APPL_TRACE_EVENT2("rc_ctrl handle: %d event=0x%x", handle, event); 208 #else 209 APPL_TRACE_EVENT2("bta_av_rc_ctrl_cback handle: %d event=0x%x", handle, event); 210 #endif 211 if (event == AVRC_OPEN_IND_EVT) 212 { 213 /* save handle of opened connection 214 bta_av_cb.rc_handle = handle;*/ 215 216 msg_event = BTA_AV_AVRC_OPEN_EVT; 217 } 218 else if (event == AVRC_CLOSE_IND_EVT) 219 { 220 msg_event = BTA_AV_AVRC_CLOSE_EVT; 221 } 222 223 if (msg_event) 224 { 225 if ((p_msg = (tBTA_AV_RC_CONN_CHG *) GKI_getbuf(sizeof(tBTA_AV_RC_CONN_CHG))) != NULL) 226 { 227 p_msg->hdr.event = msg_event; 228 p_msg->handle = handle; 229 if(peer_addr) 230 bdcpy(p_msg->peer_addr, peer_addr); 231 bta_sys_sendmsg(p_msg); 232 } 233 } 234 } 235 236 /******************************************************************************* 237 ** 238 ** Function bta_av_rc_msg_cback 239 ** 240 ** Description AVRCP message callback. 241 ** 242 ** Returns void 243 ** 244 *******************************************************************************/ 245 static void bta_av_rc_msg_cback(UINT8 handle, UINT8 label, UINT8 opcode, tAVRC_MSG *p_msg) 246 { 247 tBTA_AV_RC_MSG *p_buf; 248 UINT8 *p_data = NULL; 249 UINT8 **p_p_data = NULL; 250 UINT16 data_len = 0; 251 252 #if (defined(BTA_AV_MIN_DEBUG_TRACES) && BTA_AV_MIN_DEBUG_TRACES == TRUE) 253 APPL_TRACE_ERROR2("rc_msg handle: %d opcode=0x%x", handle, opcode); 254 #else 255 APPL_TRACE_EVENT2("bta_av_rc_msg_cback handle: %d opcode=0x%x", handle, opcode); 256 #endif 257 /* determine size of buffer we need */ 258 if (opcode == AVRC_OP_VENDOR && p_msg->vendor.p_vendor_data != NULL) 259 { 260 p_data = p_msg->vendor.p_vendor_data; 261 p_p_data = &p_msg->vendor.p_vendor_data; 262 data_len = (UINT16) p_msg->vendor.vendor_len; 263 } 264 else if (opcode == AVRC_OP_PASS_THRU && p_msg->pass.p_pass_data != NULL) 265 { 266 p_data = p_msg->pass.p_pass_data; 267 p_p_data = &p_msg->pass.p_pass_data; 268 data_len = (UINT16) p_msg->pass.pass_len; 269 } 270 271 if ((p_buf = (tBTA_AV_RC_MSG *) GKI_getbuf((UINT16) (sizeof(tBTA_AV_RC_MSG) + data_len))) != NULL) 272 { 273 p_buf->hdr.event = BTA_AV_AVRC_MSG_EVT; 274 p_buf->handle = handle; 275 p_buf->label = label; 276 p_buf->opcode = opcode; 277 memcpy(&p_buf->msg, p_msg, sizeof(tAVRC_MSG)); 278 if (p_data != NULL) 279 { 280 memcpy((UINT8 *)(p_buf + 1), p_data, data_len); 281 *p_p_data = (UINT8 *)(p_buf + 1); 282 } 283 bta_sys_sendmsg(p_buf); 284 } 285 } 286 287 /******************************************************************************* 288 ** 289 ** Function bta_av_rc_create 290 ** 291 ** Description alloc RCB and call AVRC_Open 292 ** 293 ** Returns the created rc handle 294 ** 295 *******************************************************************************/ 296 UINT8 bta_av_rc_create(tBTA_AV_CB *p_cb, UINT8 role, UINT8 shdl, UINT8 lidx) 297 { 298 tAVRC_CONN_CB ccb; 299 BD_ADDR_PTR bda = (BD_ADDR_PTR)bd_addr_any; 300 UINT8 status = BTA_AV_RC_ROLE_ACP; 301 tBTA_AV_SCB *p_scb = p_cb->p_scb[shdl - 1]; 302 int i; 303 UINT8 rc_handle; 304 tBTA_AV_RCB *p_rcb; 305 306 if(role == AVCT_INT) 307 { 308 bda = p_scb->peer_addr; 309 status = BTA_AV_RC_ROLE_INT; 310 } 311 else 312 { 313 if ((p_rcb = bta_av_get_rcb_by_shdl(shdl)) != NULL ) 314 { 315 APPL_TRACE_ERROR1("bta_av_rc_create ACP handle exist for shdl:%d", shdl); 316 return p_rcb->handle; 317 } 318 } 319 320 ccb.p_ctrl_cback = bta_av_rc_ctrl_cback; 321 ccb.p_msg_cback = bta_av_rc_msg_cback; 322 ccb.company_id = p_bta_av_cfg->company_id; 323 ccb.conn = role; 324 /* note: BTA_AV_FEAT_RCTG = AVRC_CT_TARGET, BTA_AV_FEAT_RCCT = AVRC_CT_CONTROL */ 325 ccb.control = p_cb->features & (BTA_AV_FEAT_RCTG | BTA_AV_FEAT_RCCT | AVRC_CT_PASSIVE); 326 327 328 if (AVRC_Open(&rc_handle, &ccb, bda) != AVRC_SUCCESS) 329 return BTA_AV_RC_HANDLE_NONE; 330 331 i = rc_handle; 332 p_rcb = &p_cb->rcb[i]; 333 334 if (p_rcb->handle != BTA_AV_RC_HANDLE_NONE) 335 { 336 APPL_TRACE_ERROR1("bta_av_rc_create found duplicated handle:%d", rc_handle); 337 } 338 339 p_rcb->handle = rc_handle; 340 p_rcb->status = status; 341 p_rcb->shdl = shdl; 342 p_rcb->lidx = lidx; 343 p_rcb->peer_features = 0; 344 if(lidx == (BTA_AV_NUM_LINKS + 1)) 345 { 346 /* this LIDX is reserved for the AVRCP ACP connection */ 347 p_cb->rc_acp_handle = p_rcb->handle; 348 p_cb->rc_acp_idx = (i + 1); 349 APPL_TRACE_DEBUG2("rc_acp_handle:%d idx:%d", p_cb->rc_acp_handle, p_cb->rc_acp_idx); 350 } 351 APPL_TRACE_DEBUG6("create %d, role: %d, shdl:%d, rc_handle:%d, lidx:%d, status:0x%x", 352 i, role, shdl, p_rcb->handle, lidx, p_rcb->status); 353 354 return rc_handle; 355 } 356 357 /******************************************************************************* 358 ** 359 ** Function bta_av_valid_group_navi_msg 360 ** 361 ** Description Check if it is Group Navigation Msg for Metadata 362 ** 363 ** Returns BTA_AV_RSP_ACCEPT or BTA_AV_RSP_NOT_IMPL. 364 ** 365 *******************************************************************************/ 366 static tBTA_AV_CODE bta_av_group_navi_supported(UINT8 len, UINT8 *p_data) 367 { 368 tBTA_AV_CODE ret=BTA_AV_RSP_NOT_IMPL; 369 UINT8 *p_ptr = p_data; 370 UINT16 u16; 371 UINT32 u32; 372 373 if (p_bta_av_cfg->avrc_group && len == BTA_GROUP_NAVI_MSG_OP_DATA_LEN) 374 { 375 BTA_AV_BE_STREAM_TO_CO_ID(u32, p_ptr); 376 BE_STREAM_TO_UINT16(u16, p_ptr); 377 378 if (u32 == AVRC_CO_METADATA) 379 { 380 if (u16 <= AVRC_PDU_PREV_GROUP) 381 ret = BTA_AV_RSP_ACCEPT; 382 else 383 ret = BTA_AV_RSP_REJ; 384 } 385 } 386 387 return ret; 388 } 389 390 /******************************************************************************* 391 ** 392 ** Function bta_av_op_supported 393 ** 394 ** Description Check if remote control operation is supported. 395 ** 396 ** Returns BTA_AV_RSP_ACCEPT of supported, BTA_AV_RSP_NOT_IMPL if not. 397 ** 398 *******************************************************************************/ 399 static tBTA_AV_CODE bta_av_op_supported(tBTA_AV_RC rc_id) 400 { 401 tBTA_AV_CODE ret_code = BTA_AV_RSP_NOT_IMPL; 402 403 if (p_bta_av_rc_id) 404 { 405 if (p_bta_av_rc_id[rc_id >> 4] & (1 << (rc_id & 0x0F))) 406 { 407 ret_code = BTA_AV_RSP_ACCEPT; 408 } 409 else if ((p_bta_av_cfg->rc_pass_rsp == BTA_AV_RSP_INTERIM) && p_bta_av_rc_id_ac) 410 { 411 if (p_bta_av_rc_id_ac[rc_id >> 4] & (1 << (rc_id & 0x0F))) 412 { 413 ret_code = BTA_AV_RSP_INTERIM; 414 } 415 } 416 } 417 return ret_code; 418 } 419 420 /******************************************************************************* 421 ** 422 ** Function bta_av_find_lcb 423 ** 424 ** Description Given BD_addr, find the associated LCB. 425 ** 426 ** Returns NULL, if not found. 427 ** 428 *******************************************************************************/ 429 tBTA_AV_LCB * bta_av_find_lcb(BD_ADDR addr, UINT8 op) 430 { 431 tBTA_AV_CB *p_cb = &bta_av_cb; 432 int xx; 433 UINT8 mask; 434 tBTA_AV_LCB *p_lcb = NULL; 435 436 for(xx=0; xx<BTA_AV_NUM_LINKS; xx++) 437 { 438 mask = 1 << xx; /* the used mask for this lcb */ 439 if((mask & p_cb->conn_lcb) && 0 ==( bdcmp(p_cb->lcb[xx].addr, addr))) 440 { 441 p_lcb = &p_cb->lcb[xx]; 442 if(op == BTA_AV_LCB_FREE) 443 { 444 p_cb->conn_lcb &= ~mask; /* clear the connect mask */ 445 APPL_TRACE_DEBUG1("conn_lcb: 0x%x", p_cb->conn_lcb); 446 } 447 break; 448 } 449 } 450 return p_lcb; 451 } 452 453 /******************************************************************************* 454 ** 455 ** Function bta_av_rc_opened 456 ** 457 ** Description Set AVRCP state to opened. 458 ** 459 ** Returns void 460 ** 461 *******************************************************************************/ 462 void bta_av_rc_opened(tBTA_AV_CB *p_cb, tBTA_AV_DATA *p_data) 463 { 464 tBTA_AV_RC_OPEN rc_open; 465 tBTA_AV_SCB *p_scb; 466 int i; 467 UINT8 shdl = 0; 468 tBTA_AV_LCB *p_lcb; 469 tBTA_AV_RCB *p_rcb; 470 UINT8 tmp; 471 UINT8 disc = 0; 472 473 /* find the SCB & stop the timer */ 474 for(i=0; i<BTA_AV_NUM_STRS; i++) 475 { 476 p_scb = p_cb->p_scb[i]; 477 if(p_scb && bdcmp(p_scb->peer_addr, p_data->rc_conn_chg.peer_addr) == 0) 478 { 479 p_scb->rc_handle = p_data->rc_conn_chg.handle; 480 APPL_TRACE_DEBUG2("bta_av_rc_opened shdl:%d, srch %d", i + 1, p_scb->rc_handle); 481 shdl = i+1; 482 APPL_TRACE_ERROR1("use_rc:%d", p_scb->use_rc); 483 bta_sys_stop_timer(&p_scb->timer); 484 disc = p_scb->hndl; 485 break; 486 } 487 } 488 489 i = p_data->rc_conn_chg.handle; 490 if (p_cb->rcb[i].handle == BTA_AV_RC_HANDLE_NONE) 491 { 492 APPL_TRACE_ERROR1("not a valid handle:%d any more", i); 493 return; 494 } 495 496 497 if (p_cb->rcb[i].lidx == (BTA_AV_NUM_LINKS + 1) && shdl != 0) 498 { 499 /* rc is opened on the RC only ACP channel, but is for a specific 500 * SCB -> need to switch RCBs */ 501 p_rcb = bta_av_get_rcb_by_shdl(shdl); 502 if (p_rcb) 503 { 504 p_rcb->shdl = p_cb->rcb[i].shdl; 505 tmp = p_rcb->lidx; 506 p_rcb->lidx = p_cb->rcb[i].lidx; 507 p_cb->rcb[i].lidx = tmp; 508 p_cb->rc_acp_handle = p_rcb->handle; 509 p_cb->rc_acp_idx = (p_rcb - p_cb->rcb) + 1; 510 APPL_TRACE_DEBUG2("switching RCB rc_acp_handle:%d idx:%d", 511 p_cb->rc_acp_handle, p_cb->rc_acp_idx); 512 } 513 } 514 515 p_cb->rcb[i].shdl = shdl; 516 rc_open.rc_handle = i; 517 APPL_TRACE_ERROR4("bta_av_rc_opened rcb[%d] shdl:%d lidx:%d/%d", 518 i, shdl, p_cb->rcb[i].lidx, p_cb->lcb[BTA_AV_NUM_LINKS].lidx); 519 p_cb->rcb[i].status |= BTA_AV_RC_CONN_MASK; 520 521 if(!shdl && 0 == p_cb->lcb[BTA_AV_NUM_LINKS].lidx) 522 { 523 /* no associated SCB -> connected to an RC only device 524 * update the index to the extra LCB */ 525 p_lcb = &p_cb->lcb[BTA_AV_NUM_LINKS]; 526 bdcpy(p_lcb->addr, p_data->rc_conn_chg.peer_addr); 527 APPL_TRACE_DEBUG6("rc_only bd_addr:%02x-%02x-%02x-%02x-%02x-%02x", 528 p_lcb->addr[0], p_lcb->addr[1], 529 p_lcb->addr[2], p_lcb->addr[3], 530 p_lcb->addr[4], p_lcb->addr[5]); 531 p_lcb->lidx = BTA_AV_NUM_LINKS + 1; 532 p_cb->rcb[i].lidx = p_lcb->lidx; 533 p_lcb->conn_msk = 1; 534 APPL_TRACE_ERROR3("rcb[%d].lidx=%d, lcb.conn_msk=x%x", 535 i, p_cb->rcb[i].lidx, p_lcb->conn_msk); 536 disc = p_data->rc_conn_chg.handle|BTA_AV_CHNL_MSK; 537 } 538 539 bdcpy(rc_open.peer_addr, p_data->rc_conn_chg.peer_addr); 540 rc_open.peer_features = p_cb->rcb[i].peer_features; 541 rc_open.status = BTA_AV_SUCCESS; 542 APPL_TRACE_DEBUG2("local features:x%x peer_features:x%x", p_cb->features, 543 rc_open.peer_features); 544 if(rc_open.peer_features == 0) 545 { 546 /* we have not done SDP on peer RC capabilities. 547 * peer must have initiated the RC connection */ 548 rc_open.peer_features = BTA_AV_FEAT_RCCT; 549 bta_av_rc_disc(disc); 550 } 551 (*p_cb->p_cback)(BTA_AV_RC_OPEN_EVT, (tBTA_AV *) &rc_open); 552 553 } 554 555 556 /******************************************************************************* 557 ** 558 ** Function bta_av_rc_remote_cmd 559 ** 560 ** Description Send an AVRCP remote control command. 561 ** 562 ** Returns void 563 ** 564 *******************************************************************************/ 565 void bta_av_rc_remote_cmd(tBTA_AV_CB *p_cb, tBTA_AV_DATA *p_data) 566 { 567 tBTA_AV_RCB *p_rcb; 568 if (p_cb->features & BTA_AV_FEAT_RCCT) 569 { 570 if(p_data->hdr.layer_specific < BTA_AV_NUM_RCB) 571 { 572 p_rcb = &p_cb->rcb[p_data->hdr.layer_specific]; 573 if(p_rcb->status & BTA_AV_RC_CONN_MASK) 574 { 575 AVRC_PassCmd(p_rcb->handle, p_data->api_remote_cmd.label, 576 &p_data->api_remote_cmd.msg); 577 } 578 } 579 } 580 } 581 582 /******************************************************************************* 583 ** 584 ** Function bta_av_rc_vendor_cmd 585 ** 586 ** Description Send an AVRCP vendor specific command. 587 ** 588 ** Returns void 589 ** 590 *******************************************************************************/ 591 void bta_av_rc_vendor_cmd(tBTA_AV_CB *p_cb, tBTA_AV_DATA *p_data) 592 { 593 tBTA_AV_RCB *p_rcb; 594 if ( (p_cb->features & (BTA_AV_FEAT_RCCT | BTA_AV_FEAT_VENDOR)) == 595 (BTA_AV_FEAT_RCCT | BTA_AV_FEAT_VENDOR)) 596 { 597 if(p_data->hdr.layer_specific < BTA_AV_NUM_RCB) 598 { 599 p_rcb = &p_cb->rcb[p_data->hdr.layer_specific]; 600 AVRC_VendorCmd(p_rcb->handle, p_data->api_vendor.label, &p_data->api_vendor.msg); 601 } 602 } 603 } 604 605 /******************************************************************************* 606 ** 607 ** Function bta_av_rc_vendor_rsp 608 ** 609 ** Description Send an AVRCP vendor specific response. 610 ** 611 ** Returns void 612 ** 613 *******************************************************************************/ 614 void bta_av_rc_vendor_rsp(tBTA_AV_CB *p_cb, tBTA_AV_DATA *p_data) 615 { 616 tBTA_AV_RCB *p_rcb; 617 if ( (p_cb->features & (BTA_AV_FEAT_RCTG | BTA_AV_FEAT_VENDOR)) == 618 (BTA_AV_FEAT_RCTG | BTA_AV_FEAT_VENDOR)) 619 { 620 if(p_data->hdr.layer_specific < BTA_AV_NUM_RCB) 621 { 622 p_rcb = &p_cb->rcb[p_data->hdr.layer_specific]; 623 AVRC_VendorRsp(p_rcb->handle, p_data->api_vendor.label, &p_data->api_vendor.msg); 624 } 625 } 626 } 627 628 /******************************************************************************* 629 ** 630 ** Function bta_av_rc_meta_rsp 631 ** 632 ** Description Send an AVRCP metadata/advanced control command/response. 633 ** 634 ** Returns void 635 ** 636 *******************************************************************************/ 637 void bta_av_rc_meta_rsp(tBTA_AV_CB *p_cb, tBTA_AV_DATA *p_data) 638 { 639 tBTA_AV_RCB *p_rcb; 640 BOOLEAN free = TRUE; 641 642 if ((p_cb->features & BTA_AV_FEAT_METADATA) && (p_data->hdr.layer_specific < BTA_AV_NUM_RCB)) 643 { 644 if ((p_data->api_meta_rsp.is_rsp && (p_cb->features & BTA_AV_FEAT_RCTG)) || 645 (!p_data->api_meta_rsp.is_rsp && (p_cb->features & BTA_AV_FEAT_RCCT)) ) 646 { 647 p_rcb = &p_cb->rcb[p_data->hdr.layer_specific]; 648 AVRC_MsgReq(p_rcb->handle, p_data->api_meta_rsp.label, p_data->api_meta_rsp.rsp_code, 649 p_data->api_meta_rsp.p_pkt); 650 free = FALSE; 651 } 652 } 653 654 if (free) 655 GKI_freebuf (p_data->api_meta_rsp.p_pkt); 656 } 657 658 /******************************************************************************* 659 ** 660 ** Function bta_av_rc_free_rsp 661 ** 662 ** Description free an AVRCP metadata command buffer. 663 ** 664 ** Returns void 665 ** 666 *******************************************************************************/ 667 void bta_av_rc_free_rsp (tBTA_AV_CB *p_cb, tBTA_AV_DATA *p_data) 668 { 669 GKI_freebuf (p_data->api_meta_rsp.p_pkt); 670 } 671 672 /******************************************************************************* 673 ** 674 ** Function bta_av_rc_meta_req 675 ** 676 ** Description Send an AVRCP metadata command. 677 ** 678 ** Returns void 679 ** 680 *******************************************************************************/ 681 void bta_av_rc_free_msg (tBTA_AV_CB *p_cb, tBTA_AV_DATA *p_data) 682 { 683 } 684 685 686 687 /******************************************************************************* 688 ** 689 ** Function bta_av_chk_notif_evt_id 690 ** 691 ** Description make sure the requested player id is valid. 692 ** 693 ** Returns BTA_AV_STS_NO_RSP, if no error 694 ** 695 *******************************************************************************/ 696 static tAVRC_STS bta_av_chk_notif_evt_id(tAVRC_MSG_VENDOR *p_vendor) 697 { 698 tAVRC_STS status = BTA_AV_STS_NO_RSP; 699 UINT8 xx; 700 UINT16 u16; 701 UINT8 *p = p_vendor->p_vendor_data + 2; 702 703 BE_STREAM_TO_UINT16 (u16, p); 704 /* double check the fixed length */ 705 if ((u16 != 5) || (p_vendor->vendor_len != 9)) 706 { 707 status = AVRC_STS_INTERNAL_ERR; 708 } 709 else 710 { 711 /* make sure the player_id is valid */ 712 for (xx=0; xx<p_bta_av_cfg->num_evt_ids; xx++) 713 { 714 if (*p == p_bta_av_cfg->p_meta_evt_ids[xx]) 715 { 716 break; 717 } 718 } 719 if (xx == p_bta_av_cfg->num_evt_ids) 720 { 721 status = AVRC_STS_BAD_PARAM; 722 } 723 } 724 725 return status; 726 } 727 728 /******************************************************************************* 729 ** 730 ** Function bta_av_proc_meta_cmd 731 ** 732 ** Description Process an AVRCP metadata command from the peer. 733 ** 734 ** Returns TRUE to respond immediately 735 ** 736 *******************************************************************************/ 737 tBTA_AV_EVT bta_av_proc_meta_cmd(tAVRC_RESPONSE *p_rc_rsp, tBTA_AV_RC_MSG *p_msg, UINT8 *p_ctype) 738 { 739 tBTA_AV_EVT evt = BTA_AV_META_MSG_EVT; 740 UINT8 u8, pdu, *p; 741 UINT16 u16; 742 tAVRC_MSG_VENDOR *p_vendor = &p_msg->msg.vendor; 743 744 pdu = *(p_vendor->p_vendor_data); 745 p_rc_rsp->pdu = pdu; 746 *p_ctype = AVRC_RSP_REJ; 747 /* Metadata messages only use PANEL sub-unit type */ 748 if (p_vendor->hdr.subunit_type != AVRC_SUB_PANEL) 749 { 750 APPL_TRACE_DEBUG0("SUBUNIT must be PANEL"); 751 /* reject it */ 752 evt=0; 753 p_vendor->hdr.ctype = BTA_AV_RSP_NOT_IMPL; 754 AVRC_VendorRsp(p_msg->handle, p_msg->label, &p_msg->msg.vendor); 755 } 756 else 757 { 758 switch (pdu) 759 { 760 case AVRC_PDU_GET_CAPABILITIES: 761 /* process GetCapabilities command without reporting the event to app */ 762 evt = 0; 763 u8 = *(p_vendor->p_vendor_data + 4); 764 p = p_vendor->p_vendor_data + 2; 765 p_rc_rsp->get_caps.capability_id = u8; 766 BE_STREAM_TO_UINT16 (u16, p); 767 if ((u16 != 1) || (p_vendor->vendor_len != 5)) 768 { 769 p_rc_rsp->get_caps.status = AVRC_STS_INTERNAL_ERR; 770 } 771 else 772 { 773 p_rc_rsp->get_caps.status = AVRC_STS_NO_ERROR; 774 if (u8 == AVRC_CAP_COMPANY_ID) 775 { 776 *p_ctype = AVRC_RSP_IMPL_STBL; 777 p_rc_rsp->get_caps.count = p_bta_av_cfg->num_co_ids; 778 memcpy(p_rc_rsp->get_caps.param.company_id, p_bta_av_cfg->p_meta_co_ids, 779 (p_bta_av_cfg->num_co_ids << 2)); 780 } 781 else if (u8 == AVRC_CAP_EVENTS_SUPPORTED) 782 { 783 *p_ctype = AVRC_RSP_IMPL_STBL; 784 p_rc_rsp->get_caps.count = p_bta_av_cfg->num_evt_ids; 785 memcpy(p_rc_rsp->get_caps.param.event_id, p_bta_av_cfg->p_meta_evt_ids, 786 p_bta_av_cfg->num_evt_ids); 787 } 788 else 789 { 790 APPL_TRACE_DEBUG1("Invalid capability ID: 0x%x", u8); 791 /* reject - unknown capability ID */ 792 p_rc_rsp->get_caps.status = AVRC_STS_BAD_PARAM; 793 } 794 } 795 break; 796 797 798 case AVRC_PDU_REGISTER_NOTIFICATION: 799 /* make sure the event_id is implemented */ 800 p_rc_rsp->rsp.status = bta_av_chk_notif_evt_id (p_vendor); 801 if (p_rc_rsp->rsp.status != BTA_AV_STS_NO_RSP) 802 evt = 0; 803 break; 804 805 } 806 } 807 808 return evt; 809 } 810 811 812 /******************************************************************************* 813 ** 814 ** Function bta_av_rc_msg 815 ** 816 ** Description Process an AVRCP message from the peer. 817 ** 818 ** Returns void 819 ** 820 *******************************************************************************/ 821 void bta_av_rc_msg(tBTA_AV_CB *p_cb, tBTA_AV_DATA *p_data) 822 { 823 tBTA_AV_EVT evt = 0; 824 tBTA_AV av; 825 BT_HDR *p_pkt = NULL; 826 tAVRC_MSG_VENDOR *p_vendor = &p_data->rc_msg.msg.vendor; 827 828 if (p_data->rc_msg.opcode == AVRC_OP_PASS_THRU) 829 { 830 /* if this is a pass thru command */ 831 if (p_data->rc_msg.msg.hdr.ctype == AVRC_CMD_CTRL) 832 { 833 /* check if operation is supported */ 834 if (p_data->rc_msg.msg.pass.op_id == AVRC_ID_VENDOR) 835 { 836 p_data->rc_msg.msg.hdr.ctype = BTA_AV_RSP_NOT_IMPL; 837 } 838 else 839 { 840 p_data->rc_msg.msg.hdr.ctype = bta_av_op_supported(p_data->rc_msg.msg.pass.op_id); 841 } 842 843 /* send response */ 844 if (p_data->rc_msg.msg.hdr.ctype != BTA_AV_RSP_INTERIM) 845 AVRC_PassRsp(p_data->rc_msg.handle, p_data->rc_msg.label, &p_data->rc_msg.msg.pass); 846 847 /* set up for callback if supported */ 848 if (p_data->rc_msg.msg.hdr.ctype == BTA_AV_RSP_ACCEPT || p_data->rc_msg.msg.hdr.ctype == BTA_AV_RSP_INTERIM) 849 { 850 evt = BTA_AV_REMOTE_CMD_EVT; 851 av.remote_cmd.rc_id = p_data->rc_msg.msg.pass.op_id; 852 av.remote_cmd.key_state = p_data->rc_msg.msg.pass.state; 853 av.remote_cmd.p_data = p_data->rc_msg.msg.pass.p_pass_data; 854 av.remote_cmd.len = p_data->rc_msg.msg.pass.pass_len; 855 memcpy(&av.remote_cmd.hdr, &p_data->rc_msg.msg.hdr, sizeof (tAVRC_HDR)); 856 av.remote_cmd.label = p_data->rc_msg.label; 857 } 858 } 859 /* else if this is a pass thru response */ 860 else if (p_data->rc_msg.msg.hdr.ctype >= AVRC_RSP_ACCEPT) 861 { 862 /* set up for callback */ 863 evt = BTA_AV_REMOTE_RSP_EVT; 864 av.remote_rsp.rc_id = p_data->rc_msg.msg.pass.op_id; 865 av.remote_rsp.key_state = p_data->rc_msg.msg.pass.state; 866 av.remote_rsp.rsp_code = p_data->rc_msg.msg.hdr.ctype; 867 av.remote_rsp.label = p_data->rc_msg.label; 868 } 869 /* must be a bad ctype -> reject*/ 870 else 871 { 872 p_data->rc_msg.msg.hdr.ctype = BTA_AV_RSP_REJ; 873 AVRC_PassRsp(p_data->rc_msg.handle, p_data->rc_msg.label, &p_data->rc_msg.msg.pass); 874 } 875 } 876 /* else if this is a vendor specific command or response */ 877 else if (p_data->rc_msg.opcode == AVRC_OP_VENDOR) 878 { 879 /* set up for callback */ 880 av.vendor_cmd.code = p_data->rc_msg.msg.hdr.ctype; 881 av.vendor_cmd.company_id = p_vendor->company_id; 882 av.vendor_cmd.label = p_data->rc_msg.label; 883 av.vendor_cmd.p_data = p_vendor->p_vendor_data; 884 av.vendor_cmd.len = p_vendor->vendor_len; 885 886 /* if configured to support vendor specific and it's a command */ 887 if ((p_cb->features & BTA_AV_FEAT_VENDOR) && 888 p_data->rc_msg.msg.hdr.ctype <= AVRC_CMD_GEN_INQ) 889 { 890 evt = BTA_AV_VENDOR_CMD_EVT; 891 } 892 /* else if configured to support vendor specific and it's a response */ 893 else if ((p_cb->features & BTA_AV_FEAT_VENDOR) && 894 p_data->rc_msg.msg.hdr.ctype >= AVRC_RSP_ACCEPT) 895 { 896 evt = BTA_AV_VENDOR_RSP_EVT; 897 898 } 899 /* else if not configured to support vendor specific and it's a command */ 900 else if (!(p_cb->features & BTA_AV_FEAT_VENDOR) && 901 p_data->rc_msg.msg.hdr.ctype <= AVRC_CMD_GEN_INQ) 902 { 903 if(p_data->rc_msg.msg.vendor.p_vendor_data[0] == AVRC_PDU_INVALID) 904 { 905 /* reject it */ 906 p_data->rc_msg.msg.hdr.ctype = BTA_AV_RSP_REJ; 907 p_data->rc_msg.msg.vendor.p_vendor_data[4] = AVRC_STS_BAD_CMD; 908 } 909 else 910 p_data->rc_msg.msg.hdr.ctype = BTA_AV_RSP_NOT_IMPL; 911 AVRC_VendorRsp(p_data->rc_msg.handle, p_data->rc_msg.label, &p_data->rc_msg.msg.vendor); 912 } 913 } 914 915 /* call callback */ 916 if (evt != 0) 917 { 918 av.remote_cmd.rc_handle = p_data->rc_msg.handle; 919 (*p_cb->p_cback)(evt, &av); 920 } 921 } 922 923 /******************************************************************************* 924 ** 925 ** Function bta_av_rc_close 926 ** 927 ** Description close the specified AVRC handle. 928 ** 929 ** Returns void 930 ** 931 *******************************************************************************/ 932 void bta_av_rc_close (tBTA_AV_CB *p_cb, tBTA_AV_DATA *p_data) 933 { 934 UINT16 handle = p_data->hdr.layer_specific; 935 tBTA_AV_SCB *p_scb; 936 tBTA_AV_RCB *p_rcb; 937 938 if(handle < BTA_AV_NUM_RCB) 939 { 940 p_rcb = &p_cb->rcb[handle]; 941 942 APPL_TRACE_DEBUG2("bta_av_rc_close handle: %d, status=0x%x", p_rcb->handle, p_rcb->status); 943 if(p_rcb->handle != BTA_AV_RC_HANDLE_NONE) 944 { 945 if(p_rcb->shdl) 946 { 947 p_scb = bta_av_cb.p_scb[p_rcb->shdl - 1]; 948 if(p_scb) 949 { 950 /* just in case the RC timer is active 951 if(bta_av_cb.features & BTA_AV_FEAT_RCCT && 952 p_scb->chnl == BTA_AV_CHNL_AUDIO) */ 953 bta_sys_stop_timer(&p_scb->timer); 954 } 955 } 956 957 AVRC_Close(p_rcb->handle); 958 } 959 } 960 } 961 962 /******************************************************************************* 963 ** 964 ** Function bta_av_get_shdl 965 ** 966 ** Returns The index to p_scb[] 967 ** 968 *******************************************************************************/ 969 static UINT8 bta_av_get_shdl(tBTA_AV_SCB *p_scb) 970 { 971 int i; 972 UINT8 shdl = 0; 973 /* find the SCB & stop the timer */ 974 for(i=0; i<BTA_AV_NUM_STRS; i++) 975 { 976 if(p_scb == bta_av_cb.p_scb[i]) 977 { 978 shdl = i+1; 979 break; 980 } 981 } 982 return shdl; 983 } 984 985 /******************************************************************************* 986 ** 987 ** Function bta_av_stream_chg 988 ** 989 ** Description audio streaming status changed. 990 ** 991 ** Returns void 992 ** 993 *******************************************************************************/ 994 void bta_av_stream_chg(tBTA_AV_SCB *p_scb, BOOLEAN started) 995 { 996 UINT8 started_msk; 997 int i; 998 UINT8 *p_streams; 999 BOOLEAN no_streams = FALSE; 1000 tBTA_AV_SCB *p_scbi; 1001 1002 started_msk = BTA_AV_HNDL_TO_MSK(p_scb->hdi); 1003 APPL_TRACE_DEBUG3 ("bta_av_stream_chg started:%d started_msk:x%x chnl:x%x", started, 1004 started_msk, p_scb->chnl); 1005 if (BTA_AV_CHNL_AUDIO == p_scb->chnl) 1006 p_streams = &bta_av_cb.audio_streams; 1007 else 1008 p_streams = &bta_av_cb.video_streams; 1009 1010 if (started) 1011 { 1012 /* Let L2CAP know this channel is processed with high priority */ 1013 L2CA_SetAclPriority(p_scb->peer_addr, L2CAP_PRIORITY_HIGH); 1014 (*p_streams) |= started_msk; 1015 } 1016 else 1017 { 1018 (*p_streams) &= ~started_msk; 1019 } 1020 1021 if (!started) 1022 { 1023 i=0; 1024 if (BTA_AV_CHNL_AUDIO == p_scb->chnl) 1025 { 1026 if (bta_av_cb.video_streams == 0) 1027 no_streams = TRUE; 1028 } 1029 else 1030 { 1031 no_streams = TRUE; 1032 if ( bta_av_cb.audio_streams ) 1033 { 1034 for (; i<BTA_AV_NUM_STRS; i++) 1035 { 1036 p_scbi = bta_av_cb.p_scb[i]; 1037 /* scb is used and started */ 1038 if ( p_scbi && (bta_av_cb.audio_streams & BTA_AV_HNDL_TO_MSK(i)) 1039 && bdcmp(p_scbi->peer_addr, p_scb->peer_addr) == 0) 1040 { 1041 no_streams = FALSE; 1042 break; 1043 } 1044 } 1045 1046 } 1047 } 1048 1049 APPL_TRACE_DEBUG4 ("no_streams:%d i:%d, audio_streams:x%x, video_streams:x%x", no_streams, i, 1050 bta_av_cb.audio_streams, bta_av_cb.video_streams); 1051 if (no_streams) 1052 { 1053 /* Let L2CAP know this channel is processed with low priority */ 1054 L2CA_SetAclPriority(p_scb->peer_addr, L2CAP_PRIORITY_NORMAL); 1055 } 1056 } 1057 } 1058 1059 1060 /******************************************************************************* 1061 ** 1062 ** Function bta_av_conn_chg 1063 ** 1064 ** Description connetion status changed. 1065 ** Open an AVRCP acceptor channel, if new conn. 1066 ** 1067 ** Returns void 1068 ** 1069 *******************************************************************************/ 1070 void bta_av_conn_chg(tBTA_AV_DATA *p_data) 1071 { 1072 tBTA_AV_CB *p_cb = &bta_av_cb; 1073 tBTA_AV_SCB *p_scb; 1074 tBTA_AV_SCB *p_scbi; 1075 UINT8 mask; 1076 UINT8 conn_msk; 1077 UINT8 old_msk; 1078 int i; 1079 int index = (p_data->hdr.layer_specific & BTA_AV_HNDL_MSK) - 1; 1080 tBTA_AV_LCB *p_lcb; 1081 tBTA_AV_LCB *p_lcb_rc; 1082 tBTA_AV_RCB *p_rcb, *p_rcb2; 1083 BOOLEAN chk_restore = FALSE; 1084 1085 p_scb = p_cb->p_scb[index]; 1086 1087 mask = BTA_AV_HNDL_TO_MSK(index); 1088 p_lcb = bta_av_find_lcb(p_data->conn_chg.peer_addr, BTA_AV_LCB_FIND); 1089 conn_msk = 1 << (index + 1); 1090 if(p_data->conn_chg.is_up) 1091 { 1092 /* set the conned mask for this channel */ 1093 if(p_scb) 1094 { 1095 if(p_lcb) 1096 { 1097 p_lcb->conn_msk |= conn_msk; 1098 for (i=0; i<BTA_AV_NUM_RCB; i++) 1099 { 1100 if (bta_av_cb.rcb[i].lidx == p_lcb->lidx) 1101 { 1102 bta_av_cb.rcb[i].shdl = index + 1; 1103 APPL_TRACE_DEBUG5("conn_chg up[%d]: %d, status=0x%x, shdl:%d, lidx:%d", i, 1104 bta_av_cb.rcb[i].handle, bta_av_cb.rcb[i].status, 1105 bta_av_cb.rcb[i].shdl, bta_av_cb.rcb[i].lidx); 1106 break; 1107 } 1108 } 1109 } 1110 if (p_scb->chnl == BTA_AV_CHNL_AUDIO) 1111 { 1112 old_msk = p_cb->conn_audio; 1113 p_cb->conn_audio |= mask; 1114 } 1115 else 1116 { 1117 old_msk = p_cb->conn_video; 1118 p_cb->conn_video |= mask; 1119 } 1120 1121 if ((old_msk & mask) == 0) 1122 { 1123 /* increase the audio open count, if not set yet */ 1124 bta_av_cb.audio_open_cnt++; 1125 } 1126 1127 1128 APPL_TRACE_DEBUG2("rc_acp_handle:%d rc_acp_idx:%d", p_cb->rc_acp_handle, p_cb->rc_acp_idx); 1129 /* check if the AVRCP ACP channel is already connected */ 1130 if(p_lcb && p_cb->rc_acp_handle != BTA_AV_RC_HANDLE_NONE && p_cb->rc_acp_idx) 1131 { 1132 p_lcb_rc = &p_cb->lcb[BTA_AV_NUM_LINKS]; 1133 APPL_TRACE_DEBUG1("rc_acp is connected && conn_chg on same addr p_lcb_rc->conn_msk:x%x", 1134 p_lcb_rc->conn_msk); 1135 /* check if the RC is connected to the scb addr */ 1136 APPL_TRACE_DEBUG6 ("p_lcb_rc->addr: %02x:%02x:%02x:%02x:%02x:%02x", 1137 p_lcb_rc->addr[0], p_lcb_rc->addr[1], p_lcb_rc->addr[2], p_lcb_rc->addr[3], 1138 p_lcb_rc->addr[4], p_lcb_rc->addr[5]); 1139 APPL_TRACE_DEBUG6 ("conn_chg.peer_addr: %02x:%02x:%02x:%02x:%02x:%02x", 1140 p_data->conn_chg.peer_addr[0], p_data->conn_chg.peer_addr[1], 1141 p_data->conn_chg.peer_addr[2], 1142 p_data->conn_chg.peer_addr[3], p_data->conn_chg.peer_addr[4], 1143 p_data->conn_chg.peer_addr[5]); 1144 if (p_lcb_rc->conn_msk && bdcmp(p_lcb_rc->addr, p_data->conn_chg.peer_addr) == 0) 1145 { 1146 /* AVRCP is already connected. 1147 * need to update the association betwen SCB and RCB */ 1148 p_lcb_rc->conn_msk = 0; /* indicate RC ONLY is not connected */ 1149 p_lcb_rc->lidx = 0; 1150 p_scb->rc_handle = p_cb->rc_acp_handle; 1151 p_rcb = &p_cb->rcb[p_cb->rc_acp_idx - 1]; 1152 p_rcb->shdl = bta_av_get_shdl(p_scb); 1153 APPL_TRACE_DEBUG3("update rc_acp shdl:%d/%d srch:%d", index + 1, p_rcb->shdl, 1154 p_scb->rc_handle ); 1155 1156 p_rcb2 = bta_av_get_rcb_by_shdl(p_rcb->shdl); 1157 if (p_rcb2) 1158 { 1159 /* found the RCB that was created to associated with this SCB */ 1160 p_cb->rc_acp_handle = p_rcb2->handle; 1161 p_cb->rc_acp_idx = (p_rcb2 - p_cb->rcb) + 1; 1162 APPL_TRACE_DEBUG2("new rc_acp_handle:%d, idx:%d", p_cb->rc_acp_handle, 1163 p_cb->rc_acp_idx); 1164 p_rcb2->lidx = (BTA_AV_NUM_LINKS + 1); 1165 APPL_TRACE_DEBUG3("rc2 handle:%d lidx:%d/%d",p_rcb2->handle, p_rcb2->lidx, 1166 p_cb->lcb[p_rcb2->lidx-1].lidx); 1167 } 1168 p_rcb->lidx = p_lcb->lidx; 1169 APPL_TRACE_DEBUG3("rc handle:%d lidx:%d/%d",p_rcb->handle, p_rcb->lidx, 1170 p_cb->lcb[p_rcb->lidx-1].lidx); 1171 } 1172 } 1173 } 1174 } 1175 else 1176 { 1177 if ((p_cb->conn_audio & mask) && bta_av_cb.audio_open_cnt) 1178 { 1179 /* this channel is still marked as open. decrease the count */ 1180 bta_av_cb.audio_open_cnt--; 1181 } 1182 1183 /* clear the conned mask for this channel */ 1184 p_cb->conn_audio &= ~mask; 1185 p_cb->conn_video &= ~mask; 1186 if(p_scb) 1187 { 1188 /* the stream is closed. 1189 * clear the peer address, so it would not mess up the AVRCP for the next round of operation */ 1190 bdcpy(p_scb->peer_addr, bd_addr_null); 1191 if(p_scb->chnl == BTA_AV_CHNL_AUDIO) 1192 { 1193 if(p_lcb) 1194 { 1195 p_lcb->conn_msk &= ~conn_msk; 1196 } 1197 /* audio channel is down. make sure the INT channel is down */ 1198 /* just in case the RC timer is active 1199 if(p_cb->features & BTA_AV_FEAT_RCCT) */ 1200 { 1201 bta_sys_stop_timer(&p_scb->timer); 1202 } 1203 /* one audio channel goes down. check if we need to restore high priority */ 1204 chk_restore = TRUE; 1205 } 1206 } 1207 1208 APPL_TRACE_DEBUG1("bta_av_conn_chg shdl:%d", index + 1); 1209 for (i=0; i<BTA_AV_NUM_RCB; i++) 1210 { 1211 APPL_TRACE_DEBUG5("conn_chg dn[%d]: %d, status=0x%x, shdl:%d, lidx:%d", i, 1212 bta_av_cb.rcb[i].handle, bta_av_cb.rcb[i].status, 1213 bta_av_cb.rcb[i].shdl, bta_av_cb.rcb[i].lidx); 1214 if(bta_av_cb.rcb[i].shdl == index + 1) 1215 { 1216 bta_av_del_rc(&bta_av_cb.rcb[i]); 1217 break; 1218 } 1219 } 1220 1221 if(p_cb->conn_audio == 0 && p_cb->conn_video == 0) 1222 { 1223 /* if both channels are not connected, 1224 * close all RC channels */ 1225 bta_av_close_all_rc(p_cb); 1226 } 1227 1228 /* if the AVRCP is no longer listening, create the listening channel */ 1229 if (bta_av_cb.rc_acp_handle == BTA_AV_RC_HANDLE_NONE && bta_av_cb.features & BTA_AV_FEAT_RCTG) 1230 bta_av_rc_create(&bta_av_cb, AVCT_ACP, 0, BTA_AV_NUM_LINKS + 1); 1231 } 1232 1233 APPL_TRACE_DEBUG6("bta_av_conn_chg audio:%x video:%x up:%d conn_msk:0x%x chk_restore:%d audio_open_cnt:%d", 1234 p_cb->conn_audio, p_cb->conn_video, p_data->conn_chg.is_up, conn_msk, chk_restore, p_cb->audio_open_cnt); 1235 1236 if (chk_restore) 1237 { 1238 if (p_cb->audio_open_cnt == 1) 1239 { 1240 /* one audio channel goes down and there's one audio channel remains open. 1241 * restore the switch role in default link policy */ 1242 bta_sys_set_default_policy(BTA_ID_AV, HCI_ENABLE_MASTER_SLAVE_SWITCH); 1243 /* allow role switch, if this is the last connection */ 1244 bta_av_restore_switch(); 1245 } 1246 if (p_cb->audio_open_cnt) 1247 { 1248 /* adjust flush timeout settings to longer period */ 1249 for (i=0; i<BTA_AV_NUM_STRS; i++) 1250 { 1251 p_scbi = bta_av_cb.p_scb[i]; 1252 if (p_scbi && p_scbi->chnl == BTA_AV_CHNL_AUDIO && p_scbi->co_started) 1253 { 1254 /* may need to update the flush timeout of this already started stream */ 1255 if (p_scbi->co_started != bta_av_cb.audio_open_cnt) 1256 { 1257 p_scbi->co_started = bta_av_cb.audio_open_cnt; 1258 L2CA_SetFlushTimeout(p_scbi->peer_addr, p_bta_av_cfg->p_audio_flush_to[p_scbi->co_started - 1] ); 1259 } 1260 } 1261 } 1262 } 1263 } 1264 } 1265 1266 /******************************************************************************* 1267 ** 1268 ** Function bta_av_disable 1269 ** 1270 ** Description disable AV. 1271 ** 1272 ** Returns void 1273 ** 1274 *******************************************************************************/ 1275 void bta_av_disable(tBTA_AV_CB *p_cb, tBTA_AV_DATA *p_data) 1276 { 1277 BT_HDR hdr; 1278 UINT16 xx; 1279 1280 p_cb->disabling = TRUE; 1281 1282 bta_av_close_all_rc(p_cb); 1283 1284 utl_freebuf((void **) &p_cb->p_disc_db); 1285 1286 /* disable audio/video - de-register all channels, 1287 * expect BTA_AV_DEREG_COMP_EVT when deregister is complete */ 1288 for(xx=0; xx<BTA_AV_NUM_STRS; xx++) 1289 { 1290 hdr.layer_specific = xx + 1; 1291 bta_av_api_deregister((tBTA_AV_DATA *)&hdr); 1292 } 1293 } 1294 1295 /******************************************************************************* 1296 ** 1297 ** Function bta_av_api_disconnect 1298 ** 1299 ** Description . 1300 ** 1301 ** Returns void 1302 ** 1303 *******************************************************************************/ 1304 void bta_av_api_disconnect(tBTA_AV_DATA *p_data) 1305 { 1306 AVDT_DisconnectReq(p_data->api_discnt.bd_addr, bta_av_conn_cback); 1307 bta_sys_stop_timer(&bta_av_cb.sig_tmr); 1308 } 1309 1310 /******************************************************************************* 1311 ** 1312 ** Function bta_av_sig_chg 1313 ** 1314 ** Description process AVDT signal channel up/down. 1315 ** 1316 ** Returns void 1317 ** 1318 *******************************************************************************/ 1319 void bta_av_sig_chg(tBTA_AV_DATA *p_data) 1320 { 1321 UINT16 event = p_data->str_msg.hdr.layer_specific; 1322 tBTA_AV_CB *p_cb = &bta_av_cb; 1323 int xx; 1324 UINT8 mask; 1325 tBTA_AV_LCB *p_lcb = NULL; 1326 1327 APPL_TRACE_DEBUG1("bta_av_sig_chg event: %d", event); 1328 if(event == AVDT_CONNECT_IND_EVT) 1329 { 1330 p_lcb = bta_av_find_lcb(p_data->str_msg.bd_addr, BTA_AV_LCB_FIND); 1331 if(!p_lcb) 1332 { 1333 /* if the address does not have an LCB yet, alloc one */ 1334 for(xx=0; xx<BTA_AV_NUM_LINKS; xx++) 1335 { 1336 mask = 1 << xx; 1337 APPL_TRACE_DEBUG1("conn_lcb: 0x%x", p_cb->conn_lcb); 1338 if(!(mask & p_cb->conn_lcb)) 1339 { 1340 if (!p_cb->p_scb[xx]) 1341 { 1342 /* We do not have scb for this avdt connection. */ 1343 /* Silently close the connection. */ 1344 APPL_TRACE_ERROR0("av scb not available for avdt connection"); 1345 AVDT_DisconnectReq (p_data->str_msg.bd_addr, NULL); 1346 return; 1347 } 1348 1349 p_lcb = &p_cb->lcb[xx]; 1350 p_lcb->lidx = xx + 1; 1351 bdcpy(p_lcb->addr, p_data->str_msg.bd_addr); 1352 p_lcb->conn_msk = 0; /* clear the connect mask */ 1353 /* start listening when the signal channel is open */ 1354 if (p_cb->features & BTA_AV_FEAT_RCTG) 1355 { 1356 bta_av_rc_create(p_cb, AVCT_ACP, 0, p_lcb->lidx); 1357 } 1358 /* this entry is not used yet. */ 1359 p_cb->conn_lcb |= mask; /* mark it as used */ 1360 APPL_TRACE_DEBUG1("start sig timer %d", p_data->hdr.offset); 1361 if (p_data->hdr.offset == AVDT_ACP) 1362 { 1363 APPL_TRACE_DEBUG1("Incoming L2CAP acquired, set state as incoming", NULL); 1364 bdcpy(p_cb->p_scb[xx]->peer_addr, p_data->str_msg.bd_addr); 1365 p_cb->p_scb[xx]->use_rc = TRUE; /* allowing RC for incoming connection */ 1366 bta_av_ssm_execute(p_cb->p_scb[xx], BTA_AV_ACP_CONNECT_EVT, p_data); 1367 1368 /* The Pending Event should be sent as soon as the L2CAP signalling channel 1369 * is set up, which is NOW. Earlier this was done only after 1370 * BTA_AV_SIG_TIME_VAL milliseconds. 1371 * The following function shall send the event and start the recurring timer 1372 */ 1373 bta_av_sig_timer(NULL); 1374 1375 /* Possible collision : need to avoid outgoing processing while the timer is running */ 1376 p_cb->p_scb[xx]->coll_mask = BTA_AV_COLL_INC_TMR; 1377 1378 p_cb->acp_sig_tmr.param = (UINT32)xx; 1379 p_cb->acp_sig_tmr.p_cback = (TIMER_CBACK*)&bta_av_acp_sig_timer_cback; 1380 bta_sys_start_timer(&p_cb->acp_sig_tmr, 0, BTA_AV_ACP_SIG_TIME_VAL); 1381 } 1382 break; 1383 } 1384 } 1385 } 1386 } 1387 #if( defined BTA_AR_INCLUDED ) && (BTA_AR_INCLUDED == TRUE) 1388 else if (event == BTA_AR_AVDT_CONN_EVT) 1389 { 1390 bta_sys_stop_timer(&bta_av_cb.sig_tmr); 1391 } 1392 #endif 1393 else 1394 { 1395 /* disconnected. */ 1396 p_lcb = bta_av_find_lcb(p_data->str_msg.bd_addr, BTA_AV_LCB_FREE); 1397 if(p_lcb && p_lcb->conn_msk) 1398 { 1399 APPL_TRACE_DEBUG1("conn_msk: 0x%x", p_lcb->conn_msk); 1400 /* clean up ssm */ 1401 for(xx=0; xx < BTA_AV_NUM_STRS; xx++) 1402 { 1403 mask = 1 << (xx + 1); 1404 if ((mask & p_lcb->conn_msk) && (p_cb->p_scb[xx]) && 1405 (bdcmp(p_cb->p_scb[xx]->peer_addr, p_data->str_msg.bd_addr) == 0)) 1406 { 1407 bta_av_ssm_execute(p_cb->p_scb[xx], BTA_AV_AVDT_DISCONNECT_EVT, NULL); 1408 } 1409 } 1410 } 1411 } 1412 APPL_TRACE_DEBUG1("conn_lcb: 0x%x", p_cb->conn_lcb); 1413 } 1414 1415 /******************************************************************************* 1416 ** 1417 ** Function bta_av_sig_timer 1418 ** 1419 ** Description process the signal channel timer. This timer is started 1420 ** when the AVDTP signal channel is connected. If no profile 1421 ** is connected, the timer goes off every BTA_AV_SIG_TIME_VAL 1422 ** 1423 ** Returns void 1424 ** 1425 *******************************************************************************/ 1426 void bta_av_sig_timer(tBTA_AV_DATA *p_data) 1427 { 1428 tBTA_AV_CB *p_cb = &bta_av_cb; 1429 int xx; 1430 UINT8 mask; 1431 tBTA_AV_LCB *p_lcb = NULL; 1432 tBTA_AV_PEND pend; 1433 1434 APPL_TRACE_DEBUG0("bta_av_sig_timer"); 1435 for(xx=0; xx<BTA_AV_NUM_LINKS; xx++) 1436 { 1437 mask = 1 << xx; 1438 if(mask & p_cb->conn_lcb) 1439 { 1440 /* this entry is used. check if it is connected */ 1441 p_lcb = &p_cb->lcb[xx]; 1442 if(!p_lcb->conn_msk) 1443 { 1444 bta_sys_start_timer(&p_cb->sig_tmr, BTA_AV_SIG_TIMER_EVT, BTA_AV_SIG_TIME_VAL); 1445 bdcpy(pend.bd_addr, p_lcb->addr); 1446 (*p_cb->p_cback)(BTA_AV_PENDING_EVT, (tBTA_AV *) &pend); 1447 } 1448 } 1449 } 1450 } 1451 1452 /******************************************************************************* 1453 ** 1454 ** Function bta_av_acp_sig_timer_cback 1455 ** 1456 ** Description Process the timeout when SRC is accepting connection 1457 ** and SNK did not start signalling. 1458 ** 1459 ** Returns void 1460 ** 1461 *******************************************************************************/ 1462 static void bta_av_acp_sig_timer_cback (TIMER_LIST_ENT *p_tle) 1463 { 1464 UINT8 inx = (UINT8)p_tle->param; 1465 tBTA_AV_CB *p_cb = &bta_av_cb; 1466 tBTA_AV_SCB *p_scb = p_cb->p_scb[inx]; 1467 tBTA_AV_API_OPEN *p_buf; 1468 1469 if (p_scb) 1470 { 1471 APPL_TRACE_DEBUG1("bta_av_acp_sig_timer_cback, coll_mask = 0x%02X", p_scb->coll_mask); 1472 1473 if (p_scb->coll_mask & BTA_AV_COLL_INC_TMR) 1474 { 1475 p_scb->coll_mask &= ~BTA_AV_COLL_INC_TMR; 1476 1477 if (bta_av_is_scb_opening(p_scb)) 1478 { 1479 if (p_scb->p_disc_db) 1480 { 1481 /* We are still doing SDP. Run the timer again. */ 1482 p_scb->coll_mask |= BTA_AV_COLL_INC_TMR; 1483 1484 p_cb->acp_sig_tmr.param = (UINT32)inx; 1485 p_cb->acp_sig_tmr.p_cback = (TIMER_CBACK *)&bta_av_acp_sig_timer_cback; 1486 bta_sys_start_timer(&p_cb->acp_sig_tmr, 0, BTA_AV_ACP_SIG_TIME_VAL); 1487 } 1488 else 1489 { 1490 /* SNK did not start signalling, resume signalling process. */ 1491 bta_av_discover_req (p_scb, NULL); 1492 } 1493 } 1494 else if (bta_av_is_scb_incoming(p_scb)) 1495 { 1496 /* Stay in incoming state if SNK does not start signalling */ 1497 1498 /* API open was called right after SNK opened L2C connection. */ 1499 if (p_scb->coll_mask & BTA_AV_COLL_API_CALLED) 1500 { 1501 p_scb->coll_mask &= ~BTA_AV_COLL_API_CALLED; 1502 1503 /* BTA_AV_API_OPEN_EVT */ 1504 if ((p_buf = (tBTA_AV_API_OPEN *) GKI_getbuf(sizeof(tBTA_AV_API_OPEN))) != NULL) 1505 { 1506 memcpy(p_buf, &(p_scb->open_api), sizeof(tBTA_AV_API_OPEN)); 1507 bta_sys_sendmsg(p_buf); 1508 } 1509 } 1510 } 1511 } 1512 } 1513 } 1514 1515 /******************************************************************************* 1516 ** 1517 ** Function bta_av_check_peer_features 1518 ** 1519 ** Description checks 1520 ** 1521 ** Returns void 1522 ** 1523 *******************************************************************************/ 1524 tBTA_AV_FEAT bta_av_check_peer_features (UINT16 service_uuid) 1525 { 1526 tBTA_AV_FEAT peer_features = 0; 1527 tBTA_AV_CB *p_cb = &bta_av_cb; 1528 tSDP_DISC_REC *p_rec = NULL; 1529 tSDP_DISC_ATTR *p_attr; 1530 UINT16 peer_rc_version=0; 1531 UINT16 categories = 0; 1532 1533 APPL_TRACE_DEBUG1("bta_av_check_peer_features service_uuid:x%x", service_uuid); 1534 /* loop through all records we found */ 1535 while (TRUE) 1536 { 1537 /* get next record; if none found, we're done */ 1538 if ((p_rec = SDP_FindServiceInDb(p_cb->p_disc_db, service_uuid, p_rec)) == NULL) 1539 { 1540 break; 1541 } 1542 1543 if (( SDP_FindAttributeInRec(p_rec, ATTR_ID_SERVICE_CLASS_ID_LIST)) != NULL) 1544 { 1545 /* find peer features */ 1546 if (SDP_FindServiceInDb(p_cb->p_disc_db, UUID_SERVCLASS_AV_REMOTE_CONTROL, NULL)) 1547 { 1548 peer_features |= BTA_AV_FEAT_RCCT; 1549 } 1550 if (SDP_FindServiceInDb(p_cb->p_disc_db, UUID_SERVCLASS_AV_REM_CTRL_TARGET, NULL)) 1551 { 1552 peer_features |= BTA_AV_FEAT_RCTG; 1553 } 1554 } 1555 1556 if (( SDP_FindAttributeInRec(p_rec, ATTR_ID_BT_PROFILE_DESC_LIST)) != NULL) 1557 { 1558 /* get profile version (if failure, version parameter is not updated) */ 1559 SDP_FindProfileVersionInRec(p_rec, UUID_SERVCLASS_AV_REMOTE_CONTROL, &peer_rc_version); 1560 APPL_TRACE_DEBUG1("peer_rc_version 0x%x", peer_rc_version); 1561 1562 if (peer_rc_version >= AVRC_REV_1_3) 1563 peer_features |= (BTA_AV_FEAT_VENDOR | BTA_AV_FEAT_METADATA); 1564 1565 if (peer_rc_version >= AVRC_REV_1_4) 1566 { 1567 peer_features |= (BTA_AV_FEAT_ADV_CTRL); 1568 /* get supported categories */ 1569 if ((p_attr = SDP_FindAttributeInRec(p_rec, 1570 ATTR_ID_SUPPORTED_FEATURES)) != NULL) 1571 { 1572 categories = p_attr->attr_value.v.u16; 1573 if (categories & AVRC_SUPF_CT_BROWSE) 1574 peer_features |= (BTA_AV_FEAT_BROWSE); 1575 } 1576 } 1577 } 1578 } 1579 APPL_TRACE_DEBUG1("peer_features:x%x", peer_features); 1580 return peer_features; 1581 } 1582 1583 /******************************************************************************* 1584 ** 1585 ** Function bta_av_rc_disc_done 1586 ** 1587 ** Description Handle AVRCP service discovery results. If matching 1588 ** service found, open AVRCP connection. 1589 ** 1590 ** Returns void 1591 ** 1592 *******************************************************************************/ 1593 void bta_av_rc_disc_done(tBTA_AV_DATA *p_data) 1594 { 1595 tBTA_AV_CB *p_cb = &bta_av_cb; 1596 tBTA_AV_SCB *p_scb = NULL; 1597 tBTA_AV_LCB *p_lcb; 1598 tBTA_AV_RC_OPEN rc_open; 1599 tBTA_AV_RC_FEAT rc_feat; 1600 UINT8 rc_handle; 1601 tBTA_AV_FEAT peer_features; /* peer features mask */ 1602 1603 APPL_TRACE_DEBUG1("bta_av_rc_disc_done disc:x%x", p_cb->disc); 1604 if (!p_cb->disc) 1605 { 1606 return; 1607 } 1608 1609 if ((p_cb->disc & BTA_AV_CHNL_MSK) == BTA_AV_CHNL_MSK) 1610 { 1611 /* this is the rc handle/index to tBTA_AV_RCB */ 1612 rc_handle = p_cb->disc & (~BTA_AV_CHNL_MSK); 1613 } 1614 else 1615 { 1616 p_scb = p_cb->p_scb[(p_cb->disc & BTA_AV_HNDL_MSK) - 1]; 1617 if (p_scb) 1618 rc_handle = p_scb->rc_handle; 1619 else 1620 { 1621 p_cb->disc = 0; 1622 return; 1623 } 1624 } 1625 1626 APPL_TRACE_DEBUG1("rc_handle %d", rc_handle); 1627 peer_features = bta_av_check_peer_features (UUID_SERVCLASS_AV_REMOTE_CONTROL); 1628 if ((p_cb->features & BTA_AV_FEAT_ADV_CTRL) && ((peer_features&BTA_AV_FEAT_ADV_CTRL) == 0)) 1629 { 1630 /* if we support advance control and peer does not, check their support on TG role 1631 * some implementation uses 1.3 on CT ans 1.4 on TG */ 1632 peer_features |= bta_av_check_peer_features (UUID_SERVCLASS_AV_REM_CTRL_TARGET); 1633 } 1634 1635 p_cb->disc = 0; 1636 utl_freebuf((void **) &p_cb->p_disc_db); 1637 1638 APPL_TRACE_DEBUG2("peer_features 0x%x, features 0x%x", peer_features, p_cb->features); 1639 1640 /* if we have no rc connection */ 1641 if (rc_handle == BTA_AV_RC_HANDLE_NONE) 1642 { 1643 if (p_scb) 1644 { 1645 /* if peer remote control service matches ours and USE_RC is TRUE */ 1646 if ((((p_cb->features & BTA_AV_FEAT_RCCT) && (peer_features & BTA_AV_FEAT_RCTG)) || 1647 ((p_cb->features & BTA_AV_FEAT_RCTG) && (peer_features & BTA_AV_FEAT_RCCT))) ) 1648 { 1649 p_lcb = bta_av_find_lcb(p_scb->peer_addr, BTA_AV_LCB_FIND); 1650 if(p_lcb) 1651 { 1652 rc_handle = bta_av_rc_create(p_cb, AVCT_INT, (UINT8)(p_scb->hdi + 1), p_lcb->lidx); 1653 p_cb->rcb[rc_handle].peer_features = peer_features; 1654 } 1655 #if (BT_USE_TRACES == TRUE || BT_TRACE_APPL == TRUE) 1656 else 1657 { 1658 APPL_TRACE_ERROR0("can not find LCB!!"); 1659 } 1660 #endif 1661 } 1662 else if(p_scb->use_rc) 1663 { 1664 /* can not find AVRC on peer device. report failure */ 1665 p_scb->use_rc = FALSE; 1666 bdcpy(rc_open.peer_addr, p_scb->peer_addr); 1667 rc_open.peer_features = 0; 1668 rc_open.status = BTA_AV_FAIL_SDP; 1669 (*p_cb->p_cback)(BTA_AV_RC_OPEN_EVT, (tBTA_AV *) &rc_open); 1670 } 1671 } 1672 } 1673 else 1674 { 1675 p_cb->rcb[rc_handle].peer_features = peer_features; 1676 rc_feat.rc_handle = rc_handle; 1677 rc_feat.peer_features = peer_features; 1678 (*p_cb->p_cback)(BTA_AV_RC_FEAT_EVT, (tBTA_AV *) &rc_feat); 1679 } 1680 } 1681 1682 /******************************************************************************* 1683 ** 1684 ** Function bta_av_rc_closed 1685 ** 1686 ** Description Set AVRCP state to closed. 1687 ** 1688 ** Returns void 1689 ** 1690 *******************************************************************************/ 1691 void bta_av_rc_closed(tBTA_AV_DATA *p_data) 1692 { 1693 tBTA_AV_CB *p_cb = &bta_av_cb; 1694 tBTA_AV_RC_CLOSE rc_close; 1695 tBTA_AV_RC_CONN_CHG *p_msg = (tBTA_AV_RC_CONN_CHG *)p_data; 1696 tBTA_AV_RCB *p_rcb; 1697 tBTA_AV_SCB *p_scb; 1698 int i; 1699 BOOLEAN conn = FALSE; 1700 tBTA_AV_LCB *p_lcb; 1701 1702 rc_close.rc_handle = BTA_AV_RC_HANDLE_NONE; 1703 APPL_TRACE_DEBUG1("bta_av_rc_closed rc_handle:%d", p_msg->handle); 1704 for(i=0; i<BTA_AV_NUM_RCB; i++) 1705 { 1706 p_rcb = &p_cb->rcb[i]; 1707 APPL_TRACE_DEBUG3("bta_av_rc_closed rcb[%d] rc_handle:%d, status=0x%x", i, p_rcb->handle, p_rcb->status); 1708 if(p_rcb->handle == p_msg->handle) 1709 { 1710 rc_close.rc_handle = i; 1711 p_rcb->status &= ~BTA_AV_RC_CONN_MASK; 1712 p_rcb->peer_features = 0; 1713 APPL_TRACE_DEBUG2(" shdl:%d, lidx:%d", p_rcb->shdl, p_rcb->lidx); 1714 if(p_rcb->shdl) 1715 { 1716 p_scb = bta_av_cb.p_scb[p_rcb->shdl - 1]; 1717 if(p_scb) 1718 { 1719 bdcpy(rc_close.peer_addr, p_scb->peer_addr); 1720 if(p_scb->rc_handle == p_rcb->handle) 1721 p_scb->rc_handle = BTA_AV_RC_HANDLE_NONE; 1722 APPL_TRACE_DEBUG2("shdl:%d, srch:%d", p_rcb->shdl, p_scb->rc_handle); 1723 } 1724 p_rcb->shdl = 0; 1725 } 1726 else if(p_rcb->lidx == (BTA_AV_NUM_LINKS + 1) ) 1727 { 1728 /* if the RCB uses the extra LCB, use the addr for event and clean it */ 1729 p_lcb = &p_cb->lcb[BTA_AV_NUM_LINKS]; 1730 bdcpy(rc_close.peer_addr, p_msg->peer_addr); 1731 APPL_TRACE_DEBUG6("rc_only closed bd_addr:%02x-%02x-%02x-%02x-%02x-%02x", 1732 p_msg->peer_addr[0], p_msg->peer_addr[1], 1733 p_msg->peer_addr[2], p_msg->peer_addr[3], 1734 p_msg->peer_addr[4], p_msg->peer_addr[5]); 1735 p_lcb->conn_msk = 0; 1736 p_lcb->lidx = 0; 1737 } 1738 p_rcb->lidx = 0; 1739 1740 if((p_rcb->status & BTA_AV_RC_ROLE_MASK) == BTA_AV_RC_ROLE_INT) 1741 { 1742 /* AVCT CCB is deallocated */ 1743 p_rcb->handle = BTA_AV_RC_HANDLE_NONE; 1744 p_rcb->status = 0; 1745 } 1746 else 1747 { 1748 /* AVCT CCB is still there. dealloc */ 1749 bta_av_del_rc(p_rcb); 1750 1751 /* if the AVRCP is no longer listening, create the listening channel */ 1752 if (bta_av_cb.rc_acp_handle == BTA_AV_RC_HANDLE_NONE && bta_av_cb.features & BTA_AV_FEAT_RCTG) 1753 bta_av_rc_create(&bta_av_cb, AVCT_ACP, 0, BTA_AV_NUM_LINKS + 1); 1754 } 1755 } 1756 else if((p_rcb->handle != BTA_AV_RC_HANDLE_NONE) && (p_rcb->status & BTA_AV_RC_CONN_MASK)) 1757 { 1758 /* at least one channel is still connected */ 1759 conn = TRUE; 1760 } 1761 } 1762 1763 if(!conn) 1764 { 1765 /* no AVRC channels are connected, go back to INIT state */ 1766 bta_av_sm_execute(p_cb, BTA_AV_AVRC_NONE_EVT, NULL); 1767 } 1768 1769 if (rc_close.rc_handle == BTA_AV_RC_HANDLE_NONE) 1770 { 1771 rc_close.rc_handle = p_msg->handle; 1772 bdcpy(rc_close.peer_addr, p_msg->peer_addr); 1773 } 1774 (*p_cb->p_cback)(BTA_AV_RC_CLOSE_EVT, (tBTA_AV *) &rc_close); 1775 } 1776 1777 /******************************************************************************* 1778 ** 1779 ** Function bta_av_rc_disc 1780 ** 1781 ** Description start AVRC SDP discovery. 1782 ** 1783 ** Returns void 1784 ** 1785 *******************************************************************************/ 1786 void bta_av_rc_disc(UINT8 disc) 1787 { 1788 tBTA_AV_CB *p_cb = &bta_av_cb; 1789 tAVRC_SDP_DB_PARAMS db_params; 1790 UINT16 attr_list[] = {ATTR_ID_SERVICE_CLASS_ID_LIST, 1791 ATTR_ID_BT_PROFILE_DESC_LIST, 1792 ATTR_ID_SUPPORTED_FEATURES}; 1793 UINT8 hdi; 1794 tBTA_AV_SCB *p_scb; 1795 UINT8 *p_addr = NULL; 1796 UINT8 rc_handle; 1797 1798 APPL_TRACE_DEBUG2("bta_av_rc_disc 0x%x, %d", disc, bta_av_cb.disc); 1799 if ((bta_av_cb.disc != 0) || (disc == 0)) 1800 return; 1801 1802 if ((disc & BTA_AV_CHNL_MSK) == BTA_AV_CHNL_MSK) 1803 { 1804 /* this is the rc handle/index to tBTA_AV_RCB */ 1805 rc_handle = disc & (~BTA_AV_CHNL_MSK); 1806 if (p_cb->rcb[rc_handle].lidx) 1807 { 1808 p_addr = p_cb->lcb[p_cb->rcb[rc_handle].lidx-1].addr; 1809 } 1810 } 1811 else 1812 { 1813 hdi = (disc & BTA_AV_HNDL_MSK) - 1; 1814 p_scb = p_cb->p_scb[hdi]; 1815 1816 if (p_scb) 1817 { 1818 APPL_TRACE_DEBUG1("rc_handle %d", p_scb->rc_handle); 1819 p_addr = p_scb->peer_addr; 1820 } 1821 } 1822 1823 if (p_addr) 1824 { 1825 /* allocate discovery database */ 1826 if (p_cb->p_disc_db == NULL) 1827 { 1828 p_cb->p_disc_db = (tSDP_DISCOVERY_DB *) GKI_getbuf(BTA_AV_DISC_BUF_SIZE); 1829 } 1830 1831 if (p_cb->p_disc_db) 1832 { 1833 /* set up parameters */ 1834 db_params.db_len = BTA_AV_DISC_BUF_SIZE; 1835 db_params.num_attr = 3; 1836 db_params.p_db = p_cb->p_disc_db; 1837 db_params.p_attrs = attr_list; 1838 1839 /* searching for UUID_SERVCLASS_AV_REMOTE_CONTROL gets both TG and CT */ 1840 if (AVRC_FindService(UUID_SERVCLASS_AV_REMOTE_CONTROL, p_addr, &db_params, 1841 bta_av_avrc_sdp_cback) == AVRC_SUCCESS) 1842 { 1843 p_cb->disc = disc; 1844 APPL_TRACE_DEBUG1("disc %d", p_cb->disc); 1845 } 1846 } 1847 } 1848 } 1849 1850 /******************************************************************************* 1851 ** 1852 ** Function bta_av_dereg_comp 1853 ** 1854 ** Description deregister complete. free the stream control block. 1855 ** 1856 ** Returns void 1857 ** 1858 *******************************************************************************/ 1859 void bta_av_dereg_comp(tBTA_AV_DATA *p_data) 1860 { 1861 tBTA_AV_CB *p_cb = &bta_av_cb; 1862 tBTA_AV_SCB *p_scb; 1863 tBTA_UTL_COD cod; 1864 UINT8 mask; 1865 BT_HDR *p_buf; 1866 1867 /* find the stream control block */ 1868 p_scb = bta_av_hndl_to_scb(p_data->hdr.layer_specific); 1869 1870 if(p_scb) 1871 { 1872 APPL_TRACE_DEBUG2("deregistered %d(h%d)", p_scb->chnl, p_scb->hndl); 1873 mask = BTA_AV_HNDL_TO_MSK(p_scb->hdi); 1874 if(p_scb->chnl == BTA_AV_CHNL_AUDIO) 1875 { 1876 p_cb->reg_audio &= ~mask; 1877 if ((p_cb->conn_audio & mask) && bta_av_cb.audio_open_cnt) 1878 { 1879 /* this channel is still marked as open. decrease the count */ 1880 bta_av_cb.audio_open_cnt--; 1881 } 1882 p_cb->conn_audio &= ~mask; 1883 1884 if (p_scb->q_tag == BTA_AV_Q_TAG_STREAM) 1885 { 1886 /* make sure no buffers are in q_info.a2d */ 1887 while((p_buf = (BT_HDR*)GKI_dequeue (&p_scb->q_info.a2d)) != NULL) 1888 GKI_freebuf(p_buf); 1889 } 1890 1891 /* remove the A2DP SDP record, if no more audio stream is left */ 1892 if(!p_cb->reg_audio) 1893 { 1894 #if( defined BTA_AR_INCLUDED ) && (BTA_AR_INCLUDED == TRUE) 1895 bta_ar_dereg_avrc (UUID_SERVCLASS_AV_REMOTE_CONTROL, BTA_ID_AV); 1896 #endif 1897 bta_av_del_sdp_rec(&p_cb->sdp_a2d_handle); 1898 bta_sys_remove_uuid(UUID_SERVCLASS_AUDIO_SOURCE); 1899 } 1900 } 1901 else 1902 { 1903 p_cb->reg_video &= ~mask; 1904 /* make sure that this channel is not connected */ 1905 p_cb->conn_video &= ~mask; 1906 /* remove the VDP SDP record, (only one video stream at most) */ 1907 bta_av_del_sdp_rec(&p_cb->sdp_vdp_handle); 1908 bta_sys_remove_uuid(UUID_SERVCLASS_VIDEO_SOURCE); 1909 } 1910 1911 /* make sure that the timer is not active */ 1912 bta_sys_stop_timer(&p_scb->timer); 1913 utl_freebuf((void **)&p_cb->p_scb[p_scb->hdi]); 1914 } 1915 1916 APPL_TRACE_DEBUG3("audio 0x%x, video: 0x%x, disable:%d", 1917 p_cb->reg_audio, p_cb->reg_video, p_cb->disabling); 1918 /* if no stream control block is active */ 1919 if((p_cb->reg_audio + p_cb->reg_video) == 0) 1920 { 1921 #if( defined BTA_AR_INCLUDED ) && (BTA_AR_INCLUDED == TRUE) 1922 /* deregister from AVDT */ 1923 bta_ar_dereg_avdt(BTA_ID_AV); 1924 1925 /* deregister from AVCT */ 1926 bta_ar_dereg_avrc (UUID_SERVCLASS_AV_REM_CTRL_TARGET, BTA_ID_AV); 1927 bta_ar_dereg_avct(BTA_ID_AV); 1928 #endif 1929 1930 if(p_cb->disabling) 1931 { 1932 p_cb->disabling = FALSE; 1933 bta_av_cb.features = 0; 1934 } 1935 1936 /* Clear the Capturing service class bit */ 1937 cod.service = BTM_COD_SERVICE_CAPTURING; 1938 utl_set_device_class(&cod, BTA_UTL_CLR_COD_SERVICE_CLASS); 1939 } 1940 } 1941 #endif /* BTA_AV_INCLUDED */ 1942
