1 /****************************************************************************** 2 * 3 * Copyright (C) 2009-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 * 22 * Filename: btif_rc.c 23 * 24 * Description: Bluetooth AVRC implementation 25 * 26 *****************************************************************************/ 27 #include <hardware/bluetooth.h> 28 #include <fcntl.h> 29 #include <string.h> 30 #include "bta_api.h" 31 #include "bta_av_api.h" 32 #include "avrc_defs.h" 33 #include "gki.h" 34 35 #define LOG_TAG "bt_btif_avrc" 36 #include "btif_common.h" 37 #include "btif_util.h" 38 #include "btif_av.h" 39 #include "hardware/bt_rc.h" 40 #include "uinput.h" 41 42 /***************************************************************************** 43 ** Constants & Macros 44 ******************************************************************************/ 45 46 /* cod value for Headsets */ 47 #define COD_AV_HEADSETS 0x0404 48 /* for AVRC 1.4 need to change this */ 49 #define MAX_RC_NOTIFICATIONS AVRC_EVT_APP_SETTING_CHANGE 50 51 #define IDX_GET_PLAY_STATUS_RSP 0 52 #define IDX_LIST_APP_ATTR_RSP 1 53 #define IDX_LIST_APP_VALUE_RSP 2 54 #define IDX_GET_CURR_APP_VAL_RSP 3 55 #define IDX_SET_APP_VAL_RSP 4 56 #define IDX_GET_APP_ATTR_TXT_RSP 5 57 #define IDX_GET_APP_VAL_TXT_RSP 6 58 #define IDX_GET_ELEMENT_ATTR_RSP 7 59 #define MAX_VOLUME 128 60 #define MAX_LABEL 16 61 #define MAX_TRANSACTIONS_PER_SESSION 16 62 #define MAX_CMD_QUEUE_LEN 8 63 #define PLAY_STATUS_PLAYING 1 64 65 #define CHECK_RC_CONNECTED \ 66 BTIF_TRACE_DEBUG("## %s ##", __FUNCTION__); \ 67 if(btif_rc_cb.rc_connected == FALSE) \ 68 { \ 69 BTIF_TRACE_WARNING("Function %s() called when RC is not connected", __FUNCTION__); \ 70 return BT_STATUS_NOT_READY; \ 71 } 72 73 #define FILL_PDU_QUEUE(index, ctype, label, pending) \ 74 { \ 75 btif_rc_cb.rc_pdu_info[index].ctype = ctype; \ 76 btif_rc_cb.rc_pdu_info[index].label = label; \ 77 btif_rc_cb.rc_pdu_info[index].is_rsp_pending = pending; \ 78 } 79 80 #define SEND_METAMSG_RSP(index, avrc_rsp) \ 81 { \ 82 if(btif_rc_cb.rc_pdu_info[index].is_rsp_pending == FALSE) \ 83 { \ 84 BTIF_TRACE_WARNING("%s Not sending response as no PDU was registered", __FUNCTION__); \ 85 return BT_STATUS_UNHANDLED; \ 86 } \ 87 send_metamsg_rsp(btif_rc_cb.rc_handle, btif_rc_cb.rc_pdu_info[index].label, \ 88 btif_rc_cb.rc_pdu_info[index].ctype, avrc_rsp); \ 89 btif_rc_cb.rc_pdu_info[index].ctype = 0; \ 90 btif_rc_cb.rc_pdu_info[index].label = 0; \ 91 btif_rc_cb.rc_pdu_info[index].is_rsp_pending = FALSE; \ 92 } 93 94 /***************************************************************************** 95 ** Local type definitions 96 ******************************************************************************/ 97 typedef struct { 98 UINT8 bNotify; 99 UINT8 label; 100 } btif_rc_reg_notifications_t; 101 102 typedef struct 103 { 104 UINT8 label; 105 UINT8 ctype; 106 BOOLEAN is_rsp_pending; 107 } btif_rc_cmd_ctxt_t; 108 109 /* TODO : Merge btif_rc_reg_notifications_t and btif_rc_cmd_ctxt_t to a single struct */ 110 typedef struct { 111 BOOLEAN rc_connected; 112 UINT8 rc_handle; 113 tBTA_AV_FEAT rc_features; 114 BD_ADDR rc_addr; 115 UINT16 rc_pending_play; 116 btif_rc_cmd_ctxt_t rc_pdu_info[MAX_CMD_QUEUE_LEN]; 117 btif_rc_reg_notifications_t rc_notif[MAX_RC_NOTIFICATIONS]; 118 unsigned int rc_volume; 119 uint8_t rc_vol_label; 120 } btif_rc_cb_t; 121 122 typedef struct { 123 BOOLEAN in_use; 124 UINT8 lbl; 125 UINT8 handle; 126 } rc_transaction_t; 127 128 typedef struct 129 { 130 pthread_mutex_t lbllock; 131 rc_transaction_t transaction[MAX_TRANSACTIONS_PER_SESSION]; 132 } rc_device_t; 133 134 135 rc_device_t device; 136 137 #define MAX_UINPUT_PATHS 3 138 static const char* uinput_dev_path[] = 139 {"/dev/uinput", "/dev/input/uinput", "/dev/misc/uinput" }; 140 static int uinput_fd = -1; 141 142 static int send_event (int fd, uint16_t type, uint16_t code, int32_t value); 143 static void send_key (int fd, uint16_t key, int pressed); 144 static int uinput_driver_check(); 145 static int uinput_create(char *name); 146 static int init_uinput (void); 147 static void close_uinput (void); 148 static BOOLEAN dev_blacklisted_for_absolute_volume(BD_ADDR peer_dev); 149 150 static const struct { 151 const char *name; 152 uint8_t avrcp; 153 uint16_t mapped_id; 154 uint8_t release_quirk; 155 } key_map[] = { 156 { "PLAY", AVRC_ID_PLAY, KEY_PLAYCD, 1 }, 157 { "STOP", AVRC_ID_STOP, KEY_STOPCD, 0 }, 158 { "PAUSE", AVRC_ID_PAUSE, KEY_PAUSECD, 1 }, 159 { "FORWARD", AVRC_ID_FORWARD, KEY_NEXTSONG, 0 }, 160 { "BACKWARD", AVRC_ID_BACKWARD, KEY_PREVIOUSSONG, 0 }, 161 { "REWIND", AVRC_ID_REWIND, KEY_REWIND, 0 }, 162 { "FAST FORWARD", AVRC_ID_FAST_FOR, KEY_FAST_FORWARD, 0 }, 163 { NULL, 0, 0, 0 } 164 }; 165 166 /* the rc_black_addr_prefix and rc_white_addr_prefix are used to correct 167 * IOP issues of absolute volume feature 168 * We encoutered A2DP headsets/carkits advertising absolute volume but buggy. 169 * We would like to blacklist those devices. 170 * But we donot have a full list of the bad devices. So as a temp fix, we 171 * are blacklisting all the devices except the devices we have well tested, 172 * the ones in the whitelist. 173 * 174 * For now, only the rc_white_addr_prefix is used in the code while 175 * rc_black_addr_prefix is kept here for future long term solution. 176 */ 177 static const UINT8 rc_white_addr_prefix[][3] = { 178 {0x94, 0xCE, 0x2C}, // Sony SBH50 179 {0x30, 0x17, 0xC8} // Sony wm600 180 }; 181 182 static const char* rc_white_name[] = { 183 "SBH50", 184 "MW600" 185 }; 186 187 static void send_reject_response (UINT8 rc_handle, UINT8 label, 188 UINT8 pdu, UINT8 status); 189 static UINT8 opcode_from_pdu(UINT8 pdu); 190 static void send_metamsg_rsp (UINT8 rc_handle, UINT8 label, 191 tBTA_AV_CODE code, tAVRC_RESPONSE *pmetamsg_resp); 192 static void register_volumechange(UINT8 label); 193 static void lbl_init(); 194 static void lbl_destroy(); 195 static void init_all_transactions(); 196 static bt_status_t get_transaction(rc_transaction_t **ptransaction); 197 static void release_transaction(UINT8 label); 198 static rc_transaction_t* get_transaction_by_lbl(UINT8 label); 199 static void handle_rc_metamsg_rsp(tBTA_AV_META_MSG *pmeta_msg); 200 static void btif_rc_upstreams_evt(UINT16 event, tAVRC_COMMAND* p_param, UINT8 ctype, UINT8 label); 201 static void btif_rc_upstreams_rsp_evt(UINT16 event, tAVRC_RESPONSE *pavrc_resp, UINT8 ctype, UINT8 label); 202 203 /***************************************************************************** 204 ** Static variables 205 ******************************************************************************/ 206 static btif_rc_cb_t btif_rc_cb; 207 static btrc_callbacks_t *bt_rc_callbacks = NULL; 208 static btrc_ctrl_callbacks_t *bt_rc_ctrl_callbacks = NULL; 209 210 /***************************************************************************** 211 ** Static functions 212 ******************************************************************************/ 213 214 /***************************************************************************** 215 ** Externs 216 ******************************************************************************/ 217 extern BOOLEAN btif_hf_call_terminated_recently(); 218 extern BOOLEAN check_cod(const bt_bdaddr_t *remote_bdaddr, uint32_t cod); 219 220 221 /***************************************************************************** 222 ** Functions 223 ******************************************************************************/ 224 225 /***************************************************************************** 226 ** Local uinput helper functions 227 ******************************************************************************/ 228 int send_event (int fd, uint16_t type, uint16_t code, int32_t value) 229 { 230 struct uinput_event event; 231 BTIF_TRACE_DEBUG("%s type:%u code:%u value:%d", __FUNCTION__, 232 type, code, value); 233 memset(&event, 0, sizeof(event)); 234 event.type = type; 235 event.code = code; 236 event.value = value; 237 238 return write(fd, &event, sizeof(event)); 239 } 240 241 void send_key (int fd, uint16_t key, int pressed) 242 { 243 BTIF_TRACE_DEBUG("%s fd:%d key:%u pressed:%d", __FUNCTION__, 244 fd, key, pressed); 245 246 if (fd < 0) 247 { 248 return; 249 } 250 251 BTIF_TRACE_DEBUG("AVRCP: Send key %d (%d) fd=%d", key, pressed, fd); 252 send_event(fd, EV_KEY, key, pressed); 253 send_event(fd, EV_SYN, SYN_REPORT, 0); 254 } 255 256 /************** uinput related functions **************/ 257 int uinput_driver_check() 258 { 259 uint32_t i; 260 for (i=0; i < MAX_UINPUT_PATHS; i++) 261 { 262 if (access(uinput_dev_path[i], O_RDWR) == 0) { 263 return 0; 264 } 265 } 266 BTIF_TRACE_ERROR("%s ERROR: uinput device is not in the system", __FUNCTION__); 267 return -1; 268 } 269 270 int uinput_create(char *name) 271 { 272 struct uinput_dev dev; 273 int fd, x = 0; 274 275 for(x=0; x < MAX_UINPUT_PATHS; x++) 276 { 277 fd = open(uinput_dev_path[x], O_RDWR); 278 if (fd < 0) 279 continue; 280 break; 281 } 282 if (x == MAX_UINPUT_PATHS) { 283 BTIF_TRACE_ERROR("%s ERROR: uinput device open failed", __FUNCTION__); 284 return -1; 285 } 286 memset(&dev, 0, sizeof(dev)); 287 if (name) 288 strncpy(dev.name, name, UINPUT_MAX_NAME_SIZE-1); 289 290 dev.id.bustype = BUS_BLUETOOTH; 291 dev.id.vendor = 0x0000; 292 dev.id.product = 0x0000; 293 dev.id.version = 0x0000; 294 295 if (write(fd, &dev, sizeof(dev)) < 0) { 296 BTIF_TRACE_ERROR("%s Unable to write device information", __FUNCTION__); 297 close(fd); 298 return -1; 299 } 300 301 ioctl(fd, UI_SET_EVBIT, EV_KEY); 302 ioctl(fd, UI_SET_EVBIT, EV_REL); 303 ioctl(fd, UI_SET_EVBIT, EV_SYN); 304 305 for (x = 0; key_map[x].name != NULL; x++) 306 ioctl(fd, UI_SET_KEYBIT, key_map[x].mapped_id); 307 308 if (ioctl(fd, UI_DEV_CREATE, NULL) < 0) { 309 BTIF_TRACE_ERROR("%s Unable to create uinput device", __FUNCTION__); 310 close(fd); 311 return -1; 312 } 313 return fd; 314 } 315 316 int init_uinput (void) 317 { 318 char *name = "AVRCP"; 319 320 BTIF_TRACE_DEBUG("%s", __FUNCTION__); 321 uinput_fd = uinput_create(name); 322 if (uinput_fd < 0) { 323 BTIF_TRACE_ERROR("%s AVRCP: Failed to initialize uinput for %s (%d)", 324 __FUNCTION__, name, uinput_fd); 325 } else { 326 BTIF_TRACE_DEBUG("%s AVRCP: Initialized uinput for %s (fd=%d)", 327 __FUNCTION__, name, uinput_fd); 328 } 329 return uinput_fd; 330 } 331 332 void close_uinput (void) 333 { 334 BTIF_TRACE_DEBUG("%s", __FUNCTION__); 335 if (uinput_fd > 0) { 336 ioctl(uinput_fd, UI_DEV_DESTROY); 337 338 close(uinput_fd); 339 uinput_fd = -1; 340 } 341 } 342 343 void handle_rc_features() 344 { 345 btrc_remote_features_t rc_features = BTRC_FEAT_NONE; 346 bt_bdaddr_t rc_addr; 347 bdcpy(rc_addr.address, btif_rc_cb.rc_addr); 348 349 if (dev_blacklisted_for_absolute_volume(btif_rc_cb.rc_addr)) 350 { 351 btif_rc_cb.rc_features &= ~BTA_AV_FEAT_ADV_CTRL; 352 } 353 354 if (btif_rc_cb.rc_features & BTA_AV_FEAT_BROWSE) 355 { 356 rc_features |= BTRC_FEAT_BROWSE; 357 } 358 if ( (btif_rc_cb.rc_features & BTA_AV_FEAT_ADV_CTRL) && 359 (btif_rc_cb.rc_features & BTA_AV_FEAT_RCTG)) 360 { 361 rc_features |= BTRC_FEAT_ABSOLUTE_VOLUME; 362 } 363 if (btif_rc_cb.rc_features & BTA_AV_FEAT_METADATA) 364 { 365 rc_features |= BTRC_FEAT_METADATA; 366 } 367 BTIF_TRACE_DEBUG("%s: rc_features=0x%x", __FUNCTION__, rc_features); 368 HAL_CBACK(bt_rc_callbacks, remote_features_cb, &rc_addr, rc_features) 369 370 #if (AVRC_ADV_CTRL_INCLUDED == TRUE) 371 BTIF_TRACE_DEBUG("Checking for feature flags in btif_rc_handler with label %d", 372 btif_rc_cb.rc_vol_label); 373 // Register for volume change on connect 374 if(btif_rc_cb.rc_features & BTA_AV_FEAT_ADV_CTRL && 375 btif_rc_cb.rc_features & BTA_AV_FEAT_RCTG) 376 { 377 rc_transaction_t *p_transaction=NULL; 378 bt_status_t status = BT_STATUS_NOT_READY; 379 if(MAX_LABEL==btif_rc_cb.rc_vol_label) 380 { 381 status=get_transaction(&p_transaction); 382 } 383 else 384 { 385 p_transaction=get_transaction_by_lbl(btif_rc_cb.rc_vol_label); 386 if(NULL!=p_transaction) 387 { 388 BTIF_TRACE_DEBUG("register_volumechange already in progress for label %d", 389 btif_rc_cb.rc_vol_label); 390 return; 391 } 392 else 393 status=get_transaction(&p_transaction); 394 } 395 396 if(BT_STATUS_SUCCESS == status && NULL!=p_transaction) 397 { 398 btif_rc_cb.rc_vol_label=p_transaction->lbl; 399 register_volumechange(btif_rc_cb.rc_vol_label); 400 } 401 } 402 #endif 403 } 404 405 406 /*************************************************************************** 407 * Function handle_rc_connect 408 * 409 * - Argument: tBTA_AV_RC_OPEN RC open data structure 410 * 411 * - Description: RC connection event handler 412 * 413 ***************************************************************************/ 414 void handle_rc_connect (tBTA_AV_RC_OPEN *p_rc_open) 415 { 416 BTIF_TRACE_DEBUG("%s: rc_handle: %d", __FUNCTION__, p_rc_open->rc_handle); 417 bt_status_t result = BT_STATUS_SUCCESS; 418 #if (AVRC_CTLR_INCLUDED == TRUE) 419 bt_bdaddr_t rc_addr; 420 #endif 421 422 if(p_rc_open->status == BTA_AV_SUCCESS) 423 { 424 //check if already some RC is connected 425 if (btif_rc_cb.rc_connected) 426 { 427 BTIF_TRACE_ERROR("Got RC OPEN in connected state, Connected RC: %d \ 428 and Current RC: %d", btif_rc_cb.rc_handle,p_rc_open->rc_handle ); 429 if ((btif_rc_cb.rc_handle != p_rc_open->rc_handle) 430 && (bdcmp(btif_rc_cb.rc_addr, p_rc_open->peer_addr))) 431 { 432 BTIF_TRACE_DEBUG("Got RC connected for some other handle"); 433 BTA_AvCloseRc(p_rc_open->rc_handle); 434 return; 435 } 436 } 437 memcpy(btif_rc_cb.rc_addr, p_rc_open->peer_addr, sizeof(BD_ADDR)); 438 btif_rc_cb.rc_features = p_rc_open->peer_features; 439 btif_rc_cb.rc_vol_label=MAX_LABEL; 440 btif_rc_cb.rc_volume=MAX_VOLUME; 441 442 btif_rc_cb.rc_connected = TRUE; 443 btif_rc_cb.rc_handle = p_rc_open->rc_handle; 444 445 /* on locally initiated connection we will get remote features as part of connect */ 446 if (btif_rc_cb.rc_features != 0) 447 handle_rc_features(); 448 449 result = uinput_driver_check(); 450 if(result == BT_STATUS_SUCCESS) 451 { 452 init_uinput(); 453 } 454 #if (AVRC_CTLR_INCLUDED == TRUE) 455 bdcpy(rc_addr.address, btif_rc_cb.rc_addr); 456 /* report connection state if device is AVRCP target */ 457 if (btif_rc_cb.rc_features & BTA_AV_FEAT_RCTG) { 458 if (bt_rc_ctrl_callbacks != NULL) { 459 HAL_CBACK(bt_rc_ctrl_callbacks, connection_state_cb, TRUE, &rc_addr); 460 } 461 } 462 #endif 463 } 464 else 465 { 466 BTIF_TRACE_ERROR("%s Connect failed with error code: %d", 467 __FUNCTION__, p_rc_open->status); 468 btif_rc_cb.rc_connected = FALSE; 469 } 470 } 471 472 /*************************************************************************** 473 * Function handle_rc_disconnect 474 * 475 * - Argument: tBTA_AV_RC_CLOSE RC close data structure 476 * 477 * - Description: RC disconnection event handler 478 * 479 ***************************************************************************/ 480 void handle_rc_disconnect (tBTA_AV_RC_CLOSE *p_rc_close) 481 { 482 #if (AVRC_CTLR_INCLUDED == TRUE) 483 bt_bdaddr_t rc_addr; 484 tBTA_AV_FEAT features; 485 #endif 486 BTIF_TRACE_DEBUG("%s: rc_handle: %d", __FUNCTION__, p_rc_close->rc_handle); 487 if ((p_rc_close->rc_handle != btif_rc_cb.rc_handle) 488 && (bdcmp(btif_rc_cb.rc_addr, p_rc_close->peer_addr))) 489 { 490 BTIF_TRACE_ERROR("Got disconnect of unknown device"); 491 return; 492 } 493 494 btif_rc_cb.rc_handle = 0; 495 btif_rc_cb.rc_connected = FALSE; 496 memset(btif_rc_cb.rc_addr, 0, sizeof(BD_ADDR)); 497 memset(btif_rc_cb.rc_notif, 0, sizeof(btif_rc_cb.rc_notif)); 498 #if (AVRC_CTLR_INCLUDED == TRUE) 499 features = btif_rc_cb.rc_features; 500 #endif 501 btif_rc_cb.rc_features = 0; 502 btif_rc_cb.rc_vol_label=MAX_LABEL; 503 btif_rc_cb.rc_volume=MAX_VOLUME; 504 init_all_transactions(); 505 close_uinput(); 506 #if (AVRC_CTLR_INCLUDED == TRUE) 507 bdcpy(rc_addr.address, btif_rc_cb.rc_addr); 508 #endif 509 memset(btif_rc_cb.rc_addr, 0, sizeof(BD_ADDR)); 510 #if (AVRC_CTLR_INCLUDED == TRUE) 511 /* report connection state if device is AVRCP target */ 512 if (features & BTA_AV_FEAT_RCTG) { 513 if (bt_rc_ctrl_callbacks != NULL) { 514 HAL_CBACK(bt_rc_ctrl_callbacks, connection_state_cb, FALSE, &rc_addr); 515 } 516 } 517 #endif 518 } 519 520 /*************************************************************************** 521 * Function handle_rc_passthrough_cmd 522 * 523 * - Argument: tBTA_AV_RC rc_id remote control command ID 524 * tBTA_AV_STATE key_state status of key press 525 * 526 * - Description: Remote control command handler 527 * 528 ***************************************************************************/ 529 void handle_rc_passthrough_cmd ( tBTA_AV_REMOTE_CMD *p_remote_cmd) 530 { 531 const char *status; 532 int pressed, i; 533 534 BTIF_TRACE_DEBUG("%s: p_remote_cmd->rc_id=%d", __FUNCTION__, p_remote_cmd->rc_id); 535 536 /* If AVRC is open and peer sends PLAY but there is no AVDT, then we queue-up this PLAY */ 537 if (p_remote_cmd) 538 { 539 /* queue AVRC PLAY if GAVDTP Open notification to app is pending (2 second timer) */ 540 if ((p_remote_cmd->rc_id == BTA_AV_RC_PLAY) && (!btif_av_is_connected())) 541 { 542 if (p_remote_cmd->key_state == AVRC_STATE_PRESS) 543 { 544 APPL_TRACE_WARNING("%s: AVDT not open, queuing the PLAY command", __FUNCTION__); 545 btif_rc_cb.rc_pending_play = TRUE; 546 } 547 return; 548 } 549 550 if ((p_remote_cmd->rc_id == BTA_AV_RC_PAUSE) && (btif_rc_cb.rc_pending_play)) 551 { 552 APPL_TRACE_WARNING("%s: Clear the pending PLAY on PAUSE received", __FUNCTION__); 553 btif_rc_cb.rc_pending_play = FALSE; 554 return; 555 } 556 } 557 558 if ((p_remote_cmd->rc_id == BTA_AV_RC_STOP) && (!btif_av_stream_started_ready())) 559 { 560 APPL_TRACE_WARNING("%s: Stream suspended, ignore STOP cmd",__FUNCTION__); 561 return; 562 } 563 564 if (p_remote_cmd->key_state == AVRC_STATE_RELEASE) { 565 status = "released"; 566 pressed = 0; 567 } else { 568 status = "pressed"; 569 pressed = 1; 570 } 571 572 /* If this is Play/Pause command (press or release) before processing, check the following 573 * a voice call has ended recently 574 * the remote device is not of type headset 575 * If the above conditions meet, drop the Play/Pause command 576 * This fix is to interop with certain carkits which sends an automatic PLAY or PAUSE 577 * commands right after call ends 578 */ 579 if((p_remote_cmd->rc_id == BTA_AV_RC_PLAY || p_remote_cmd->rc_id == BTA_AV_RC_PAUSE)&& 580 (btif_hf_call_terminated_recently() == TRUE) && 581 (check_cod( (const bt_bdaddr_t*)&(btif_rc_cb.rc_addr), COD_AV_HEADSETS) != TRUE)) 582 { 583 BTIF_TRACE_DEBUG("%s:Dropping the play/Pause command received right after call end cmd:%d", 584 __FUNCTION__,p_remote_cmd->rc_id); 585 return; 586 } 587 588 if (p_remote_cmd->rc_id == BTA_AV_RC_FAST_FOR || p_remote_cmd->rc_id == BTA_AV_RC_REWIND) { 589 HAL_CBACK(bt_rc_callbacks, passthrough_cmd_cb, p_remote_cmd->rc_id, pressed); 590 return; 591 } 592 593 for (i = 0; key_map[i].name != NULL; i++) { 594 if (p_remote_cmd->rc_id == key_map[i].avrcp) { 595 BTIF_TRACE_DEBUG("%s: %s %s", __FUNCTION__, key_map[i].name, status); 596 597 /* MusicPlayer uses a long_press_timeout of 1 second for PLAYPAUSE button 598 * and maps that to autoshuffle. So if for some reason release for PLAY/PAUSE 599 * comes 1 second after the press, the MediaPlayer UI goes into a bad state. 600 * The reason for the delay could be sniff mode exit or some AVDTP procedure etc. 601 * The fix is to generate a release right after the press and drown the 'actual' 602 * release. 603 */ 604 if ((key_map[i].release_quirk == 1) && (pressed == 0)) 605 { 606 BTIF_TRACE_DEBUG("%s: AVRC %s Release Faked earlier, drowned now", 607 __FUNCTION__, key_map[i].name); 608 return; 609 } 610 send_key(uinput_fd, key_map[i].mapped_id, pressed); 611 if ((key_map[i].release_quirk == 1) && (pressed == 1)) 612 { 613 GKI_delay(30); // 30ms 614 BTIF_TRACE_DEBUG("%s: AVRC %s Release quirk enabled, send release now", 615 __FUNCTION__, key_map[i].name); 616 send_key(uinput_fd, key_map[i].mapped_id, 0); 617 } 618 break; 619 } 620 } 621 622 if (key_map[i].name == NULL) 623 BTIF_TRACE_ERROR("%s AVRCP: unknown button 0x%02X %s", __FUNCTION__, 624 p_remote_cmd->rc_id, status); 625 } 626 627 /*************************************************************************** 628 * Function handle_rc_passthrough_rsp 629 * 630 * - Argument: tBTA_AV_REMOTE_RSP passthrough command response 631 * 632 * - Description: Remote control passthrough response handler 633 * 634 ***************************************************************************/ 635 void handle_rc_passthrough_rsp ( tBTA_AV_REMOTE_RSP *p_remote_rsp) 636 { 637 #if (AVRC_CTLR_INCLUDED == TRUE) 638 const char *status; 639 if (btif_rc_cb.rc_features & BTA_AV_FEAT_RCTG) 640 { 641 int key_state; 642 if (p_remote_rsp->key_state == AVRC_STATE_RELEASE) 643 { 644 status = "released"; 645 key_state = 1; 646 } 647 else 648 { 649 status = "pressed"; 650 key_state = 0; 651 } 652 653 BTIF_TRACE_DEBUG("%s: rc_id=%d status=%s", __FUNCTION__, p_remote_rsp->rc_id, status); 654 655 release_transaction(p_remote_rsp->label); 656 if (bt_rc_ctrl_callbacks != NULL) { 657 HAL_CBACK(bt_rc_ctrl_callbacks, passthrough_rsp_cb, p_remote_rsp->rc_id, key_state); 658 } 659 } 660 else 661 { 662 BTIF_TRACE_ERROR("%s DUT does not support AVRCP controller role", __FUNCTION__); 663 } 664 #else 665 BTIF_TRACE_ERROR("%s AVRCP controller role is not enabled", __FUNCTION__); 666 #endif 667 } 668 669 void handle_uid_changed_notification(tBTA_AV_META_MSG *pmeta_msg, tAVRC_COMMAND *pavrc_command) 670 { 671 tAVRC_RESPONSE avrc_rsp = {0}; 672 avrc_rsp.rsp.pdu = pavrc_command->pdu; 673 avrc_rsp.rsp.status = AVRC_STS_NO_ERROR; 674 avrc_rsp.rsp.opcode = pavrc_command->cmd.opcode; 675 676 avrc_rsp.reg_notif.event_id = pavrc_command->reg_notif.event_id; 677 avrc_rsp.reg_notif.param.uid_counter = 0; 678 679 send_metamsg_rsp(pmeta_msg->rc_handle, pmeta_msg->label, AVRC_RSP_INTERIM, &avrc_rsp); 680 send_metamsg_rsp(pmeta_msg->rc_handle, pmeta_msg->label, AVRC_RSP_CHANGED, &avrc_rsp); 681 682 } 683 684 685 /*************************************************************************** 686 * Function handle_rc_metamsg_cmd 687 * 688 * - Argument: tBTA_AV_VENDOR Structure containing the received 689 * metamsg command 690 * 691 * - Description: Remote control metamsg command handler (AVRCP 1.3) 692 * 693 ***************************************************************************/ 694 void handle_rc_metamsg_cmd (tBTA_AV_META_MSG *pmeta_msg) 695 { 696 /* Parse the metamsg command and pass it on to BTL-IFS */ 697 UINT8 scratch_buf[512] = {0}; 698 tAVRC_COMMAND avrc_command = {0}; 699 tAVRC_STS status; 700 701 BTIF_TRACE_EVENT("+ %s", __FUNCTION__); 702 703 if (pmeta_msg->p_msg->hdr.opcode != AVRC_OP_VENDOR) 704 { 705 BTIF_TRACE_WARNING("Invalid opcode: %x", pmeta_msg->p_msg->hdr.opcode); 706 return; 707 } 708 if (pmeta_msg->len < 3) 709 { 710 BTIF_TRACE_WARNING("Invalid length.Opcode: 0x%x, len: 0x%x", pmeta_msg->p_msg->hdr.opcode, 711 pmeta_msg->len); 712 return; 713 } 714 715 if (pmeta_msg->code >= AVRC_RSP_NOT_IMPL) 716 { 717 #if (AVRC_ADV_CTRL_INCLUDED == TRUE) 718 { 719 rc_transaction_t *transaction=NULL; 720 transaction=get_transaction_by_lbl(pmeta_msg->label); 721 if(NULL!=transaction) 722 { 723 handle_rc_metamsg_rsp(pmeta_msg); 724 } 725 else 726 { 727 BTIF_TRACE_DEBUG("%s:Discard vendor dependent rsp. code: %d label:%d.", 728 __FUNCTION__, pmeta_msg->code, pmeta_msg->label); 729 } 730 return; 731 } 732 #else 733 { 734 BTIF_TRACE_DEBUG("%s:Received vendor dependent rsp. code: %d len: %d. Not processing it.", 735 __FUNCTION__, pmeta_msg->code, pmeta_msg->len); 736 return; 737 } 738 #endif 739 } 740 741 status=AVRC_ParsCommand(pmeta_msg->p_msg, &avrc_command, scratch_buf, sizeof(scratch_buf)); 742 BTIF_TRACE_DEBUG("Received vendor command.code,PDU and label: %d, %d,%d",pmeta_msg->code, 743 avrc_command.cmd.pdu, pmeta_msg->label); 744 745 if (status != AVRC_STS_NO_ERROR) 746 { 747 /* return error */ 748 BTIF_TRACE_WARNING("%s: Error in parsing received metamsg command. status: 0x%02x", 749 __FUNCTION__, status); 750 send_reject_response(pmeta_msg->rc_handle, pmeta_msg->label, avrc_command.pdu, status); 751 } 752 else 753 { 754 /* if RegisterNotification, add it to our registered queue */ 755 756 if (avrc_command.cmd.pdu == AVRC_PDU_REGISTER_NOTIFICATION) 757 { 758 UINT8 event_id = avrc_command.reg_notif.event_id; 759 BTIF_TRACE_EVENT("%s:New register notification received.event_id:%s,label:0x%x,code:%x", 760 __FUNCTION__,dump_rc_notification_event_id(event_id), pmeta_msg->label,pmeta_msg->code); 761 btif_rc_cb.rc_notif[event_id-1].bNotify = TRUE; 762 btif_rc_cb.rc_notif[event_id-1].label = pmeta_msg->label; 763 764 if(event_id == AVRC_EVT_UIDS_CHANGE) 765 { 766 handle_uid_changed_notification(pmeta_msg, &avrc_command); 767 return; 768 } 769 770 } 771 772 BTIF_TRACE_EVENT("%s: Passing received metamsg command to app. pdu: %s", 773 __FUNCTION__, dump_rc_pdu(avrc_command.cmd.pdu)); 774 775 /* Since handle_rc_metamsg_cmd() itself is called from 776 *btif context, no context switching is required. Invoke 777 * btif_rc_upstreams_evt directly from here. */ 778 btif_rc_upstreams_evt((uint16_t)avrc_command.cmd.pdu, &avrc_command, pmeta_msg->code, 779 pmeta_msg->label); 780 } 781 } 782 783 /*************************************************************************** 784 ** 785 ** Function btif_rc_handler 786 ** 787 ** Description RC event handler 788 ** 789 ***************************************************************************/ 790 void btif_rc_handler(tBTA_AV_EVT event, tBTA_AV *p_data) 791 { 792 BTIF_TRACE_DEBUG ("%s event:%s", __FUNCTION__, dump_rc_event(event)); 793 switch (event) 794 { 795 case BTA_AV_RC_OPEN_EVT: 796 { 797 BTIF_TRACE_DEBUG("Peer_features:%x", p_data->rc_open.peer_features); 798 handle_rc_connect( &(p_data->rc_open) ); 799 }break; 800 801 case BTA_AV_RC_CLOSE_EVT: 802 { 803 handle_rc_disconnect( &(p_data->rc_close) ); 804 }break; 805 806 case BTA_AV_REMOTE_CMD_EVT: 807 { 808 BTIF_TRACE_DEBUG("rc_id:0x%x key_state:%d", p_data->remote_cmd.rc_id, 809 p_data->remote_cmd.key_state); 810 handle_rc_passthrough_cmd( (&p_data->remote_cmd) ); 811 } 812 break; 813 #if (AVRC_CTLR_INCLUDED == TRUE) 814 case BTA_AV_REMOTE_RSP_EVT: 815 { 816 BTIF_TRACE_DEBUG("RSP: rc_id:0x%x key_state:%d", p_data->remote_rsp.rc_id, 817 p_data->remote_rsp.key_state); 818 handle_rc_passthrough_rsp( (&p_data->remote_rsp) ); 819 } 820 break; 821 #endif 822 case BTA_AV_RC_FEAT_EVT: 823 { 824 BTIF_TRACE_DEBUG("Peer_features:%x", p_data->rc_feat.peer_features); 825 btif_rc_cb.rc_features = p_data->rc_feat.peer_features; 826 handle_rc_features(); 827 } 828 break; 829 case BTA_AV_META_MSG_EVT: 830 { 831 BTIF_TRACE_DEBUG("BTA_AV_META_MSG_EVT code:%d label:%d", p_data->meta_msg.code, 832 p_data->meta_msg.label); 833 BTIF_TRACE_DEBUG(" company_id:0x%x len:%d handle:%d", p_data->meta_msg.company_id, 834 p_data->meta_msg.len, p_data->meta_msg.rc_handle); 835 /* handle the metamsg command */ 836 handle_rc_metamsg_cmd(&(p_data->meta_msg)); 837 } 838 break; 839 default: 840 BTIF_TRACE_DEBUG("Unhandled RC event : 0x%x", event); 841 } 842 } 843 844 /*************************************************************************** 845 ** 846 ** Function btif_rc_get_connected_peer 847 ** 848 ** Description Fetches the connected headset's BD_ADDR if any 849 ** 850 ***************************************************************************/ 851 BOOLEAN btif_rc_get_connected_peer(BD_ADDR peer_addr) 852 { 853 if (btif_rc_cb.rc_connected == TRUE) { 854 bdcpy(peer_addr, btif_rc_cb.rc_addr); 855 return TRUE; 856 } 857 return FALSE; 858 } 859 860 /*************************************************************************** 861 ** 862 ** Function btif_rc_check_handle_pending_play 863 ** 864 ** Description Clears the queued PLAY command. if bSend is TRUE, forwards to app 865 ** 866 ***************************************************************************/ 867 868 /* clear the queued PLAY command. if bSend is TRUE, forward to app */ 869 void btif_rc_check_handle_pending_play (BD_ADDR peer_addr, BOOLEAN bSendToApp) 870 { 871 UNUSED(peer_addr); 872 873 BTIF_TRACE_DEBUG("%s: bSendToApp=%d", __FUNCTION__, bSendToApp); 874 if (btif_rc_cb.rc_pending_play) 875 { 876 if (bSendToApp) 877 { 878 tBTA_AV_REMOTE_CMD remote_cmd; 879 APPL_TRACE_DEBUG("%s: Sending queued PLAYED event to app", __FUNCTION__); 880 881 memset (&remote_cmd, 0, sizeof(tBTA_AV_REMOTE_CMD)); 882 remote_cmd.rc_handle = btif_rc_cb.rc_handle; 883 remote_cmd.rc_id = AVRC_ID_PLAY; 884 remote_cmd.hdr.ctype = AVRC_CMD_CTRL; 885 remote_cmd.hdr.opcode = AVRC_OP_PASS_THRU; 886 887 /* delay sending to app, else there is a timing issue in the framework, 888 ** which causes the audio to be on th device's speaker. Delay between 889 ** OPEN & RC_PLAYs 890 */ 891 GKI_delay (200); 892 /* send to app - both PRESSED & RELEASED */ 893 remote_cmd.key_state = AVRC_STATE_PRESS; 894 handle_rc_passthrough_cmd( &remote_cmd ); 895 896 GKI_delay (100); 897 898 remote_cmd.key_state = AVRC_STATE_RELEASE; 899 handle_rc_passthrough_cmd( &remote_cmd ); 900 } 901 btif_rc_cb.rc_pending_play = FALSE; 902 } 903 } 904 905 /* Generic reject response */ 906 static void send_reject_response (UINT8 rc_handle, UINT8 label, UINT8 pdu, UINT8 status) 907 { 908 UINT8 ctype = AVRC_RSP_REJ; 909 tAVRC_RESPONSE avrc_rsp; 910 BT_HDR *p_msg = NULL; 911 memset (&avrc_rsp, 0, sizeof(tAVRC_RESPONSE)); 912 913 avrc_rsp.rsp.opcode = opcode_from_pdu(pdu); 914 avrc_rsp.rsp.pdu = pdu; 915 avrc_rsp.rsp.status = status; 916 917 if (AVRC_STS_NO_ERROR == (status = AVRC_BldResponse(rc_handle, &avrc_rsp, &p_msg)) ) 918 { 919 BTIF_TRACE_DEBUG("%s:Sending error notification to handle:%d. pdu:%s,status:0x%02x", 920 __FUNCTION__, rc_handle, dump_rc_pdu(pdu), status); 921 BTA_AvMetaRsp(rc_handle, label, ctype, p_msg); 922 } 923 } 924 925 /*************************************************************************** 926 * Function send_metamsg_rsp 927 * 928 * - Argument: 929 * rc_handle RC handle corresponding to the connected RC 930 * label Label of the RC response 931 * code Response type 932 * pmetamsg_resp Vendor response 933 * 934 * - Description: Remote control metamsg response handler (AVRCP 1.3) 935 * 936 ***************************************************************************/ 937 static void send_metamsg_rsp (UINT8 rc_handle, UINT8 label, tBTA_AV_CODE code, 938 tAVRC_RESPONSE *pmetamsg_resp) 939 { 940 UINT8 ctype; 941 942 if (!pmetamsg_resp) 943 { 944 BTIF_TRACE_WARNING("%s: Invalid response received from application", __FUNCTION__); 945 return; 946 } 947 948 BTIF_TRACE_EVENT("+%s: rc_handle: %d, label: %d, code: 0x%02x, pdu: %s", __FUNCTION__, 949 rc_handle, label, code, dump_rc_pdu(pmetamsg_resp->rsp.pdu)); 950 951 if (pmetamsg_resp->rsp.status != AVRC_STS_NO_ERROR) 952 { 953 ctype = AVRC_RSP_REJ; 954 } 955 else 956 { 957 if ( code < AVRC_RSP_NOT_IMPL) 958 { 959 if (code == AVRC_CMD_NOTIF) 960 { 961 ctype = AVRC_RSP_INTERIM; 962 } 963 else if (code == AVRC_CMD_STATUS) 964 { 965 ctype = AVRC_RSP_IMPL_STBL; 966 } 967 else 968 { 969 ctype = AVRC_RSP_ACCEPT; 970 } 971 } 972 else 973 { 974 ctype = code; 975 } 976 } 977 /* if response is for register_notification, make sure the rc has 978 actually registered for this */ 979 if((pmetamsg_resp->rsp.pdu == AVRC_PDU_REGISTER_NOTIFICATION) && (code == AVRC_RSP_CHANGED)) 980 { 981 BOOLEAN bSent = FALSE; 982 UINT8 event_id = pmetamsg_resp->reg_notif.event_id; 983 BOOLEAN bNotify = (btif_rc_cb.rc_connected) && (btif_rc_cb.rc_notif[event_id-1].bNotify); 984 985 /* de-register this notification for a CHANGED response */ 986 btif_rc_cb.rc_notif[event_id-1].bNotify = FALSE; 987 BTIF_TRACE_DEBUG("%s rc_handle: %d. event_id: 0x%02d bNotify:%u", __FUNCTION__, 988 btif_rc_cb.rc_handle, event_id, bNotify); 989 if (bNotify) 990 { 991 BT_HDR *p_msg = NULL; 992 tAVRC_STS status; 993 994 if (AVRC_STS_NO_ERROR == (status = AVRC_BldResponse(btif_rc_cb.rc_handle, 995 pmetamsg_resp, &p_msg)) ) 996 { 997 BTIF_TRACE_DEBUG("%s Sending notification to rc_handle: %d. event_id: 0x%02d", 998 __FUNCTION__, btif_rc_cb.rc_handle, event_id); 999 bSent = TRUE; 1000 BTA_AvMetaRsp(btif_rc_cb.rc_handle, btif_rc_cb.rc_notif[event_id-1].label, 1001 ctype, p_msg); 1002 } 1003 else 1004 { 1005 BTIF_TRACE_WARNING("%s failed to build metamsg response. status: 0x%02x", 1006 __FUNCTION__, status); 1007 } 1008 1009 } 1010 1011 if (!bSent) 1012 { 1013 BTIF_TRACE_DEBUG("%s: Notification not sent, as there are no RC connections or the \ 1014 CT has not subscribed for event_id: %s", __FUNCTION__, dump_rc_notification_event_id(event_id)); 1015 } 1016 } 1017 else 1018 { 1019 /* All other commands go here */ 1020 1021 BT_HDR *p_msg = NULL; 1022 tAVRC_STS status; 1023 1024 status = AVRC_BldResponse(rc_handle, pmetamsg_resp, &p_msg); 1025 1026 if (status == AVRC_STS_NO_ERROR) 1027 { 1028 BTA_AvMetaRsp(rc_handle, label, ctype, p_msg); 1029 } 1030 else 1031 { 1032 BTIF_TRACE_ERROR("%s: failed to build metamsg response. status: 0x%02x", 1033 __FUNCTION__, status); 1034 } 1035 } 1036 } 1037 1038 static UINT8 opcode_from_pdu(UINT8 pdu) 1039 { 1040 UINT8 opcode = 0; 1041 1042 switch (pdu) 1043 { 1044 case AVRC_PDU_NEXT_GROUP: 1045 case AVRC_PDU_PREV_GROUP: /* pass thru */ 1046 opcode = AVRC_OP_PASS_THRU; 1047 break; 1048 1049 default: /* vendor */ 1050 opcode = AVRC_OP_VENDOR; 1051 break; 1052 } 1053 1054 return opcode; 1055 } 1056 1057 /******************************************************************************* 1058 ** 1059 ** Function btif_rc_upstreams_evt 1060 ** 1061 ** Description Executes AVRC UPSTREAMS events in btif context. 1062 ** 1063 ** Returns void 1064 ** 1065 *******************************************************************************/ 1066 static void btif_rc_upstreams_evt(UINT16 event, tAVRC_COMMAND *pavrc_cmd, UINT8 ctype, UINT8 label) 1067 { 1068 BTIF_TRACE_EVENT("%s pdu: %s handle: 0x%x ctype:%x label:%x", __FUNCTION__, 1069 dump_rc_pdu(pavrc_cmd->pdu), btif_rc_cb.rc_handle, ctype, label); 1070 1071 switch (event) 1072 { 1073 case AVRC_PDU_GET_PLAY_STATUS: 1074 { 1075 FILL_PDU_QUEUE(IDX_GET_PLAY_STATUS_RSP, ctype, label, TRUE) 1076 HAL_CBACK(bt_rc_callbacks, get_play_status_cb); 1077 } 1078 break; 1079 case AVRC_PDU_LIST_PLAYER_APP_ATTR: 1080 case AVRC_PDU_LIST_PLAYER_APP_VALUES: 1081 case AVRC_PDU_GET_CUR_PLAYER_APP_VALUE: 1082 case AVRC_PDU_SET_PLAYER_APP_VALUE: 1083 case AVRC_PDU_GET_PLAYER_APP_ATTR_TEXT: 1084 case AVRC_PDU_GET_PLAYER_APP_VALUE_TEXT: 1085 { 1086 /* TODO: Add support for Application Settings */ 1087 send_reject_response (btif_rc_cb.rc_handle, label, pavrc_cmd->pdu, AVRC_STS_BAD_CMD); 1088 } 1089 break; 1090 case AVRC_PDU_GET_ELEMENT_ATTR: 1091 { 1092 btrc_media_attr_t element_attrs[BTRC_MAX_ELEM_ATTR_SIZE]; 1093 UINT8 num_attr; 1094 memset(&element_attrs, 0, sizeof(element_attrs)); 1095 if (pavrc_cmd->get_elem_attrs.num_attr == 0) 1096 { 1097 /* CT requests for all attributes */ 1098 int attr_cnt; 1099 num_attr = BTRC_MAX_ELEM_ATTR_SIZE; 1100 for (attr_cnt = 0; attr_cnt < BTRC_MAX_ELEM_ATTR_SIZE; attr_cnt++) 1101 { 1102 element_attrs[attr_cnt] = attr_cnt + 1; 1103 } 1104 } 1105 else if (pavrc_cmd->get_elem_attrs.num_attr == 0xFF) 1106 { 1107 /* 0xff indicates, no attributes requested - reject */ 1108 send_reject_response (btif_rc_cb.rc_handle, label, pavrc_cmd->pdu, 1109 AVRC_STS_BAD_PARAM); 1110 return; 1111 } 1112 else 1113 { 1114 int attr_cnt, filled_attr_count; 1115 1116 num_attr = 0; 1117 /* Attribute IDs from 1 to AVRC_MAX_NUM_MEDIA_ATTR_ID are only valid, 1118 * hence HAL definition limits the attributes to AVRC_MAX_NUM_MEDIA_ATTR_ID. 1119 * Fill only valid entries. 1120 */ 1121 for (attr_cnt = 0; (attr_cnt < pavrc_cmd->get_elem_attrs.num_attr) && 1122 (num_attr < AVRC_MAX_NUM_MEDIA_ATTR_ID); attr_cnt++) 1123 { 1124 if ((pavrc_cmd->get_elem_attrs.attrs[attr_cnt] > 0) && 1125 (pavrc_cmd->get_elem_attrs.attrs[attr_cnt] <= AVRC_MAX_NUM_MEDIA_ATTR_ID)) 1126 { 1127 /* Skip the duplicate entries : PTS sends duplicate entries for Fragment cases 1128 */ 1129 for (filled_attr_count = 0; filled_attr_count < num_attr; filled_attr_count++) 1130 { 1131 if (element_attrs[filled_attr_count] == pavrc_cmd->get_elem_attrs.attrs[attr_cnt]) 1132 break; 1133 } 1134 if (filled_attr_count == num_attr) 1135 { 1136 element_attrs[num_attr] = pavrc_cmd->get_elem_attrs.attrs[attr_cnt]; 1137 num_attr++; 1138 } 1139 } 1140 } 1141 } 1142 FILL_PDU_QUEUE(IDX_GET_ELEMENT_ATTR_RSP, ctype, label, TRUE); 1143 HAL_CBACK(bt_rc_callbacks, get_element_attr_cb, num_attr, element_attrs); 1144 } 1145 break; 1146 case AVRC_PDU_REGISTER_NOTIFICATION: 1147 { 1148 if(pavrc_cmd->reg_notif.event_id == BTRC_EVT_PLAY_POS_CHANGED && 1149 pavrc_cmd->reg_notif.param == 0) 1150 { 1151 BTIF_TRACE_WARNING("%s Device registering position changed with illegal param 0.", 1152 __FUNCTION__); 1153 send_reject_response (btif_rc_cb.rc_handle, label, pavrc_cmd->pdu, AVRC_STS_BAD_PARAM); 1154 /* de-register this notification for a rejected response */ 1155 btif_rc_cb.rc_notif[BTRC_EVT_PLAY_POS_CHANGED - 1].bNotify = FALSE; 1156 return; 1157 } 1158 HAL_CBACK(bt_rc_callbacks, register_notification_cb, pavrc_cmd->reg_notif.event_id, 1159 pavrc_cmd->reg_notif.param); 1160 } 1161 break; 1162 case AVRC_PDU_INFORM_DISPLAY_CHARSET: 1163 { 1164 tAVRC_RESPONSE avrc_rsp; 1165 BTIF_TRACE_EVENT("%s() AVRC_PDU_INFORM_DISPLAY_CHARSET", __FUNCTION__); 1166 if(btif_rc_cb.rc_connected == TRUE) 1167 { 1168 memset(&(avrc_rsp.inform_charset), 0, sizeof(tAVRC_RSP)); 1169 avrc_rsp.inform_charset.opcode=opcode_from_pdu(AVRC_PDU_INFORM_DISPLAY_CHARSET); 1170 avrc_rsp.inform_charset.pdu=AVRC_PDU_INFORM_DISPLAY_CHARSET; 1171 avrc_rsp.inform_charset.status=AVRC_STS_NO_ERROR; 1172 send_metamsg_rsp(btif_rc_cb.rc_handle, label, ctype, &avrc_rsp); 1173 } 1174 } 1175 break; 1176 default: 1177 { 1178 send_reject_response (btif_rc_cb.rc_handle, label, pavrc_cmd->pdu, 1179 (pavrc_cmd->pdu == AVRC_PDU_SEARCH)?AVRC_STS_SEARCH_NOT_SUP:AVRC_STS_BAD_CMD); 1180 return; 1181 } 1182 break; 1183 } 1184 1185 } 1186 1187 1188 /******************************************************************************* 1189 ** 1190 ** Function btif_rc_upstreams_rsp_evt 1191 ** 1192 ** Description Executes AVRC UPSTREAMS response events in btif context. 1193 ** 1194 ** Returns void 1195 ** 1196 *******************************************************************************/ 1197 static void btif_rc_upstreams_rsp_evt(UINT16 event, tAVRC_RESPONSE *pavrc_resp, UINT8 ctype, UINT8 label) 1198 { 1199 BTIF_TRACE_EVENT("%s pdu: %s handle: 0x%x ctype:%x label:%x", __FUNCTION__, 1200 dump_rc_pdu(pavrc_resp->pdu), btif_rc_cb.rc_handle, ctype, label); 1201 1202 #if (AVRC_ADV_CTRL_INCLUDED == TRUE) 1203 switch (event) 1204 { 1205 case AVRC_PDU_REGISTER_NOTIFICATION: 1206 { 1207 if(AVRC_RSP_CHANGED==ctype) 1208 btif_rc_cb.rc_volume=pavrc_resp->reg_notif.param.volume; 1209 HAL_CBACK(bt_rc_callbacks, volume_change_cb, pavrc_resp->reg_notif.param.volume,ctype) 1210 } 1211 break; 1212 1213 case AVRC_PDU_SET_ABSOLUTE_VOLUME: 1214 { 1215 BTIF_TRACE_DEBUG("Set absolute volume change event received: volume %d,ctype %d", 1216 pavrc_resp->volume.volume,ctype); 1217 if(AVRC_RSP_ACCEPT==ctype) 1218 btif_rc_cb.rc_volume=pavrc_resp->volume.volume; 1219 HAL_CBACK(bt_rc_callbacks,volume_change_cb,pavrc_resp->volume.volume,ctype) 1220 } 1221 break; 1222 1223 default: 1224 return; 1225 } 1226 #endif 1227 } 1228 1229 /************************************************************************************ 1230 ** AVRCP API Functions 1231 ************************************************************************************/ 1232 1233 /******************************************************************************* 1234 ** 1235 ** Function init 1236 ** 1237 ** Description Initializes the AVRC interface 1238 ** 1239 ** Returns bt_status_t 1240 ** 1241 *******************************************************************************/ 1242 static bt_status_t init(btrc_callbacks_t* callbacks ) 1243 { 1244 BTIF_TRACE_EVENT("## %s ##", __FUNCTION__); 1245 bt_status_t result = BT_STATUS_SUCCESS; 1246 1247 if (bt_rc_callbacks) 1248 return BT_STATUS_DONE; 1249 1250 bt_rc_callbacks = callbacks; 1251 memset (&btif_rc_cb, 0, sizeof(btif_rc_cb)); 1252 btif_rc_cb.rc_vol_label=MAX_LABEL; 1253 btif_rc_cb.rc_volume=MAX_VOLUME; 1254 lbl_init(); 1255 1256 return result; 1257 } 1258 1259 /******************************************************************************* 1260 ** 1261 ** Function init_ctrl 1262 ** 1263 ** Description Initializes the AVRC interface 1264 ** 1265 ** Returns bt_status_t 1266 ** 1267 *******************************************************************************/ 1268 static bt_status_t init_ctrl(btrc_ctrl_callbacks_t* callbacks ) 1269 { 1270 BTIF_TRACE_EVENT("## %s ##", __FUNCTION__); 1271 bt_status_t result = BT_STATUS_SUCCESS; 1272 1273 if (bt_rc_ctrl_callbacks) 1274 return BT_STATUS_DONE; 1275 1276 bt_rc_ctrl_callbacks = callbacks; 1277 memset (&btif_rc_cb, 0, sizeof(btif_rc_cb)); 1278 btif_rc_cb.rc_vol_label=MAX_LABEL; 1279 btif_rc_cb.rc_volume=MAX_VOLUME; 1280 lbl_init(); 1281 1282 return result; 1283 } 1284 1285 /*************************************************************************** 1286 ** 1287 ** Function get_play_status_rsp 1288 ** 1289 ** Description Returns the current play status. 1290 ** This method is called in response to 1291 ** GetPlayStatus request. 1292 ** 1293 ** Returns bt_status_t 1294 ** 1295 ***************************************************************************/ 1296 static bt_status_t get_play_status_rsp(btrc_play_status_t play_status, uint32_t song_len, 1297 uint32_t song_pos) 1298 { 1299 tAVRC_RESPONSE avrc_rsp; 1300 CHECK_RC_CONNECTED 1301 memset(&(avrc_rsp.get_play_status), 0, sizeof(tAVRC_GET_PLAY_STATUS_RSP)); 1302 avrc_rsp.get_play_status.song_len = song_len; 1303 avrc_rsp.get_play_status.song_pos = song_pos; 1304 avrc_rsp.get_play_status.play_status = play_status; 1305 1306 avrc_rsp.get_play_status.pdu = AVRC_PDU_GET_PLAY_STATUS; 1307 avrc_rsp.get_play_status.opcode = opcode_from_pdu(AVRC_PDU_GET_PLAY_STATUS); 1308 avrc_rsp.get_play_status.status = AVRC_STS_NO_ERROR; 1309 /* Send the response */ 1310 SEND_METAMSG_RSP(IDX_GET_PLAY_STATUS_RSP, &avrc_rsp); 1311 return BT_STATUS_SUCCESS; 1312 } 1313 1314 /*************************************************************************** 1315 ** 1316 ** Function get_element_attr_rsp 1317 ** 1318 ** Description Returns the current songs' element attributes 1319 ** in text. 1320 ** 1321 ** Returns bt_status_t 1322 ** 1323 ***************************************************************************/ 1324 static bt_status_t get_element_attr_rsp(uint8_t num_attr, btrc_element_attr_val_t *p_attrs) 1325 { 1326 tAVRC_RESPONSE avrc_rsp; 1327 UINT32 i; 1328 tAVRC_ATTR_ENTRY element_attrs[BTRC_MAX_ELEM_ATTR_SIZE]; 1329 CHECK_RC_CONNECTED 1330 memset(element_attrs, 0, sizeof(tAVRC_ATTR_ENTRY) * num_attr); 1331 1332 if (num_attr == 0) 1333 { 1334 avrc_rsp.get_play_status.status = AVRC_STS_BAD_PARAM; 1335 } 1336 else 1337 { 1338 for (i=0; i<num_attr; i++) { 1339 element_attrs[i].attr_id = p_attrs[i].attr_id; 1340 element_attrs[i].name.charset_id = AVRC_CHARSET_ID_UTF8; 1341 element_attrs[i].name.str_len = (UINT16)strlen((char *)p_attrs[i].text); 1342 element_attrs[i].name.p_str = p_attrs[i].text; 1343 BTIF_TRACE_DEBUG("%s attr_id:0x%x, charset_id:0x%x, str_len:%d, str:%s", 1344 __FUNCTION__, (unsigned int)element_attrs[i].attr_id, 1345 element_attrs[i].name.charset_id, element_attrs[i].name.str_len, 1346 element_attrs[i].name.p_str); 1347 } 1348 avrc_rsp.get_play_status.status = AVRC_STS_NO_ERROR; 1349 } 1350 avrc_rsp.get_elem_attrs.num_attr = num_attr; 1351 avrc_rsp.get_elem_attrs.p_attrs = element_attrs; 1352 avrc_rsp.get_elem_attrs.pdu = AVRC_PDU_GET_ELEMENT_ATTR; 1353 avrc_rsp.get_elem_attrs.opcode = opcode_from_pdu(AVRC_PDU_GET_ELEMENT_ATTR); 1354 /* Send the response */ 1355 SEND_METAMSG_RSP(IDX_GET_ELEMENT_ATTR_RSP, &avrc_rsp); 1356 return BT_STATUS_SUCCESS; 1357 } 1358 1359 /*************************************************************************** 1360 ** 1361 ** Function register_notification_rsp 1362 ** 1363 ** Description Response to the register notification request. 1364 ** in text. 1365 ** 1366 ** Returns bt_status_t 1367 ** 1368 ***************************************************************************/ 1369 static bt_status_t register_notification_rsp(btrc_event_id_t event_id, 1370 btrc_notification_type_t type, btrc_register_notification_t *p_param) 1371 { 1372 tAVRC_RESPONSE avrc_rsp; 1373 CHECK_RC_CONNECTED 1374 BTIF_TRACE_EVENT("## %s ## event_id:%s", __FUNCTION__, dump_rc_notification_event_id(event_id)); 1375 if (btif_rc_cb.rc_notif[event_id-1].bNotify == FALSE) 1376 { 1377 BTIF_TRACE_ERROR("Avrcp Event id not registered: event_id = %x", event_id); 1378 return BT_STATUS_NOT_READY; 1379 } 1380 memset(&(avrc_rsp.reg_notif), 0, sizeof(tAVRC_REG_NOTIF_RSP)); 1381 avrc_rsp.reg_notif.event_id = event_id; 1382 1383 switch(event_id) 1384 { 1385 case BTRC_EVT_PLAY_STATUS_CHANGED: 1386 avrc_rsp.reg_notif.param.play_status = p_param->play_status; 1387 if (avrc_rsp.reg_notif.param.play_status == PLAY_STATUS_PLAYING) 1388 btif_av_clear_remote_suspend_flag(); 1389 break; 1390 case BTRC_EVT_TRACK_CHANGE: 1391 memcpy(&(avrc_rsp.reg_notif.param.track), &(p_param->track), sizeof(btrc_uid_t)); 1392 break; 1393 case BTRC_EVT_PLAY_POS_CHANGED: 1394 avrc_rsp.reg_notif.param.play_pos = p_param->song_pos; 1395 break; 1396 default: 1397 BTIF_TRACE_WARNING("%s : Unhandled event ID : 0x%x", __FUNCTION__, event_id); 1398 return BT_STATUS_UNHANDLED; 1399 } 1400 1401 avrc_rsp.reg_notif.pdu = AVRC_PDU_REGISTER_NOTIFICATION; 1402 avrc_rsp.reg_notif.opcode = opcode_from_pdu(AVRC_PDU_REGISTER_NOTIFICATION); 1403 avrc_rsp.get_play_status.status = AVRC_STS_NO_ERROR; 1404 1405 /* Send the response. */ 1406 send_metamsg_rsp(btif_rc_cb.rc_handle, btif_rc_cb.rc_notif[event_id-1].label, 1407 ((type == BTRC_NOTIFICATION_TYPE_INTERIM)?AVRC_CMD_NOTIF:AVRC_RSP_CHANGED), &avrc_rsp); 1408 return BT_STATUS_SUCCESS; 1409 } 1410 1411 /*************************************************************************** 1412 ** 1413 ** Function set_volume 1414 ** 1415 ** Description Send current volume setting to remote side. 1416 ** Support limited to SetAbsoluteVolume 1417 ** This can be enhanced to support Relative Volume (AVRCP 1.0). 1418 ** With RelateVolume, we will send VOLUME_UP/VOLUME_DOWN 1419 ** as opposed to absolute volume level 1420 ** volume: Should be in the range 0-127. bit7 is reseved and cannot be set 1421 ** 1422 ** Returns bt_status_t 1423 ** 1424 ***************************************************************************/ 1425 static bt_status_t set_volume(uint8_t volume) 1426 { 1427 BTIF_TRACE_DEBUG("%s", __FUNCTION__); 1428 CHECK_RC_CONNECTED 1429 tAVRC_STS status = BT_STATUS_UNSUPPORTED; 1430 rc_transaction_t *p_transaction=NULL; 1431 1432 if(btif_rc_cb.rc_volume==volume) 1433 { 1434 status=BT_STATUS_DONE; 1435 BTIF_TRACE_ERROR("%s: volume value already set earlier: 0x%02x",__FUNCTION__, volume); 1436 return status; 1437 } 1438 1439 if ((btif_rc_cb.rc_features & BTA_AV_FEAT_RCTG) && 1440 (btif_rc_cb.rc_features & BTA_AV_FEAT_ADV_CTRL)) 1441 { 1442 tAVRC_COMMAND avrc_cmd = {0}; 1443 BT_HDR *p_msg = NULL; 1444 1445 BTIF_TRACE_DEBUG("%s: Peer supports absolute volume. newVolume=%d", __FUNCTION__, volume); 1446 avrc_cmd.volume.opcode = AVRC_OP_VENDOR; 1447 avrc_cmd.volume.pdu = AVRC_PDU_SET_ABSOLUTE_VOLUME; 1448 avrc_cmd.volume.status = AVRC_STS_NO_ERROR; 1449 avrc_cmd.volume.volume = volume; 1450 1451 if (AVRC_BldCommand(&avrc_cmd, &p_msg) == AVRC_STS_NO_ERROR) 1452 { 1453 bt_status_t tran_status=get_transaction(&p_transaction); 1454 if(BT_STATUS_SUCCESS == tran_status && NULL!=p_transaction) 1455 { 1456 BTIF_TRACE_DEBUG("%s msgreq being sent out with label %d", 1457 __FUNCTION__,p_transaction->lbl); 1458 BTA_AvMetaCmd(btif_rc_cb.rc_handle,p_transaction->lbl, AVRC_CMD_CTRL, p_msg); 1459 status = BT_STATUS_SUCCESS; 1460 } 1461 else 1462 { 1463 if(NULL!=p_msg) 1464 GKI_freebuf(p_msg); 1465 BTIF_TRACE_ERROR("%s: failed to obtain transaction details. status: 0x%02x", 1466 __FUNCTION__, tran_status); 1467 status = BT_STATUS_FAIL; 1468 } 1469 } 1470 else 1471 { 1472 BTIF_TRACE_ERROR("%s: failed to build absolute volume command. status: 0x%02x", 1473 __FUNCTION__, status); 1474 status = BT_STATUS_FAIL; 1475 } 1476 } 1477 else 1478 status=BT_STATUS_NOT_READY; 1479 return status; 1480 } 1481 1482 1483 /*************************************************************************** 1484 ** 1485 ** Function register_volumechange 1486 ** 1487 ** Description Register for volume change notification from remote side. 1488 ** 1489 ** Returns void 1490 ** 1491 ***************************************************************************/ 1492 1493 static void register_volumechange (UINT8 lbl) 1494 { 1495 tAVRC_COMMAND avrc_cmd = {0}; 1496 BT_HDR *p_msg = NULL; 1497 tAVRC_STS BldResp=AVRC_STS_BAD_CMD; 1498 rc_transaction_t *p_transaction=NULL; 1499 1500 BTIF_TRACE_DEBUG("%s called with label:%d",__FUNCTION__,lbl); 1501 1502 avrc_cmd.cmd.opcode=0x00; 1503 avrc_cmd.pdu = AVRC_PDU_REGISTER_NOTIFICATION; 1504 avrc_cmd.reg_notif.event_id = AVRC_EVT_VOLUME_CHANGE; 1505 avrc_cmd.reg_notif.status = AVRC_STS_NO_ERROR; 1506 1507 BldResp=AVRC_BldCommand(&avrc_cmd, &p_msg); 1508 if(AVRC_STS_NO_ERROR==BldResp && p_msg) 1509 { 1510 p_transaction=get_transaction_by_lbl(lbl); 1511 if(NULL!=p_transaction) 1512 { 1513 BTA_AvMetaCmd(btif_rc_cb.rc_handle,p_transaction->lbl, AVRC_CMD_NOTIF, p_msg); 1514 BTIF_TRACE_DEBUG("%s:BTA_AvMetaCmd called",__FUNCTION__); 1515 } 1516 else 1517 { 1518 if(NULL!=p_msg) 1519 GKI_freebuf(p_msg); 1520 BTIF_TRACE_ERROR("%s transaction not obtained with label: %d",__FUNCTION__,lbl); 1521 } 1522 } 1523 else 1524 BTIF_TRACE_ERROR("%s failed to build command:%d",__FUNCTION__,BldResp); 1525 } 1526 1527 1528 /*************************************************************************** 1529 ** 1530 ** Function handle_rc_metamsg_rsp 1531 ** 1532 ** Description Handle RC metamessage response 1533 ** 1534 ** Returns void 1535 ** 1536 ***************************************************************************/ 1537 static void handle_rc_metamsg_rsp(tBTA_AV_META_MSG *pmeta_msg) 1538 { 1539 tAVRC_RESPONSE avrc_response = {0}; 1540 UINT8 scratch_buf[512] = {0}; 1541 tAVRC_STS status = BT_STATUS_UNSUPPORTED; 1542 1543 if(AVRC_OP_VENDOR==pmeta_msg->p_msg->hdr.opcode &&(AVRC_RSP_CHANGED==pmeta_msg->code 1544 || AVRC_RSP_INTERIM==pmeta_msg->code || AVRC_RSP_ACCEPT==pmeta_msg->code 1545 || AVRC_RSP_REJ==pmeta_msg->code || AVRC_RSP_NOT_IMPL==pmeta_msg->code)) 1546 { 1547 status=AVRC_ParsResponse(pmeta_msg->p_msg, &avrc_response, scratch_buf, sizeof(scratch_buf)); 1548 BTIF_TRACE_DEBUG("%s: code %d,event ID %d,PDU %x,parsing status %d, label:%d", 1549 __FUNCTION__,pmeta_msg->code,avrc_response.reg_notif.event_id,avrc_response.reg_notif.pdu, 1550 status, pmeta_msg->label); 1551 1552 if (status != AVRC_STS_NO_ERROR) 1553 { 1554 if(AVRC_PDU_REGISTER_NOTIFICATION==avrc_response.rsp.pdu 1555 && AVRC_EVT_VOLUME_CHANGE==avrc_response.reg_notif.event_id 1556 && btif_rc_cb.rc_vol_label==pmeta_msg->label) 1557 { 1558 btif_rc_cb.rc_vol_label=MAX_LABEL; 1559 release_transaction(btif_rc_cb.rc_vol_label); 1560 } 1561 else if(AVRC_PDU_SET_ABSOLUTE_VOLUME==avrc_response.rsp.pdu) 1562 { 1563 release_transaction(pmeta_msg->label); 1564 } 1565 return; 1566 } 1567 else if(AVRC_PDU_REGISTER_NOTIFICATION==avrc_response.rsp.pdu 1568 && AVRC_EVT_VOLUME_CHANGE==avrc_response.reg_notif.event_id 1569 && btif_rc_cb.rc_vol_label!=pmeta_msg->label) 1570 { 1571 // Just discard the message, if the device sends back with an incorrect label 1572 BTIF_TRACE_DEBUG("%s:Discarding register notfn in rsp.code: %d and label %d", 1573 __FUNCTION__, pmeta_msg->code, pmeta_msg->label); 1574 return; 1575 } 1576 } 1577 else 1578 { 1579 BTIF_TRACE_DEBUG("%s:Received vendor dependent in adv ctrl rsp. code: %d len: %d. Not processing it.", 1580 __FUNCTION__, pmeta_msg->code, pmeta_msg->len); 1581 return; 1582 } 1583 1584 if(AVRC_PDU_REGISTER_NOTIFICATION==avrc_response.rsp.pdu 1585 && AVRC_EVT_VOLUME_CHANGE==avrc_response.reg_notif.event_id 1586 && AVRC_RSP_CHANGED==pmeta_msg->code) 1587 { 1588 /* re-register for volume change notification */ 1589 // Do not re-register for rejected case, as it might get into endless loop 1590 register_volumechange(btif_rc_cb.rc_vol_label); 1591 } 1592 else if(AVRC_PDU_SET_ABSOLUTE_VOLUME==avrc_response.rsp.pdu) 1593 { 1594 /* free up the label here */ 1595 release_transaction(pmeta_msg->label); 1596 } 1597 1598 BTIF_TRACE_EVENT("%s: Passing received metamsg response to app. pdu: %s", 1599 __FUNCTION__, dump_rc_pdu(avrc_response.pdu)); 1600 btif_rc_upstreams_rsp_evt((uint16_t)avrc_response.rsp.pdu, &avrc_response, pmeta_msg->code, 1601 pmeta_msg->label); 1602 } 1603 1604 1605 /*************************************************************************** 1606 ** 1607 ** Function cleanup 1608 ** 1609 ** Description Closes the AVRC interface 1610 ** 1611 ** Returns void 1612 ** 1613 ***************************************************************************/ 1614 static void cleanup() 1615 { 1616 BTIF_TRACE_EVENT("## %s ##", __FUNCTION__); 1617 close_uinput(); 1618 if (bt_rc_callbacks) 1619 { 1620 bt_rc_callbacks = NULL; 1621 } 1622 memset(&btif_rc_cb, 0, sizeof(btif_rc_cb_t)); 1623 lbl_destroy(); 1624 BTIF_TRACE_EVENT("## %s ## completed", __FUNCTION__); 1625 } 1626 1627 /*************************************************************************** 1628 ** 1629 ** Function cleanup_ctrl 1630 ** 1631 ** Description Closes the AVRC Controller interface 1632 ** 1633 ** Returns void 1634 ** 1635 ***************************************************************************/ 1636 static void cleanup_ctrl() 1637 { 1638 BTIF_TRACE_EVENT("## %s ##", __FUNCTION__); 1639 1640 if (bt_rc_ctrl_callbacks) 1641 { 1642 bt_rc_ctrl_callbacks = NULL; 1643 } 1644 memset(&btif_rc_cb, 0, sizeof(btif_rc_cb_t)); 1645 lbl_destroy(); 1646 BTIF_TRACE_EVENT("## %s ## completed", __FUNCTION__); 1647 } 1648 1649 static bt_status_t send_passthrough_cmd(bt_bdaddr_t *bd_addr, uint8_t key_code, uint8_t key_state) 1650 { 1651 tAVRC_STS status = BT_STATUS_UNSUPPORTED; 1652 #if (AVRC_CTLR_INCLUDED == TRUE) 1653 CHECK_RC_CONNECTED 1654 rc_transaction_t *p_transaction=NULL; 1655 BTIF_TRACE_DEBUG("%s: key-code: %d, key-state: %d", __FUNCTION__, 1656 key_code, key_state); 1657 if (btif_rc_cb.rc_features & BTA_AV_FEAT_RCTG) 1658 { 1659 bt_status_t tran_status = get_transaction(&p_transaction); 1660 if(BT_STATUS_SUCCESS == tran_status && NULL != p_transaction) 1661 { 1662 BTA_AvRemoteCmd(btif_rc_cb.rc_handle, p_transaction->lbl, 1663 (tBTA_AV_RC)key_code, (tBTA_AV_STATE)key_state); 1664 status = BT_STATUS_SUCCESS; 1665 BTIF_TRACE_DEBUG("%s: succesfully sent passthrough command to BTA", __FUNCTION__); 1666 } 1667 else 1668 { 1669 status = BT_STATUS_FAIL; 1670 BTIF_TRACE_DEBUG("%s: error in fetching transaction", __FUNCTION__); 1671 } 1672 } 1673 else 1674 { 1675 status = BT_STATUS_FAIL; 1676 BTIF_TRACE_DEBUG("%s: feature not supported", __FUNCTION__); 1677 } 1678 #else 1679 BTIF_TRACE_DEBUG("%s: feature not enabled", __FUNCTION__); 1680 #endif 1681 return status; 1682 } 1683 1684 static const btrc_interface_t bt_rc_interface = { 1685 sizeof(bt_rc_interface), 1686 init, 1687 get_play_status_rsp, 1688 NULL, /* list_player_app_attr_rsp */ 1689 NULL, /* list_player_app_value_rsp */ 1690 NULL, /* get_player_app_value_rsp */ 1691 NULL, /* get_player_app_attr_text_rsp */ 1692 NULL, /* get_player_app_value_text_rsp */ 1693 get_element_attr_rsp, 1694 NULL, /* set_player_app_value_rsp */ 1695 register_notification_rsp, 1696 set_volume, 1697 cleanup, 1698 }; 1699 1700 static const btrc_ctrl_interface_t bt_rc_ctrl_interface = { 1701 sizeof(bt_rc_ctrl_interface), 1702 init_ctrl, 1703 send_passthrough_cmd, 1704 cleanup_ctrl, 1705 }; 1706 1707 /******************************************************************************* 1708 ** 1709 ** Function btif_rc_get_interface 1710 ** 1711 ** Description Get the AVRCP Target callback interface 1712 ** 1713 ** Returns btav_interface_t 1714 ** 1715 *******************************************************************************/ 1716 const btrc_interface_t *btif_rc_get_interface(void) 1717 { 1718 BTIF_TRACE_EVENT("%s", __FUNCTION__); 1719 return &bt_rc_interface; 1720 } 1721 1722 /******************************************************************************* 1723 ** 1724 ** Function btif_rc_ctrl_get_interface 1725 ** 1726 ** Description Get the AVRCP Controller callback interface 1727 ** 1728 ** Returns btav_interface_t 1729 ** 1730 *******************************************************************************/ 1731 const btrc_ctrl_interface_t *btif_rc_ctrl_get_interface(void) 1732 { 1733 BTIF_TRACE_EVENT("%s", __FUNCTION__); 1734 return &bt_rc_ctrl_interface; 1735 } 1736 1737 /******************************************************************************* 1738 ** Function initialize_transaction 1739 ** 1740 ** Description Initializes fields of the transaction structure 1741 ** 1742 ** Returns void 1743 *******************************************************************************/ 1744 static void initialize_transaction(int lbl) 1745 { 1746 pthread_mutex_lock(&device.lbllock); 1747 if(lbl < MAX_TRANSACTIONS_PER_SESSION) 1748 { 1749 device.transaction[lbl].lbl = lbl; 1750 device.transaction[lbl].in_use=FALSE; 1751 device.transaction[lbl].handle=0; 1752 } 1753 pthread_mutex_unlock(&device.lbllock); 1754 } 1755 1756 /******************************************************************************* 1757 ** Function lbl_init 1758 ** 1759 ** Description Initializes label structures and mutexes. 1760 ** 1761 ** Returns void 1762 *******************************************************************************/ 1763 void lbl_init() 1764 { 1765 memset(&device,0,sizeof(rc_device_t)); 1766 pthread_mutexattr_t attr; 1767 pthread_mutexattr_init(&attr); 1768 pthread_mutex_init(&(device.lbllock), &attr); 1769 pthread_mutexattr_destroy(&attr); 1770 init_all_transactions(); 1771 } 1772 1773 /******************************************************************************* 1774 ** 1775 ** Function init_all_transactions 1776 ** 1777 ** Description Initializes all transactions 1778 ** 1779 ** Returns void 1780 *******************************************************************************/ 1781 void init_all_transactions() 1782 { 1783 UINT8 txn_indx=0; 1784 for(txn_indx=0; txn_indx < MAX_TRANSACTIONS_PER_SESSION; txn_indx++) 1785 { 1786 initialize_transaction(txn_indx); 1787 } 1788 } 1789 1790 /******************************************************************************* 1791 ** 1792 ** Function get_transaction_by_lbl 1793 ** 1794 ** Description Will return a transaction based on the label. If not inuse 1795 ** will return an error. 1796 ** 1797 ** Returns bt_status_t 1798 *******************************************************************************/ 1799 rc_transaction_t *get_transaction_by_lbl(UINT8 lbl) 1800 { 1801 rc_transaction_t *transaction = NULL; 1802 pthread_mutex_lock(&device.lbllock); 1803 1804 /* Determine if this is a valid label */ 1805 if (lbl < MAX_TRANSACTIONS_PER_SESSION) 1806 { 1807 if (FALSE==device.transaction[lbl].in_use) 1808 { 1809 transaction = NULL; 1810 } 1811 else 1812 { 1813 transaction = &(device.transaction[lbl]); 1814 BTIF_TRACE_DEBUG("%s: Got transaction.label: %d",__FUNCTION__,lbl); 1815 } 1816 } 1817 1818 pthread_mutex_unlock(&device.lbllock); 1819 return transaction; 1820 } 1821 1822 /******************************************************************************* 1823 ** 1824 ** Function get_transaction 1825 ** 1826 ** Description Obtains the transaction details. 1827 ** 1828 ** Returns bt_status_t 1829 *******************************************************************************/ 1830 1831 bt_status_t get_transaction(rc_transaction_t **ptransaction) 1832 { 1833 bt_status_t result = BT_STATUS_NOMEM; 1834 UINT8 i=0; 1835 pthread_mutex_lock(&device.lbllock); 1836 1837 // Check for unused transactions 1838 for (i=0; i<MAX_TRANSACTIONS_PER_SESSION; i++) 1839 { 1840 if (FALSE==device.transaction[i].in_use) 1841 { 1842 BTIF_TRACE_DEBUG("%s:Got transaction.label: %d",__FUNCTION__,device.transaction[i].lbl); 1843 device.transaction[i].in_use = TRUE; 1844 *ptransaction = &(device.transaction[i]); 1845 result = BT_STATUS_SUCCESS; 1846 break; 1847 } 1848 } 1849 1850 pthread_mutex_unlock(&device.lbllock); 1851 return result; 1852 } 1853 1854 1855 /******************************************************************************* 1856 ** 1857 ** Function release_transaction 1858 ** 1859 ** Description Will release a transaction for reuse 1860 ** 1861 ** Returns bt_status_t 1862 *******************************************************************************/ 1863 void release_transaction(UINT8 lbl) 1864 { 1865 rc_transaction_t *transaction = get_transaction_by_lbl(lbl); 1866 1867 /* If the transaction is in use... */ 1868 if (transaction != NULL) 1869 { 1870 BTIF_TRACE_DEBUG("%s: lbl: %d", __FUNCTION__, lbl); 1871 initialize_transaction(lbl); 1872 } 1873 } 1874 1875 /******************************************************************************* 1876 ** 1877 ** Function lbl_destroy 1878 ** 1879 ** Description Cleanup of the mutex 1880 ** 1881 ** Returns void 1882 *******************************************************************************/ 1883 void lbl_destroy() 1884 { 1885 pthread_mutex_destroy(&(device.lbllock)); 1886 } 1887 1888 /******************************************************************************* 1889 ** Function dev_blacklisted_for_absolute_volume 1890 ** 1891 ** Description Blacklist Devices that donot handle absolute volume well 1892 ** We are blacklisting all the devices that are not in whitelist 1893 ** 1894 ** Returns True if the device is in the list 1895 *******************************************************************************/ 1896 static BOOLEAN dev_blacklisted_for_absolute_volume(BD_ADDR peer_dev) 1897 { 1898 int i; 1899 char *dev_name_str = NULL; 1900 int whitelist_size = sizeof(rc_white_addr_prefix)/sizeof(rc_white_addr_prefix[0]); 1901 1902 for (i = 0; i < whitelist_size; i++) { 1903 if (rc_white_addr_prefix[i][0] == peer_dev[0] && 1904 rc_white_addr_prefix[i][1] == peer_dev[1] && 1905 rc_white_addr_prefix[i][2] == peer_dev[2]) { 1906 BTIF_TRACE_DEBUG("whitelist absolute volume for %02x:%02x:%02x", 1907 peer_dev[0], peer_dev[1], peer_dev[2]); 1908 return FALSE; 1909 } 1910 } 1911 1912 dev_name_str = BTM_SecReadDevName(peer_dev); 1913 whitelist_size = sizeof(rc_white_name)/sizeof(char*); 1914 if (dev_name_str != NULL) { 1915 for (i = 0; i < whitelist_size; i++) { 1916 if (strcmp(dev_name_str, rc_white_name[i]) == 0) { 1917 BTIF_TRACE_DEBUG("whitelist absolute volume for %s", dev_name_str); 1918 return FALSE; 1919 } 1920 } 1921 } 1922 1923 BTIF_TRACE_WARNING("blacklist absolute volume for %02x:%02x:%02x, name = %s", 1924 peer_dev[0], peer_dev[1], peer_dev[2], dev_name_str); 1925 return TRUE; 1926 } 1927
