1 /****************************************************************************** 2 * 3 * Copyright 2009-2016 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 #define LOG_TAG "btif_av" 20 21 #include "btif_av.h" 22 23 #include <base/bind.h> 24 #include <base/logging.h> 25 #include <base/strings/stringprintf.h> 26 #include <string.h> 27 #include <map> 28 29 #include <hardware/bluetooth.h> 30 #include <hardware/bt_av.h> 31 #include <hardware/bt_rc.h> 32 33 #include "audio_a2dp_hw/include/audio_a2dp_hw.h" 34 #include "bt_common.h" 35 #include "bt_utils.h" 36 #include "bta/include/bta_api.h" 37 #include "bta/include/bta_closure_api.h" 38 #include "btif/include/btif_a2dp_source.h" 39 #include "btif_a2dp.h" 40 #include "btif_a2dp_audio_interface.h" 41 #include "btif_a2dp_control.h" 42 #include "btif_a2dp_sink.h" 43 #include "btif_av_co.h" 44 #include "btif_profile_queue.h" 45 #include "btif_rc.h" 46 #include "btif_state_machine.h" 47 #include "btif_util.h" 48 #include "btu.h" 49 #include "osi/include/allocator.h" 50 #include "osi/include/osi.h" 51 #include "osi/include/properties.h" 52 53 /***************************************************************************** 54 * Constants & Macros 55 *****************************************************************************/ 56 static const std::string kBtifAvSourceServiceName = "Advanced Audio Source"; 57 static const std::string kBtifAvSinkServiceName = "Advanced Audio Sink"; 58 static constexpr int kDefaultMaxConnectedAudioDevices = 1; 59 static constexpr tBTA_AV_HNDL kBtaHandleUnknown = 0; 60 61 /***************************************************************************** 62 * Local type definitions 63 *****************************************************************************/ 64 65 typedef struct { 66 int sample_rate; 67 int channel_count; 68 RawAddress peer_address; 69 } btif_av_sink_config_req_t; 70 71 /** 72 * BTIF AV events 73 */ 74 typedef enum { 75 /* Reuse BTA_AV_XXX_EVT - No need to redefine them here */ 76 BTIF_AV_CONNECT_REQ_EVT = BTA_AV_MAX_EVT, 77 BTIF_AV_DISCONNECT_REQ_EVT, 78 BTIF_AV_START_STREAM_REQ_EVT, 79 BTIF_AV_STOP_STREAM_REQ_EVT, 80 BTIF_AV_SUSPEND_STREAM_REQ_EVT, 81 BTIF_AV_SINK_CONFIG_REQ_EVT, 82 BTIF_AV_ACL_DISCONNECTED, 83 BTIF_AV_OFFLOAD_START_REQ_EVT, 84 BTIF_AV_AVRCP_OPEN_EVT, 85 BTIF_AV_AVRCP_CLOSE_EVT, 86 BTIF_AV_AVRCP_REMOTE_PLAY_EVT, 87 } btif_av_sm_event_t; 88 89 class BtifAvEvent { 90 public: 91 BtifAvEvent(uint32_t event, const void* p_data, size_t data_length); 92 BtifAvEvent(const BtifAvEvent& other); 93 BtifAvEvent() = delete; 94 ~BtifAvEvent(); 95 BtifAvEvent& operator=(const BtifAvEvent& other); 96 97 uint32_t Event() const { return event_; } 98 void* Data() const { return data_; } 99 size_t DataLength() const { return data_length_; } 100 std::string ToString() const; 101 static std::string EventName(uint32_t event); 102 103 private: 104 void DeepCopy(uint32_t event, const void* p_data, size_t data_length); 105 void DeepFree(); 106 107 uint32_t event_; 108 void* data_; 109 size_t data_length_; 110 }; 111 112 class BtifAvPeer; 113 114 // Should not need dedicated Suspend state as actual actions are no 115 // different than Open state. Suspend flags are needed however to prevent 116 // media task from trying to restart stream during remote Suspend or while 117 // we are in the process of a local Suspend. 118 class BtifAvStateMachine : public BtifStateMachine { 119 public: 120 enum { 121 kStateIdle, // AVDTP disconnected 122 kStateOpening, // Opening AVDTP connection 123 kStateOpened, // AVDTP is in OPEN state 124 kStateStarted, // A2DP stream started 125 kStateClosing, // Closing AVDTP connection 126 }; 127 128 class StateIdle : public State { 129 public: 130 StateIdle(BtifAvStateMachine& sm) 131 : State(sm, kStateIdle), peer_(sm.Peer()) {} 132 void OnEnter() override; 133 void OnExit() override; 134 bool ProcessEvent(uint32_t event, void* p_data) override; 135 136 private: 137 BtifAvPeer& peer_; 138 }; 139 140 class StateOpening : public State { 141 public: 142 StateOpening(BtifAvStateMachine& sm) 143 : State(sm, kStateOpening), peer_(sm.Peer()) {} 144 void OnEnter() override; 145 void OnExit() override; 146 bool ProcessEvent(uint32_t event, void* p_data) override; 147 148 private: 149 BtifAvPeer& peer_; 150 }; 151 152 class StateOpened : public State { 153 public: 154 StateOpened(BtifAvStateMachine& sm) 155 : State(sm, kStateOpened), peer_(sm.Peer()) {} 156 void OnEnter() override; 157 void OnExit() override; 158 bool ProcessEvent(uint32_t event, void* p_data) override; 159 160 private: 161 BtifAvPeer& peer_; 162 }; 163 164 class StateStarted : public State { 165 public: 166 StateStarted(BtifAvStateMachine& sm) 167 : State(sm, kStateStarted), peer_(sm.Peer()) {} 168 void OnEnter() override; 169 void OnExit() override; 170 bool ProcessEvent(uint32_t event, void* p_data) override; 171 172 private: 173 BtifAvPeer& peer_; 174 }; 175 176 class StateClosing : public State { 177 public: 178 StateClosing(BtifAvStateMachine& sm) 179 : State(sm, kStateClosing), peer_(sm.Peer()) {} 180 void OnEnter() override; 181 void OnExit() override; 182 bool ProcessEvent(uint32_t event, void* p_data) override; 183 184 private: 185 BtifAvPeer& peer_; 186 }; 187 188 BtifAvStateMachine(BtifAvPeer& btif_av_peer) : peer_(btif_av_peer) { 189 state_idle_ = new StateIdle(*this); 190 state_opening_ = new StateOpening(*this); 191 state_opened_ = new StateOpened(*this); 192 state_started_ = new StateStarted(*this); 193 state_closing_ = new StateClosing(*this); 194 195 AddState(state_idle_); 196 AddState(state_opening_); 197 AddState(state_opened_); 198 AddState(state_started_); 199 AddState(state_closing_); 200 SetInitialState(state_idle_); 201 } 202 203 BtifAvPeer& Peer() { return peer_; } 204 205 private: 206 BtifAvPeer& peer_; 207 StateIdle* state_idle_; 208 StateOpening* state_opening_; 209 StateOpened* state_opened_; 210 StateStarted* state_started_; 211 StateClosing* state_closing_; 212 }; 213 214 class BtifAvPeer { 215 public: 216 enum { 217 kFlagLocalSuspendPending = 0x1, 218 kFlagRemoteSuspend = 0x2, 219 kFlagPendingStart = 0x4, 220 kFlagPendingStop = 0x8, 221 }; 222 static constexpr period_ms_t kTimeoutAvOpenOnRcMs = 2 * 1000; // 2s 223 224 BtifAvPeer(const RawAddress& peer_address, uint8_t peer_sep, 225 tBTA_AV_HNDL bta_handle, uint8_t peer_id); 226 ~BtifAvPeer(); 227 228 bt_status_t Init(); 229 void Cleanup(); 230 231 /** 232 * Check whether the peer can be deleted. 233 * 234 * @return true if the pair can be deleted, otherwise false 235 */ 236 bool CanBeDeleted() const; 237 238 /** 239 * Check whether the peer is the active one. 240 * 241 * @return true if this peer is the active one 242 */ 243 bool IsActivePeer() const { return (PeerAddress() == ActivePeerAddress()); } 244 245 /** 246 * Get the address of the active peer. 247 * 248 * @return the address of the active peer 249 */ 250 const RawAddress& ActivePeerAddress() const; 251 252 const RawAddress& PeerAddress() const { return peer_address_; } 253 bool IsSource() const { return (peer_sep_ == AVDT_TSEP_SRC); } 254 bool IsSink() const { return (peer_sep_ == AVDT_TSEP_SNK); } 255 uint8_t PeerSep() const { return peer_sep_; } 256 /** 257 * Get the local device's Service Class UUID 258 * 259 * @return the local device's Service Class UUID: UUID_SERVCLASS_AUDIO_SOURCE 260 * or UUID_SERVCLASS_AUDIO_SINK 261 */ 262 uint16_t LocalUuidServiceClass() const { 263 return (IsSink() ? UUID_SERVCLASS_AUDIO_SOURCE : UUID_SERVCLASS_AUDIO_SINK); 264 } 265 tBTA_AV_HNDL BtaHandle() const { return bta_handle_; } 266 void SetBtaHandle(tBTA_AV_HNDL bta_handle) { bta_handle_ = bta_handle; } 267 uint8_t PeerId() const { return peer_id_; } 268 269 BtifAvStateMachine& StateMachine() { return state_machine_; } 270 const BtifAvStateMachine& StateMachine() const { return state_machine_; } 271 alarm_t* AvOpenOnRcTimer() { return av_open_on_rc_timer_; } 272 const alarm_t* AvOpenOnRcTimer() const { return av_open_on_rc_timer_; } 273 274 void SetEdr(tBTA_AV_EDR edr) { edr_ = edr; } 275 bool IsEdr() const { return (edr_ != 0); } 276 bool Is3Mbps() const { return ((edr_ & BTA_AV_EDR_3MBPS) != 0); } 277 278 bool IsConnected() const; 279 bool IsStreaming() const; 280 281 /** 282 * Check whether any of the flags specified by the bitlags mask is set. 283 * 284 * @param bitflags_mask the bitflags to check 285 * @return true if any of the flags to check is set, otherwise false. 286 */ 287 bool CheckFlags(uint8_t bitflags_mask) const { 288 return ((flags_ & bitflags_mask) != 0); 289 } 290 291 /** 292 * Set only the flags as specified by the bitflags mask. 293 * 294 * @param bitflags_mask the bitflags to set 295 */ 296 void SetFlags(uint8_t bitflags_mask) { flags_ |= bitflags_mask; } 297 298 /** 299 * Clear only the flags as specified by the bitflags mask. 300 * 301 * @param bitflags_mask the bitflags to clear 302 */ 303 void ClearFlags(uint8_t bitflags_mask) { flags_ &= ~bitflags_mask; } 304 305 /** 306 * Clear all flags. 307 */ 308 void ClearAllFlags() { flags_ = 0; } 309 310 /** 311 * Get a string representation of the flags that are set. 312 */ 313 std::string FlagsToString() const; 314 315 bool SelfInitiatedConnection() const { return self_initiated_connection_; } 316 void SetSelfInitiatedConnection(bool v) { self_initiated_connection_ = v; } 317 318 private: 319 const RawAddress peer_address_; 320 const uint8_t peer_sep_; // SEP type of peer device 321 tBTA_AV_HNDL bta_handle_; 322 const uint8_t peer_id_; 323 BtifAvStateMachine state_machine_; 324 alarm_t* av_open_on_rc_timer_; 325 tBTA_AV_EDR edr_; 326 uint8_t flags_; 327 bool self_initiated_connection_; 328 }; 329 330 class BtifAvSource { 331 public: 332 // The PeerId is used as AppId for BTA_AvRegister() purpose 333 static constexpr uint8_t kPeerIdMin = 0; 334 static constexpr uint8_t kPeerIdMax = BTA_AV_NUM_STRS; 335 336 BtifAvSource() 337 : callbacks_(nullptr), 338 enabled_(false), 339 a2dp_offload_enabled_(false), 340 max_connected_peers_(kDefaultMaxConnectedAudioDevices) {} 341 ~BtifAvSource(); 342 343 bt_status_t Init( 344 btav_source_callbacks_t* callbacks, int max_connected_audio_devices, 345 const std::vector<btav_a2dp_codec_config_t>& codec_priorities); 346 void Cleanup(); 347 348 btav_source_callbacks_t* Callbacks() { return callbacks_; } 349 bool Enabled() const { return enabled_; } 350 bool A2dpOffloadEnabled() const { return a2dp_offload_enabled_; } 351 352 BtifAvPeer* FindPeer(const RawAddress& peer_address); 353 BtifAvPeer* FindPeerByHandle(tBTA_AV_HNDL bta_handle); 354 BtifAvPeer* FindPeerByPeerId(uint8_t peer_id); 355 BtifAvPeer* FindOrCreatePeer(const RawAddress& peer_address, 356 tBTA_AV_HNDL bta_handle); 357 358 /** 359 * Check whether a connection to a peer is allowed. 360 * The check considers the maximum number of connected peers. 361 * 362 * @param peer_address the peer address to connect to 363 * @return true if connection is allowed, otherwise false 364 */ 365 bool AllowedToConnect(const RawAddress& peer_address) const; 366 367 /** 368 * Delete a peer. 369 * 370 * @param peer_address the peer to delete 371 * @return true on success, otherwise false 372 */ 373 bool DeletePeer(const RawAddress& peer_address); 374 375 /** 376 * Delete all peers that have transitioned to Idle state and can be deleted. 377 * If a peer was just created/initialized, then it cannot be deleted yet. 378 */ 379 void DeleteIdlePeers(); 380 381 /** 382 * Get the active peer. 383 * 384 * @return the active peer 385 */ 386 const RawAddress& ActivePeer() const { return active_peer_; } 387 388 /** 389 * Set the active peer. 390 * 391 * @param peer_address the active peer address or RawAddress::kEmpty to 392 * reset the active peer 393 * @return true on success, otherwise false 394 */ 395 bool SetActivePeer(const RawAddress& peer_address) { 396 LOG_INFO(LOG_TAG, "%s: peer: %s", __PRETTY_FUNCTION__, 397 peer_address.ToString().c_str()); 398 399 if (active_peer_ == peer_address) return true; // Nothing has changed 400 if (peer_address.IsEmpty()) { 401 BTIF_TRACE_EVENT("%s: peer address is empty, shutdown the Audio source", 402 __func__); 403 if (!bta_av_co_set_active_peer(peer_address)) { 404 BTIF_TRACE_WARNING("%s: unable to set active peer to empty in BtaAvCo", 405 __func__); 406 } 407 btif_a2dp_source_end_session(active_peer_); 408 btif_a2dp_source_shutdown(); 409 active_peer_ = peer_address; 410 return true; 411 } 412 413 BtifAvPeer* peer = FindPeer(peer_address); 414 if (peer != nullptr && !peer->IsConnected()) { 415 BTIF_TRACE_ERROR("%s: Error setting %s as active Source peer", __func__, 416 peer->PeerAddress().ToString().c_str()); 417 return false; 418 } 419 420 if (!btif_a2dp_source_restart_session(active_peer_, peer_address)) { 421 return false; 422 } 423 active_peer_ = peer_address; 424 return true; 425 } 426 427 /** 428 * Update source codec configuration for a peer. 429 * 430 * @param peer_address the address of the peer to update 431 * @param codec_preferences the updated codec preferences 432 */ 433 void UpdateCodecConfig( 434 const RawAddress& peer_address, 435 const std::vector<btav_a2dp_codec_config_t>& codec_preferences) { 436 // Restart the session if the codec for the active peer is updated 437 bool restart_session = 438 ((active_peer_ == peer_address) && !active_peer_.IsEmpty()); 439 if (restart_session) { 440 btif_a2dp_source_end_session(active_peer_); 441 } 442 443 for (auto cp : codec_preferences) { 444 BTIF_TRACE_DEBUG("%s: codec_preference=%s", __func__, 445 cp.ToString().c_str()); 446 btif_a2dp_source_encoder_user_config_update_req(peer_address, cp); 447 } 448 if (restart_session) { 449 btif_a2dp_source_start_session(active_peer_); 450 } 451 } 452 453 const std::map<RawAddress, BtifAvPeer*>& Peers() const { return peers_; } 454 455 void RegisterAllBtaHandles(); 456 void DeregisterAllBtaHandles(); 457 void BtaHandleRegistered(uint8_t peer_id, tBTA_AV_HNDL bta_handle); 458 459 private: 460 void CleanupAllPeers(); 461 462 btav_source_callbacks_t* callbacks_; 463 bool enabled_; 464 bool a2dp_offload_enabled_; 465 int max_connected_peers_; 466 std::map<RawAddress, BtifAvPeer*> peers_; 467 RawAddress active_peer_; 468 std::map<uint8_t, tBTA_AV_HNDL> peer_id2bta_handle_; 469 }; 470 471 class BtifAvSink { 472 public: 473 // The PeerId is used as AppId for BTA_AvRegister() purpose 474 static constexpr uint8_t kPeerIdMin = 0; 475 static constexpr uint8_t kPeerIdMax = BTA_AV_NUM_STRS; 476 477 BtifAvSink() 478 : callbacks_(nullptr), 479 enabled_(false), 480 max_connected_peers_(kDefaultMaxConnectedAudioDevices) {} 481 ~BtifAvSink(); 482 483 bt_status_t Init(btav_sink_callbacks_t* callbacks); 484 void Cleanup(); 485 486 btav_sink_callbacks_t* Callbacks() { return callbacks_; } 487 bool Enabled() const { return enabled_; } 488 489 BtifAvPeer* FindPeer(const RawAddress& peer_address); 490 BtifAvPeer* FindPeerByHandle(tBTA_AV_HNDL bta_handle); 491 BtifAvPeer* FindPeerByPeerId(uint8_t peer_id); 492 BtifAvPeer* FindOrCreatePeer(const RawAddress& peer_address, 493 tBTA_AV_HNDL bta_handle); 494 495 /** 496 * Check whether a connection to a peer is allowed. 497 * The check considers the maximum number of connected peers. 498 * 499 * @param peer_address the peer address to connect to 500 * @return true if connection is allowed, otherwise false 501 */ 502 bool AllowedToConnect(const RawAddress& peer_address) const; 503 504 /** 505 * Delete a peer. 506 * 507 * @param peer_address the peer to delete 508 * @return true on success, otherwise false 509 */ 510 bool DeletePeer(const RawAddress& peer_address); 511 512 /** 513 * Delete all peers that have transitioned to Idle state and can be deleted. 514 * If a peer was just created/initialized, then it cannot be deleted yet. 515 */ 516 void DeleteIdlePeers(); 517 518 /** 519 * Get the active peer. 520 * 521 * @return the active peer 522 */ 523 const RawAddress& ActivePeer() const { return active_peer_; } 524 525 /** 526 * Set the active peer. 527 * 528 * @param peer_address the active peer address or RawAddress::kEmpty to 529 * reset the active peer 530 * @return true on success, otherwise false 531 */ 532 bool SetActivePeer(const RawAddress& peer_address) { 533 LOG_INFO(LOG_TAG, "%s: peer: %s", __PRETTY_FUNCTION__, 534 peer_address.ToString().c_str()); 535 536 if (active_peer_ == peer_address) return true; // Nothing has changed 537 if (peer_address.IsEmpty()) { 538 BTIF_TRACE_EVENT("%s: peer address is empty, shutdown the Audio sink", 539 __func__); 540 if (!bta_av_co_set_active_peer(peer_address)) { 541 BTIF_TRACE_WARNING("%s: unable to set active peer to empty in BtaAvCo", 542 __func__); 543 } 544 btif_a2dp_sink_end_session(active_peer_); 545 btif_a2dp_sink_shutdown(); 546 active_peer_ = peer_address; 547 return true; 548 } 549 550 BtifAvPeer* peer = FindPeer(peer_address); 551 if (peer != nullptr && !peer->IsConnected()) { 552 BTIF_TRACE_ERROR("%s: Error setting %s as active Sink peer", __func__, 553 peer->PeerAddress().ToString().c_str()); 554 return false; 555 } 556 557 if (!btif_a2dp_sink_restart_session(active_peer_, peer_address)) { 558 return false; 559 } 560 active_peer_ = peer_address; 561 return true; 562 } 563 564 const std::map<RawAddress, BtifAvPeer*>& Peers() const { return peers_; } 565 566 void RegisterAllBtaHandles(); 567 void DeregisterAllBtaHandles(); 568 void BtaHandleRegistered(uint8_t peer_id, tBTA_AV_HNDL bta_handle); 569 570 private: 571 void CleanupAllPeers(); 572 573 btav_sink_callbacks_t* callbacks_; 574 bool enabled_; 575 int max_connected_peers_; 576 std::map<RawAddress, BtifAvPeer*> peers_; 577 RawAddress active_peer_; 578 std::map<uint8_t, tBTA_AV_HNDL> peer_id2bta_handle_; 579 }; 580 581 /***************************************************************************** 582 * Static variables 583 *****************************************************************************/ 584 static BtifAvSource btif_av_source; 585 static BtifAvSink btif_av_sink; 586 587 /* Helper macro to avoid code duplication in the state machine handlers */ 588 #define CHECK_RC_EVENT(e, d) \ 589 case BTA_AV_RC_OPEN_EVT: \ 590 case BTA_AV_RC_BROWSE_OPEN_EVT: \ 591 case BTA_AV_RC_CLOSE_EVT: \ 592 case BTA_AV_RC_BROWSE_CLOSE_EVT: \ 593 case BTA_AV_REMOTE_CMD_EVT: \ 594 case BTA_AV_VENDOR_CMD_EVT: \ 595 case BTA_AV_META_MSG_EVT: \ 596 case BTA_AV_RC_FEAT_EVT: \ 597 case BTA_AV_REMOTE_RSP_EVT: { \ 598 btif_rc_handler(e, d); \ 599 } break; 600 601 static bt_status_t src_disconnect_sink(const RawAddress& peer_address); 602 static bt_status_t sink_disconnect_src(const RawAddress& peer_address); 603 static void btif_av_source_dispatch_sm_event(const RawAddress& peer_address, 604 btif_av_sm_event_t event); 605 static void btif_av_sink_dispatch_sm_event(const RawAddress& peer_address, 606 btif_av_sm_event_t event); 607 static void btif_av_handle_event(uint8_t peer_sep, 608 const RawAddress& peer_address, 609 tBTA_AV_HNDL bta_handle, 610 const BtifAvEvent& btif_av_event); 611 static void btif_report_connection_state(const RawAddress& peer_address, 612 btav_connection_state_t state); 613 static void btif_report_audio_state(const RawAddress& peer_address, 614 btav_audio_state_t state); 615 static void btif_av_report_sink_audio_config_state( 616 const RawAddress& peer_address, int sample_rate, int channel_count); 617 static void btif_av_source_initiate_av_open_timer_timeout(void* data); 618 static void btif_av_sink_initiate_av_open_timer_timeout(void* data); 619 static void bta_av_sink_media_callback(tBTA_AV_EVT event, 620 tBTA_AV_MEDIA* p_data); 621 622 static BtifAvPeer* btif_av_source_find_peer(const RawAddress& peer_address) { 623 return btif_av_source.FindPeer(peer_address); 624 } 625 static BtifAvPeer* btif_av_sink_find_peer(const RawAddress& peer_address) { 626 return btif_av_sink.FindPeer(peer_address); 627 } 628 static BtifAvPeer* btif_av_find_peer(const RawAddress& peer_address) { 629 if (btif_av_source.Enabled()) return btif_av_source_find_peer(peer_address); 630 if (btif_av_sink.Enabled()) return btif_av_sink_find_peer(peer_address); 631 return nullptr; 632 } 633 static BtifAvPeer* btif_av_find_active_peer() { 634 if (btif_av_source.Enabled()) 635 return btif_av_source_find_peer(btif_av_source.ActivePeer()); 636 if (btif_av_sink.Enabled()) 637 return btif_av_sink_find_peer(btif_av_sink.ActivePeer()); 638 return nullptr; 639 } 640 641 /***************************************************************************** 642 * Local helper functions 643 *****************************************************************************/ 644 645 const char* dump_av_sm_event_name(btif_av_sm_event_t event) { 646 switch ((int)event) { 647 CASE_RETURN_STR(BTA_AV_ENABLE_EVT) 648 CASE_RETURN_STR(BTA_AV_REGISTER_EVT) 649 CASE_RETURN_STR(BTA_AV_OPEN_EVT) 650 CASE_RETURN_STR(BTA_AV_CLOSE_EVT) 651 CASE_RETURN_STR(BTA_AV_START_EVT) 652 CASE_RETURN_STR(BTA_AV_STOP_EVT) 653 CASE_RETURN_STR(BTA_AV_PROTECT_REQ_EVT) 654 CASE_RETURN_STR(BTA_AV_PROTECT_RSP_EVT) 655 CASE_RETURN_STR(BTA_AV_RC_OPEN_EVT) 656 CASE_RETURN_STR(BTA_AV_RC_CLOSE_EVT) 657 CASE_RETURN_STR(BTA_AV_RC_BROWSE_OPEN_EVT) 658 CASE_RETURN_STR(BTA_AV_RC_BROWSE_CLOSE_EVT) 659 CASE_RETURN_STR(BTA_AV_REMOTE_CMD_EVT) 660 CASE_RETURN_STR(BTA_AV_REMOTE_RSP_EVT) 661 CASE_RETURN_STR(BTA_AV_VENDOR_CMD_EVT) 662 CASE_RETURN_STR(BTA_AV_VENDOR_RSP_EVT) 663 CASE_RETURN_STR(BTA_AV_RECONFIG_EVT) 664 CASE_RETURN_STR(BTA_AV_SUSPEND_EVT) 665 CASE_RETURN_STR(BTA_AV_PENDING_EVT) 666 CASE_RETURN_STR(BTA_AV_META_MSG_EVT) 667 CASE_RETURN_STR(BTA_AV_REJECT_EVT) 668 CASE_RETURN_STR(BTA_AV_RC_FEAT_EVT) 669 CASE_RETURN_STR(BTA_AV_OFFLOAD_START_RSP_EVT) 670 CASE_RETURN_STR(BTIF_AV_CONNECT_REQ_EVT) 671 CASE_RETURN_STR(BTIF_AV_DISCONNECT_REQ_EVT) 672 CASE_RETURN_STR(BTIF_AV_START_STREAM_REQ_EVT) 673 CASE_RETURN_STR(BTIF_AV_STOP_STREAM_REQ_EVT) 674 CASE_RETURN_STR(BTIF_AV_SUSPEND_STREAM_REQ_EVT) 675 CASE_RETURN_STR(BTIF_AV_SINK_CONFIG_REQ_EVT) 676 CASE_RETURN_STR(BTIF_AV_ACL_DISCONNECTED) 677 CASE_RETURN_STR(BTIF_AV_OFFLOAD_START_REQ_EVT) 678 CASE_RETURN_STR(BTIF_AV_AVRCP_OPEN_EVT) 679 CASE_RETURN_STR(BTIF_AV_AVRCP_CLOSE_EVT) 680 CASE_RETURN_STR(BTIF_AV_AVRCP_REMOTE_PLAY_EVT) 681 default: 682 return "UNKNOWN_EVENT"; 683 } 684 } 685 686 BtifAvEvent::BtifAvEvent(uint32_t event, const void* p_data, size_t data_length) 687 : event_(event), data_(nullptr), data_length_(0) { 688 DeepCopy(event, p_data, data_length); 689 } 690 691 BtifAvEvent::BtifAvEvent(const BtifAvEvent& other) 692 : event_(0), data_(nullptr), data_length_(0) { 693 *this = other; 694 } 695 696 BtifAvEvent& BtifAvEvent::operator=(const BtifAvEvent& other) { 697 DeepFree(); 698 DeepCopy(other.Event(), other.Data(), other.DataLength()); 699 return *this; 700 } 701 702 BtifAvEvent::~BtifAvEvent() { DeepFree(); } 703 704 std::string BtifAvEvent::ToString() const { 705 return BtifAvEvent::EventName(event_); 706 } 707 708 std::string BtifAvEvent::EventName(uint32_t event) { 709 std::string name = dump_av_sm_event_name((btif_av_sm_event_t)event); 710 std::stringstream ss_value; 711 ss_value << "(0x" << std::hex << event << ")"; 712 return name + ss_value.str(); 713 } 714 715 void BtifAvEvent::DeepCopy(uint32_t event, const void* p_data, 716 size_t data_length) { 717 event_ = event; 718 data_length_ = data_length; 719 if (data_length == 0) { 720 data_ = nullptr; 721 } else { 722 data_ = osi_malloc(data_length_); 723 memcpy(data_, p_data, data_length); 724 } 725 726 switch (event) { 727 case BTA_AV_META_MSG_EVT: { 728 CHECK(data_length >= sizeof(tBTA_AV)); 729 const tBTA_AV* av_src = (const tBTA_AV*)p_data; 730 tBTA_AV* av_dest = (tBTA_AV*)data_; 731 if (av_src->meta_msg.p_data && av_src->meta_msg.len) { 732 av_dest->meta_msg.p_data = (uint8_t*)osi_calloc(av_src->meta_msg.len); 733 memcpy(av_dest->meta_msg.p_data, av_src->meta_msg.p_data, 734 av_src->meta_msg.len); 735 } 736 737 if (av_src->meta_msg.p_msg) { 738 av_dest->meta_msg.p_msg = (tAVRC_MSG*)osi_calloc(sizeof(tAVRC_MSG)); 739 memcpy(av_dest->meta_msg.p_msg, av_src->meta_msg.p_msg, 740 sizeof(tAVRC_MSG)); 741 742 tAVRC_MSG* p_msg_src = av_src->meta_msg.p_msg; 743 tAVRC_MSG* p_msg_dest = av_dest->meta_msg.p_msg; 744 745 if ((p_msg_src->hdr.opcode == AVRC_OP_VENDOR) && 746 (p_msg_src->vendor.p_vendor_data && p_msg_src->vendor.vendor_len)) { 747 p_msg_dest->vendor.p_vendor_data = 748 (uint8_t*)osi_calloc(p_msg_src->vendor.vendor_len); 749 memcpy(p_msg_dest->vendor.p_vendor_data, 750 p_msg_src->vendor.p_vendor_data, p_msg_src->vendor.vendor_len); 751 } 752 if ((p_msg_src->hdr.opcode == AVRC_OP_BROWSE) && 753 p_msg_src->browse.p_browse_data && p_msg_src->browse.browse_len) { 754 p_msg_dest->browse.p_browse_data = 755 (uint8_t*)osi_calloc(p_msg_src->browse.browse_len); 756 memcpy(p_msg_dest->browse.p_browse_data, 757 p_msg_src->browse.p_browse_data, p_msg_src->browse.browse_len); 758 } 759 } 760 } break; 761 762 default: 763 break; 764 } 765 } 766 767 void BtifAvEvent::DeepFree() { 768 switch (event_) { 769 case BTA_AV_META_MSG_EVT: { 770 tBTA_AV* av = (tBTA_AV*)data_; 771 osi_free_and_reset((void**)&av->meta_msg.p_data); 772 773 if (av->meta_msg.p_msg) { 774 if (av->meta_msg.p_msg->hdr.opcode == AVRC_OP_VENDOR) { 775 osi_free(av->meta_msg.p_msg->vendor.p_vendor_data); 776 } 777 if (av->meta_msg.p_msg->hdr.opcode == AVRC_OP_BROWSE) { 778 osi_free(av->meta_msg.p_msg->browse.p_browse_data); 779 } 780 osi_free_and_reset((void**)&av->meta_msg.p_msg); 781 } 782 } break; 783 784 default: 785 break; 786 } 787 788 osi_free_and_reset((void**)&data_); 789 data_length_ = 0; 790 } 791 792 BtifAvPeer::BtifAvPeer(const RawAddress& peer_address, uint8_t peer_sep, 793 tBTA_AV_HNDL bta_handle, uint8_t peer_id) 794 : peer_address_(peer_address), 795 peer_sep_(peer_sep), 796 bta_handle_(bta_handle), 797 peer_id_(peer_id), 798 state_machine_(*this), 799 av_open_on_rc_timer_(nullptr), 800 edr_(0), 801 flags_(0), 802 self_initiated_connection_(false) {} 803 804 BtifAvPeer::~BtifAvPeer() { alarm_free(av_open_on_rc_timer_); } 805 806 std::string BtifAvPeer::FlagsToString() const { 807 std::string result; 808 809 if (flags_ & BtifAvPeer::kFlagLocalSuspendPending) { 810 if (!result.empty()) result += "|"; 811 result += "LOCAL_SUSPEND_PENDING"; 812 } 813 if (flags_ & BtifAvPeer::kFlagRemoteSuspend) { 814 if (!result.empty()) result += "|"; 815 result += "REMOTE_SUSPEND"; 816 } 817 if (flags_ & BtifAvPeer::kFlagPendingStart) { 818 if (!result.empty()) result += "|"; 819 result += "PENDING_START"; 820 } 821 if (flags_ & BtifAvPeer::kFlagPendingStop) { 822 if (!result.empty()) result += "|"; 823 result += "PENDING_STOP"; 824 } 825 if (result.empty()) result = "None"; 826 827 return base::StringPrintf("0x%x(%s)", flags_, result.c_str()); 828 } 829 830 bt_status_t BtifAvPeer::Init() { 831 alarm_free(av_open_on_rc_timer_); 832 av_open_on_rc_timer_ = alarm_new("btif_av_peer.av_open_on_rc_timer"); 833 834 state_machine_.Start(); 835 return BT_STATUS_SUCCESS; 836 } 837 838 void BtifAvPeer::Cleanup() { 839 state_machine_.Quit(); 840 alarm_free(av_open_on_rc_timer_); 841 av_open_on_rc_timer_ = nullptr; 842 } 843 844 bool BtifAvPeer::CanBeDeleted() const { 845 return ( 846 (state_machine_.StateId() == BtifAvStateMachine::kStateIdle) && 847 (state_machine_.PreviousStateId() != BtifAvStateMachine::kStateInvalid)); 848 } 849 850 const RawAddress& BtifAvPeer::ActivePeerAddress() const { 851 if (IsSource()) { 852 return btif_av_sink.ActivePeer(); 853 } 854 if (IsSink()) { 855 return btif_av_source.ActivePeer(); 856 } 857 LOG(FATAL) << __PRETTY_FUNCTION__ << ": A2DP peer " << PeerAddress() 858 << " is neither Source nor Sink"; 859 return RawAddress::kEmpty; 860 } 861 862 bool BtifAvPeer::IsConnected() const { 863 int state = state_machine_.StateId(); 864 return ((state == BtifAvStateMachine::kStateOpened) || 865 (state == BtifAvStateMachine::kStateStarted)); 866 } 867 868 bool BtifAvPeer::IsStreaming() const { 869 int state = state_machine_.StateId(); 870 return (state == BtifAvStateMachine::kStateStarted); 871 } 872 873 BtifAvSource::~BtifAvSource() { CleanupAllPeers(); } 874 875 bt_status_t BtifAvSource::Init( 876 btav_source_callbacks_t* callbacks, int max_connected_audio_devices, 877 const std::vector<btav_a2dp_codec_config_t>& codec_priorities) { 878 LOG_INFO(LOG_TAG, "%s: max_connected_audio_devices=%d", __PRETTY_FUNCTION__, 879 max_connected_audio_devices); 880 if (enabled_) return BT_STATUS_SUCCESS; 881 CleanupAllPeers(); 882 max_connected_peers_ = max_connected_audio_devices; 883 884 /* A2DP OFFLOAD */ 885 char value_sup[PROPERTY_VALUE_MAX] = {'\0'}; 886 char value_dis[PROPERTY_VALUE_MAX] = {'\0'}; 887 osi_property_get("ro.bluetooth.a2dp_offload.supported", value_sup, "false"); 888 osi_property_get("persist.bluetooth.a2dp_offload.disabled", value_dis, 889 "false"); 890 a2dp_offload_enabled_ = 891 (strcmp(value_sup, "true") == 0) && (strcmp(value_dis, "false") == 0); 892 BTIF_TRACE_DEBUG("a2dp_offload.enable = %d", a2dp_offload_enabled_); 893 894 callbacks_ = callbacks; 895 bta_av_co_init(codec_priorities); 896 897 if (!btif_a2dp_source_init()) { 898 return BT_STATUS_FAIL; 899 } 900 btif_enable_service(BTA_A2DP_SOURCE_SERVICE_ID); 901 enabled_ = true; 902 return BT_STATUS_SUCCESS; 903 } 904 905 void BtifAvSource::Cleanup() { 906 LOG_INFO(LOG_TAG, "%s", __PRETTY_FUNCTION__); 907 if (!enabled_) return; 908 909 btif_queue_cleanup(UUID_SERVCLASS_AUDIO_SOURCE); 910 911 do_in_bta_thread( 912 FROM_HERE, 913 base::Bind(base::IgnoreResult(&BtifAvSource::SetActivePeer), 914 base::Unretained(&btif_av_source), RawAddress::kEmpty)); 915 do_in_bta_thread(FROM_HERE, base::Bind(&btif_a2dp_source_cleanup)); 916 917 btif_disable_service(BTA_A2DP_SOURCE_SERVICE_ID); 918 CleanupAllPeers(); 919 920 callbacks_ = nullptr; 921 enabled_ = false; 922 } 923 924 BtifAvPeer* BtifAvSource::FindPeer(const RawAddress& peer_address) { 925 auto it = peers_.find(peer_address); 926 if (it != peers_.end()) return it->second; 927 return nullptr; 928 } 929 930 BtifAvPeer* BtifAvSource::FindPeerByHandle(tBTA_AV_HNDL bta_handle) { 931 for (auto it : peers_) { 932 BtifAvPeer* peer = it.second; 933 if (peer->BtaHandle() == bta_handle) { 934 return peer; 935 } 936 } 937 return nullptr; 938 } 939 940 BtifAvPeer* BtifAvSource::FindPeerByPeerId(uint8_t peer_id) { 941 for (auto it : peers_) { 942 BtifAvPeer* peer = it.second; 943 if (peer->PeerId() == peer_id) { 944 return peer; 945 } 946 } 947 return nullptr; 948 } 949 950 BtifAvPeer* BtifAvSource::FindOrCreatePeer(const RawAddress& peer_address, 951 tBTA_AV_HNDL bta_handle) { 952 BTIF_TRACE_DEBUG("%s: peer_address=%s bta_handle=0x%x", __PRETTY_FUNCTION__, 953 peer_address.ToString().c_str(), bta_handle); 954 955 BtifAvPeer* peer = FindPeer(peer_address); 956 if (peer != nullptr) return peer; 957 958 // Find next availabie Peer ID to use 959 uint8_t peer_id; 960 for (peer_id = kPeerIdMin; peer_id < kPeerIdMax; peer_id++) { 961 if (FindPeerByPeerId(peer_id) == nullptr) break; 962 } 963 if (peer_id == kPeerIdMax) { 964 BTIF_TRACE_ERROR( 965 "%s: Cannot create peer for peer_address=%s : " 966 "cannot allocate unique Peer ID", 967 __PRETTY_FUNCTION__, peer_address.ToString().c_str()); 968 return nullptr; 969 } 970 // Get the BTA Handle (if known) 971 if (bta_handle == kBtaHandleUnknown) { 972 auto it = peer_id2bta_handle_.find(peer_id); 973 if (it != peer_id2bta_handle_.end()) { 974 bta_handle = it->second; 975 } 976 } 977 978 LOG_INFO(LOG_TAG, 979 "%s: Create peer: peer_address=%s bta_handle=0x%x peer_id=%d", 980 __PRETTY_FUNCTION__, peer_address.ToString().c_str(), bta_handle, 981 peer_id); 982 peer = new BtifAvPeer(peer_address, AVDT_TSEP_SNK, bta_handle, peer_id); 983 peers_.insert(std::make_pair(peer_address, peer)); 984 peer->Init(); 985 return peer; 986 } 987 988 bool BtifAvSource::AllowedToConnect(const RawAddress& peer_address) const { 989 int connected = 0; 990 991 // Count peers that are in the process of connecting or already connected 992 for (auto it : peers_) { 993 const BtifAvPeer* peer = it.second; 994 switch (peer->StateMachine().StateId()) { 995 case BtifAvStateMachine::kStateOpening: 996 case BtifAvStateMachine::kStateOpened: 997 case BtifAvStateMachine::kStateStarted: 998 if (peer->PeerAddress() == peer_address) { 999 return true; // Already connected or accounted for 1000 } 1001 connected++; 1002 break; 1003 default: 1004 break; 1005 } 1006 } 1007 return (connected < max_connected_peers_); 1008 } 1009 1010 bool BtifAvSource::DeletePeer(const RawAddress& peer_address) { 1011 auto it = peers_.find(peer_address); 1012 if (it == peers_.end()) return false; 1013 BtifAvPeer* peer = it->second; 1014 peer->Cleanup(); 1015 peers_.erase(it); 1016 delete peer; 1017 return true; 1018 } 1019 1020 void BtifAvSource::DeleteIdlePeers() { 1021 for (auto it = peers_.begin(); it != peers_.end();) { 1022 BtifAvPeer* peer = it->second; 1023 auto prev_it = it++; 1024 if (!peer->CanBeDeleted()) continue; 1025 LOG_INFO(LOG_TAG, "%s: Deleting idle peer: %s bta_handle=0x%x", __func__, 1026 peer->PeerAddress().ToString().c_str(), peer->BtaHandle()); 1027 peer->Cleanup(); 1028 peers_.erase(prev_it); 1029 delete peer; 1030 } 1031 } 1032 1033 void BtifAvSource::CleanupAllPeers() { 1034 while (!peers_.empty()) { 1035 auto it = peers_.begin(); 1036 BtifAvPeer* peer = it->second; 1037 peer->Cleanup(); 1038 peers_.erase(it); 1039 delete peer; 1040 } 1041 } 1042 1043 void BtifAvSource::RegisterAllBtaHandles() { 1044 for (int peer_id = kPeerIdMin; peer_id < kPeerIdMax; peer_id++) { 1045 BTA_AvRegister(BTA_AV_CHNL_AUDIO, kBtifAvSourceServiceName.c_str(), peer_id, 1046 nullptr, UUID_SERVCLASS_AUDIO_SOURCE); 1047 } 1048 } 1049 1050 void BtifAvSource::DeregisterAllBtaHandles() { 1051 for (auto it : peer_id2bta_handle_) { 1052 tBTA_AV_HNDL bta_handle = it.second; 1053 BTA_AvDeregister(bta_handle); 1054 } 1055 peer_id2bta_handle_.clear(); 1056 } 1057 1058 void BtifAvSource::BtaHandleRegistered(uint8_t peer_id, 1059 tBTA_AV_HNDL bta_handle) { 1060 peer_id2bta_handle_.insert(std::make_pair(peer_id, bta_handle)); 1061 1062 // Set the BTA Handle for the Peer (if exists) 1063 BtifAvPeer* peer = FindPeerByPeerId(peer_id); 1064 if (peer != nullptr) { 1065 peer->SetBtaHandle(bta_handle); 1066 } 1067 } 1068 1069 BtifAvSink::~BtifAvSink() { CleanupAllPeers(); } 1070 1071 bt_status_t BtifAvSink::Init(btav_sink_callbacks_t* callbacks) { 1072 LOG_INFO(LOG_TAG, "%s", __PRETTY_FUNCTION__); 1073 if (enabled_) return BT_STATUS_SUCCESS; 1074 1075 CleanupAllPeers(); 1076 max_connected_peers_ = kDefaultMaxConnectedAudioDevices; 1077 callbacks_ = callbacks; 1078 1079 std::vector<btav_a2dp_codec_config_t> codec_priorities; // Default priorities 1080 bta_av_co_init(codec_priorities); 1081 1082 if (!btif_a2dp_sink_init()) { 1083 return BT_STATUS_FAIL; 1084 } 1085 btif_enable_service(BTA_A2DP_SINK_SERVICE_ID); 1086 enabled_ = true; 1087 return BT_STATUS_SUCCESS; 1088 } 1089 1090 void BtifAvSink::Cleanup() { 1091 LOG_INFO(LOG_TAG, "%s", __PRETTY_FUNCTION__); 1092 if (!enabled_) return; 1093 1094 btif_queue_cleanup(UUID_SERVCLASS_AUDIO_SINK); 1095 1096 do_in_bta_thread( 1097 FROM_HERE, 1098 base::Bind(base::IgnoreResult(&BtifAvSink::SetActivePeer), 1099 base::Unretained(&btif_av_sink), RawAddress::kEmpty)); 1100 do_in_bta_thread(FROM_HERE, base::Bind(&btif_a2dp_sink_cleanup)); 1101 1102 btif_disable_service(BTA_A2DP_SINK_SERVICE_ID); 1103 CleanupAllPeers(); 1104 1105 callbacks_ = nullptr; 1106 enabled_ = false; 1107 } 1108 1109 BtifAvPeer* BtifAvSink::FindPeer(const RawAddress& peer_address) { 1110 auto it = peers_.find(peer_address); 1111 if (it != peers_.end()) return it->second; 1112 return nullptr; 1113 } 1114 1115 BtifAvPeer* BtifAvSink::FindPeerByHandle(tBTA_AV_HNDL bta_handle) { 1116 for (auto it : peers_) { 1117 BtifAvPeer* peer = it.second; 1118 if (peer->BtaHandle() == bta_handle) { 1119 return peer; 1120 } 1121 } 1122 return nullptr; 1123 } 1124 1125 BtifAvPeer* BtifAvSink::FindPeerByPeerId(uint8_t peer_id) { 1126 for (auto it : peers_) { 1127 BtifAvPeer* peer = it.second; 1128 if (peer->PeerId() == peer_id) { 1129 return peer; 1130 } 1131 } 1132 return nullptr; 1133 } 1134 1135 BtifAvPeer* BtifAvSink::FindOrCreatePeer(const RawAddress& peer_address, 1136 tBTA_AV_HNDL bta_handle) { 1137 BTIF_TRACE_DEBUG("%s: peer_address=%s bta_handle=0x%x", __PRETTY_FUNCTION__, 1138 peer_address.ToString().c_str(), bta_handle); 1139 1140 BtifAvPeer* peer = FindPeer(peer_address); 1141 if (peer != nullptr) return peer; 1142 1143 // Find next availabie Peer ID to use 1144 uint8_t peer_id; 1145 for (peer_id = kPeerIdMin; peer_id < kPeerIdMax; peer_id++) { 1146 if (FindPeerByPeerId(peer_id) == nullptr) break; 1147 } 1148 if (peer_id == kPeerIdMax) { 1149 BTIF_TRACE_ERROR( 1150 "%s: Cannot create peer for peer_address=%s : " 1151 "cannot allocate unique Peer ID", 1152 __PRETTY_FUNCTION__, peer_address.ToString().c_str()); 1153 return nullptr; 1154 } 1155 1156 // Get the BTA Handle (if known) 1157 if (bta_handle == kBtaHandleUnknown) { 1158 auto it = peer_id2bta_handle_.find(peer_id); 1159 if (it != peer_id2bta_handle_.end()) { 1160 bta_handle = it->second; 1161 } 1162 } 1163 1164 LOG_INFO(LOG_TAG, 1165 "%s: Create peer: peer_address=%s bta_handle=0x%x peer_id=%d", 1166 __PRETTY_FUNCTION__, peer_address.ToString().c_str(), bta_handle, 1167 peer_id); 1168 peer = new BtifAvPeer(peer_address, AVDT_TSEP_SRC, bta_handle, peer_id); 1169 peers_.insert(std::make_pair(peer_address, peer)); 1170 peer->Init(); 1171 return peer; 1172 } 1173 1174 bool BtifAvSink::AllowedToConnect(const RawAddress& peer_address) const { 1175 int connected = 0; 1176 1177 // Count peers that are in the process of connecting or already connected 1178 for (auto it : peers_) { 1179 const BtifAvPeer* peer = it.second; 1180 switch (peer->StateMachine().StateId()) { 1181 case BtifAvStateMachine::kStateOpening: 1182 case BtifAvStateMachine::kStateOpened: 1183 case BtifAvStateMachine::kStateStarted: 1184 if (peer->PeerAddress() == peer_address) { 1185 return true; // Already connected or accounted for 1186 } 1187 connected++; 1188 break; 1189 default: 1190 break; 1191 } 1192 } 1193 return (connected < max_connected_peers_); 1194 } 1195 1196 bool BtifAvSink::DeletePeer(const RawAddress& peer_address) { 1197 auto it = peers_.find(peer_address); 1198 if (it == peers_.end()) return false; 1199 BtifAvPeer* peer = it->second; 1200 peer->Cleanup(); 1201 peers_.erase(it); 1202 delete peer; 1203 return true; 1204 } 1205 1206 void BtifAvSink::DeleteIdlePeers() { 1207 for (auto it = peers_.begin(); it != peers_.end();) { 1208 BtifAvPeer* peer = it->second; 1209 auto prev_it = it++; 1210 if (!peer->CanBeDeleted()) continue; 1211 LOG_INFO(LOG_TAG, "%s: Deleting idle peer: %s bta_handle=0x%x", __func__, 1212 peer->PeerAddress().ToString().c_str(), peer->BtaHandle()); 1213 peer->Cleanup(); 1214 peers_.erase(prev_it); 1215 delete peer; 1216 } 1217 } 1218 1219 void BtifAvSink::CleanupAllPeers() { 1220 while (!peers_.empty()) { 1221 auto it = peers_.begin(); 1222 BtifAvPeer* peer = it->second; 1223 peer->Cleanup(); 1224 peers_.erase(it); 1225 delete peer; 1226 } 1227 } 1228 1229 void BtifAvSink::RegisterAllBtaHandles() { 1230 for (int peer_id = kPeerIdMin; peer_id < kPeerIdMax; peer_id++) { 1231 BTA_AvRegister(BTA_AV_CHNL_AUDIO, kBtifAvSinkServiceName.c_str(), peer_id, 1232 bta_av_sink_media_callback, UUID_SERVCLASS_AUDIO_SINK); 1233 } 1234 } 1235 1236 void BtifAvSink::DeregisterAllBtaHandles() { 1237 for (auto it : peer_id2bta_handle_) { 1238 tBTA_AV_HNDL bta_handle = it.second; 1239 BTA_AvDeregister(bta_handle); 1240 } 1241 peer_id2bta_handle_.clear(); 1242 } 1243 1244 void BtifAvSink::BtaHandleRegistered(uint8_t peer_id, tBTA_AV_HNDL bta_handle) { 1245 peer_id2bta_handle_.insert(std::make_pair(peer_id, bta_handle)); 1246 1247 // Set the BTA Handle for the Peer (if exists) 1248 BtifAvPeer* peer = FindPeerByPeerId(peer_id); 1249 if (peer != nullptr) { 1250 peer->SetBtaHandle(bta_handle); 1251 } 1252 } 1253 1254 void BtifAvStateMachine::StateIdle::OnEnter() { 1255 BTIF_TRACE_DEBUG("%s: Peer %s", __PRETTY_FUNCTION__, 1256 peer_.PeerAddress().ToString().c_str()); 1257 1258 peer_.SetEdr(0); 1259 peer_.ClearAllFlags(); 1260 1261 // Stop A2DP if this is the active peer 1262 if (peer_.IsActivePeer() || peer_.ActivePeerAddress().IsEmpty()) { 1263 btif_a2dp_on_idle(); 1264 } 1265 1266 // Reset the active peer if this was the active peer and 1267 // the Idle state was reentered 1268 if (peer_.IsActivePeer() && peer_.CanBeDeleted()) { 1269 if (peer_.IsSink()) { 1270 btif_av_source.SetActivePeer(RawAddress::kEmpty); 1271 } else if (peer_.IsSource()) { 1272 btif_av_sink.SetActivePeer(RawAddress::kEmpty); 1273 } 1274 } 1275 1276 // Delete peers that are re-entering the Idle state 1277 if (peer_.IsSink()) { 1278 do_in_bta_thread(FROM_HERE, base::Bind(&BtifAvSource::DeleteIdlePeers, 1279 base::Unretained(&btif_av_source))); 1280 } else if (peer_.IsSource()) { 1281 do_in_bta_thread(FROM_HERE, base::Bind(&BtifAvSink::DeleteIdlePeers, 1282 base::Unretained(&btif_av_sink))); 1283 } 1284 } 1285 1286 void BtifAvStateMachine::StateIdle::OnExit() { 1287 BTIF_TRACE_DEBUG("%s: Peer %s", __PRETTY_FUNCTION__, 1288 peer_.PeerAddress().ToString().c_str()); 1289 } 1290 1291 bool BtifAvStateMachine::StateIdle::ProcessEvent(uint32_t event, void* p_data) { 1292 BTIF_TRACE_DEBUG("%s: Peer %s : event=%s flags=%s active_peer=%s", 1293 __PRETTY_FUNCTION__, peer_.PeerAddress().ToString().c_str(), 1294 BtifAvEvent::EventName(event).c_str(), 1295 peer_.FlagsToString().c_str(), 1296 logbool(peer_.IsActivePeer()).c_str()); 1297 1298 switch (event) { 1299 case BTA_AV_ENABLE_EVT: 1300 break; 1301 1302 case BTIF_AV_STOP_STREAM_REQ_EVT: 1303 case BTIF_AV_SUSPEND_STREAM_REQ_EVT: 1304 case BTIF_AV_ACL_DISCONNECTED: 1305 // Ignore. Just re-enter Idle so the peer can be deleted 1306 peer_.StateMachine().TransitionTo(BtifAvStateMachine::kStateIdle); 1307 break; 1308 1309 case BTIF_AV_DISCONNECT_REQ_EVT: 1310 if (peer_.BtaHandle() != kBtaHandleUnknown) { 1311 BTA_AvClose(peer_.BtaHandle()); 1312 if (peer_.IsSource()) { 1313 BTA_AvCloseRc(peer_.BtaHandle()); 1314 } 1315 } 1316 // Re-enter Idle so the peer can be deleted 1317 peer_.StateMachine().TransitionTo(BtifAvStateMachine::kStateIdle); 1318 break; 1319 1320 case BTIF_AV_CONNECT_REQ_EVT: 1321 case BTA_AV_PENDING_EVT: { 1322 bool can_connect = true; 1323 peer_.SetSelfInitiatedConnection(event == BTIF_AV_CONNECT_REQ_EVT); 1324 // Check whether connection is allowed 1325 if (peer_.IsSink()) { 1326 can_connect = btif_av_source.AllowedToConnect(peer_.PeerAddress()); 1327 if (!can_connect) src_disconnect_sink(peer_.PeerAddress()); 1328 } else if (peer_.IsSource()) { 1329 can_connect = btif_av_sink.AllowedToConnect(peer_.PeerAddress()); 1330 if (!can_connect) sink_disconnect_src(peer_.PeerAddress()); 1331 } 1332 if (!can_connect) { 1333 BTIF_TRACE_ERROR( 1334 "%s: Cannot connect to peer %s: too many connected " 1335 "peers", 1336 __PRETTY_FUNCTION__, peer_.PeerAddress().ToString().c_str()); 1337 if (peer_.SelfInitiatedConnection()) { 1338 btif_queue_advance(); 1339 } 1340 break; 1341 } 1342 BTA_AvOpen(peer_.PeerAddress(), peer_.BtaHandle(), true, 1343 BTA_SEC_AUTHENTICATE, peer_.LocalUuidServiceClass()); 1344 peer_.StateMachine().TransitionTo(BtifAvStateMachine::kStateOpening); 1345 } break; 1346 case BTIF_AV_AVRCP_OPEN_EVT: 1347 case BTA_AV_RC_OPEN_EVT: { 1348 // IOP_FIX: Jabra 620 only does AVRCP Open without AV Open whenever it 1349 // connects. So as per the AV WP, an AVRCP connection cannot exist 1350 // without an AV connection. Therefore, we initiate an AV connection 1351 // if an RC_OPEN_EVT is received when we are in AV_CLOSED state. 1352 // We initiate the AV connection after a small 3s timeout to avoid any 1353 // collisions from the headsets, as some headsets initiate the AVRCP 1354 // connection first and then immediately initiate the AV connection 1355 // 1356 // TODO: We may need to do this only on an AVRCP Play. FixMe 1357 BTIF_TRACE_WARNING("%s: Peer %s : event=%s received without AV", 1358 __PRETTY_FUNCTION__, 1359 peer_.PeerAddress().ToString().c_str(), 1360 BtifAvEvent::EventName(event).c_str()); 1361 1362 bool can_connect = true; 1363 // Check whether connection is allowed 1364 if (peer_.IsSink()) { 1365 can_connect = btif_av_source.AllowedToConnect(peer_.PeerAddress()); 1366 if (!can_connect) src_disconnect_sink(peer_.PeerAddress()); 1367 } else if (peer_.IsSource()) { 1368 can_connect = btif_av_sink.AllowedToConnect(peer_.PeerAddress()); 1369 if (!can_connect) sink_disconnect_src(peer_.PeerAddress()); 1370 } 1371 if (!can_connect) { 1372 BTIF_TRACE_ERROR( 1373 "%s: Cannot connect to peer %s: too many connected " 1374 "peers", 1375 __PRETTY_FUNCTION__, peer_.PeerAddress().ToString().c_str()); 1376 break; 1377 } 1378 if (btif_av_source.Enabled()) { 1379 alarm_set_on_mloop( 1380 peer_.AvOpenOnRcTimer(), BtifAvPeer::kTimeoutAvOpenOnRcMs, 1381 btif_av_source_initiate_av_open_timer_timeout, &peer_); 1382 } else if (btif_av_sink.Enabled()) { 1383 alarm_set_on_mloop(peer_.AvOpenOnRcTimer(), 1384 BtifAvPeer::kTimeoutAvOpenOnRcMs, 1385 btif_av_sink_initiate_av_open_timer_timeout, &peer_); 1386 } 1387 if (event == BTA_AV_RC_OPEN_EVT) { 1388 btif_rc_handler(event, (tBTA_AV*)p_data); 1389 } 1390 } break; 1391 1392 case BTA_AV_RC_BROWSE_OPEN_EVT: 1393 btif_rc_handler(event, (tBTA_AV*)p_data); 1394 break; 1395 1396 // In case Signalling channel is not down and remote started Streaming 1397 // Procedure, we have to handle Config and Open event in Idle state. 1398 // We hit these scenarios while running PTS test case for AVRCP Controller. 1399 case BTIF_AV_SINK_CONFIG_REQ_EVT: { 1400 const btif_av_sink_config_req_t* p_config_req = 1401 static_cast<const btif_av_sink_config_req_t*>(p_data); 1402 btif_av_report_sink_audio_config_state(p_config_req->peer_address, 1403 p_config_req->sample_rate, 1404 p_config_req->channel_count); 1405 } break; 1406 1407 case BTA_AV_OPEN_EVT: { 1408 tBTA_AV* p_bta_data = (tBTA_AV*)p_data; 1409 btav_connection_state_t state; 1410 int av_state; 1411 tBTA_AV_STATUS status = p_bta_data->open.status; 1412 bool can_connect = true; 1413 1414 LOG_INFO( 1415 LOG_TAG, "%s: Peer %s : event=%s flags=%s status=%d(%s) edr=0x%x", 1416 __PRETTY_FUNCTION__, peer_.PeerAddress().ToString().c_str(), 1417 BtifAvEvent::EventName(event).c_str(), peer_.FlagsToString().c_str(), 1418 status, (status == BTA_AV_SUCCESS) ? "SUCCESS" : "FAILED", 1419 p_bta_data->open.edr); 1420 1421 if (p_bta_data->open.status == BTA_AV_SUCCESS) { 1422 state = BTAV_CONNECTION_STATE_CONNECTED; 1423 av_state = BtifAvStateMachine::kStateOpened; 1424 peer_.SetEdr(p_bta_data->open.edr); 1425 CHECK(peer_.PeerSep() == p_bta_data->open.sep); 1426 // Check whether connection is allowed 1427 if (peer_.IsSink()) { 1428 can_connect = btif_av_source.AllowedToConnect(peer_.PeerAddress()); 1429 if (!can_connect) src_disconnect_sink(peer_.PeerAddress()); 1430 } else if (peer_.IsSource()) { 1431 can_connect = btif_av_sink.AllowedToConnect(peer_.PeerAddress()); 1432 if (!can_connect) sink_disconnect_src(peer_.PeerAddress()); 1433 } 1434 } else { 1435 state = BTAV_CONNECTION_STATE_DISCONNECTED; 1436 av_state = BtifAvStateMachine::kStateIdle; 1437 } 1438 1439 if (!can_connect) { 1440 BTIF_TRACE_ERROR( 1441 "%s: Cannot connect to peer %s: too many connected " 1442 "peers", 1443 __PRETTY_FUNCTION__, peer_.PeerAddress().ToString().c_str()); 1444 } else { 1445 // Report the connection state to the application 1446 btif_report_connection_state(peer_.PeerAddress(), state); 1447 // Change state to Open/Idle based on the status 1448 peer_.StateMachine().TransitionTo(av_state); 1449 if (peer_.IsSink()) { 1450 // If queued PLAY command, send it now 1451 btif_rc_check_handle_pending_play( 1452 p_bta_data->open.bd_addr, 1453 (p_bta_data->open.status == BTA_AV_SUCCESS)); 1454 } else if (peer_.IsSource() && 1455 (p_bta_data->open.status == BTA_AV_SUCCESS)) { 1456 // Bring up AVRCP connection as well 1457 BTA_AvOpenRc(peer_.BtaHandle()); 1458 } 1459 } 1460 btif_queue_advance(); 1461 } break; 1462 1463 case BTA_AV_REMOTE_CMD_EVT: 1464 case BTA_AV_VENDOR_CMD_EVT: 1465 case BTA_AV_META_MSG_EVT: 1466 case BTA_AV_RC_FEAT_EVT: 1467 case BTA_AV_REMOTE_RSP_EVT: 1468 btif_rc_handler(event, (tBTA_AV*)p_data); 1469 break; 1470 1471 case BTIF_AV_AVRCP_CLOSE_EVT: 1472 case BTA_AV_RC_CLOSE_EVT: { 1473 BTIF_TRACE_DEBUG("%s: Peer %s : event=%s : Stopping AV timer", 1474 __PRETTY_FUNCTION__, 1475 peer_.PeerAddress().ToString().c_str(), 1476 BtifAvEvent::EventName(event).c_str()); 1477 alarm_cancel(peer_.AvOpenOnRcTimer()); 1478 1479 if (event == BTA_AV_RC_CLOSE_EVT) { 1480 btif_rc_handler(event, (tBTA_AV*)p_data); 1481 } 1482 } break; 1483 1484 case BTIF_AV_OFFLOAD_START_REQ_EVT: 1485 BTIF_TRACE_ERROR("%s: Peer %s : event=%s: stream is not Opened", 1486 __PRETTY_FUNCTION__, 1487 peer_.PeerAddress().ToString().c_str(), 1488 BtifAvEvent::EventName(event).c_str()); 1489 btif_a2dp_on_offload_started(peer_.PeerAddress(), BTA_AV_FAIL); 1490 break; 1491 1492 default: 1493 BTIF_TRACE_WARNING("%s: Peer %s : Unhandled event=%s", 1494 __PRETTY_FUNCTION__, 1495 peer_.PeerAddress().ToString().c_str(), 1496 BtifAvEvent::EventName(event).c_str()); 1497 return false; 1498 } 1499 1500 return true; 1501 } 1502 1503 void BtifAvStateMachine::StateOpening::OnEnter() { 1504 BTIF_TRACE_DEBUG("%s: Peer %s", __PRETTY_FUNCTION__, 1505 peer_.PeerAddress().ToString().c_str()); 1506 1507 // Inform the application that we are entering connecting state 1508 btif_report_connection_state(peer_.PeerAddress(), 1509 BTAV_CONNECTION_STATE_CONNECTING); 1510 } 1511 1512 void BtifAvStateMachine::StateOpening::OnExit() { 1513 BTIF_TRACE_DEBUG("%s: Peer %s", __PRETTY_FUNCTION__, 1514 peer_.PeerAddress().ToString().c_str()); 1515 } 1516 1517 bool BtifAvStateMachine::StateOpening::ProcessEvent(uint32_t event, 1518 void* p_data) { 1519 BTIF_TRACE_DEBUG("%s: Peer %s : event=%s flags=%s active_peer=%s", 1520 __PRETTY_FUNCTION__, peer_.PeerAddress().ToString().c_str(), 1521 BtifAvEvent::EventName(event).c_str(), 1522 peer_.FlagsToString().c_str(), 1523 logbool(peer_.IsActivePeer()).c_str()); 1524 1525 switch (event) { 1526 case BTIF_AV_STOP_STREAM_REQ_EVT: 1527 case BTIF_AV_SUSPEND_STREAM_REQ_EVT: 1528 break; // Ignore 1529 1530 case BTIF_AV_ACL_DISCONNECTED: 1531 // ACL Disconnected needs to be handled only in Opening state, because 1532 // it is in an intermediate state. In other states we can handle 1533 // incoming/outgoing connect/disconnect requests. 1534 BTIF_TRACE_WARNING( 1535 "%s: Peer %s : event=%s: transitioning to Idle due to ACL Disconnect", 1536 __PRETTY_FUNCTION__, peer_.PeerAddress().ToString().c_str(), 1537 BtifAvEvent::EventName(event).c_str()); 1538 btif_report_connection_state(peer_.PeerAddress(), 1539 BTAV_CONNECTION_STATE_DISCONNECTED); 1540 peer_.StateMachine().TransitionTo(BtifAvStateMachine::kStateIdle); 1541 if (peer_.SelfInitiatedConnection()) { 1542 btif_queue_advance(); 1543 } 1544 break; 1545 case BTA_AV_REJECT_EVT: 1546 BTIF_TRACE_WARNING("%s: Peer %s : event=%s flags=%s", __PRETTY_FUNCTION__, 1547 peer_.PeerAddress().ToString().c_str(), 1548 BtifAvEvent::EventName(event).c_str(), 1549 peer_.FlagsToString().c_str()); 1550 btif_report_connection_state(peer_.PeerAddress(), 1551 BTAV_CONNECTION_STATE_DISCONNECTED); 1552 peer_.StateMachine().TransitionTo(BtifAvStateMachine::kStateIdle); 1553 if (peer_.SelfInitiatedConnection()) { 1554 btif_queue_advance(); 1555 } 1556 break; 1557 1558 case BTA_AV_OPEN_EVT: { 1559 tBTA_AV* p_bta_data = (tBTA_AV*)p_data; 1560 btav_connection_state_t state; 1561 int av_state; 1562 tBTA_AV_STATUS status = p_bta_data->open.status; 1563 1564 LOG_INFO( 1565 LOG_TAG, "%s: Peer %s : event=%s flags=%s status=%d(%s) edr=0x%x", 1566 __PRETTY_FUNCTION__, peer_.PeerAddress().ToString().c_str(), 1567 BtifAvEvent::EventName(event).c_str(), peer_.FlagsToString().c_str(), 1568 status, (status == BTA_AV_SUCCESS) ? "SUCCESS" : "FAILED", 1569 p_bta_data->open.edr); 1570 1571 if (p_bta_data->open.status == BTA_AV_SUCCESS) { 1572 state = BTAV_CONNECTION_STATE_CONNECTED; 1573 av_state = BtifAvStateMachine::kStateOpened; 1574 peer_.SetEdr(p_bta_data->open.edr); 1575 CHECK(peer_.PeerSep() == p_bta_data->open.sep); 1576 } else { 1577 if (btif_rc_is_connected_peer(peer_.PeerAddress())) { 1578 // Disconnect the AVRCP connection, in case the A2DP connectiton 1579 // failed for any reason. 1580 BTIF_TRACE_WARNING("%s: Peer %s : Disconnecting AVRCP", 1581 __PRETTY_FUNCTION__, 1582 peer_.PeerAddress().ToString().c_str()); 1583 uint8_t peer_handle = 1584 btif_rc_get_connected_peer_handle(peer_.PeerAddress()); 1585 if (peer_handle != BTRC_HANDLE_NONE) { 1586 BTA_AvCloseRc(peer_handle); 1587 } 1588 } 1589 state = BTAV_CONNECTION_STATE_DISCONNECTED; 1590 av_state = BtifAvStateMachine::kStateIdle; 1591 } 1592 1593 // Report the connection state to the application 1594 btif_report_connection_state(peer_.PeerAddress(), state); 1595 // Change state to Open/Idle based on the status 1596 peer_.StateMachine().TransitionTo(av_state); 1597 if (peer_.IsSink()) { 1598 // If queued PLAY command, send it now 1599 btif_rc_check_handle_pending_play( 1600 p_bta_data->open.bd_addr, 1601 (p_bta_data->open.status == BTA_AV_SUCCESS)); 1602 } else if (peer_.IsSource() && 1603 (p_bta_data->open.status == BTA_AV_SUCCESS)) { 1604 // Bring up AVRCP connection as well 1605 BTA_AvOpenRc(peer_.BtaHandle()); 1606 } 1607 if (peer_.SelfInitiatedConnection()) { 1608 btif_queue_advance(); 1609 } 1610 } break; 1611 1612 case BTIF_AV_SINK_CONFIG_REQ_EVT: { 1613 const btif_av_sink_config_req_t* p_config_req = 1614 static_cast<const btif_av_sink_config_req_t*>(p_data); 1615 if (peer_.IsSource()) { 1616 btif_av_report_sink_audio_config_state(p_config_req->peer_address, 1617 p_config_req->sample_rate, 1618 p_config_req->channel_count); 1619 } 1620 } break; 1621 1622 case BTIF_AV_CONNECT_REQ_EVT: { 1623 // The device has moved already to Opening, hence don't report the 1624 // connection state. 1625 BTIF_TRACE_WARNING( 1626 "%s: Peer %s : event=%s : device is already connecting, " 1627 "ignore Connect request", 1628 __PRETTY_FUNCTION__, peer_.PeerAddress().ToString().c_str(), 1629 BtifAvEvent::EventName(event).c_str()); 1630 btif_queue_advance(); 1631 } break; 1632 1633 case BTA_AV_PENDING_EVT: { 1634 // The device has moved already to Opening, hence don't report the 1635 // connection state. 1636 BTIF_TRACE_WARNING( 1637 "%s: Peer %s : event=%s : device is already connecting, " 1638 "ignore incoming request", 1639 __PRETTY_FUNCTION__, peer_.PeerAddress().ToString().c_str(), 1640 BtifAvEvent::EventName(event).c_str()); 1641 } break; 1642 1643 case BTIF_AV_OFFLOAD_START_REQ_EVT: 1644 BTIF_TRACE_ERROR("%s: Peer %s : event=%s: stream is not Opened", 1645 __PRETTY_FUNCTION__, 1646 peer_.PeerAddress().ToString().c_str(), 1647 BtifAvEvent::EventName(event).c_str()); 1648 btif_a2dp_on_offload_started(peer_.PeerAddress(), BTA_AV_FAIL); 1649 break; 1650 1651 case BTA_AV_CLOSE_EVT: 1652 btif_a2dp_on_stopped(nullptr); 1653 btif_report_connection_state(peer_.PeerAddress(), 1654 BTAV_CONNECTION_STATE_DISCONNECTED); 1655 peer_.StateMachine().TransitionTo(BtifAvStateMachine::kStateIdle); 1656 if (peer_.SelfInitiatedConnection()) { 1657 btif_queue_advance(); 1658 } 1659 break; 1660 1661 case BTIF_AV_DISCONNECT_REQ_EVT: 1662 BTA_AvClose(peer_.BtaHandle()); 1663 btif_report_connection_state(peer_.PeerAddress(), 1664 BTAV_CONNECTION_STATE_DISCONNECTED); 1665 peer_.StateMachine().TransitionTo(BtifAvStateMachine::kStateIdle); 1666 if (peer_.SelfInitiatedConnection()) { 1667 btif_queue_advance(); 1668 } 1669 break; 1670 1671 CHECK_RC_EVENT(event, (tBTA_AV*)p_data); 1672 1673 default: 1674 BTIF_TRACE_WARNING("%s: Peer %s : Unhandled event=%s", 1675 __PRETTY_FUNCTION__, 1676 peer_.PeerAddress().ToString().c_str(), 1677 BtifAvEvent::EventName(event).c_str()); 1678 return false; 1679 } 1680 return true; 1681 } 1682 1683 void BtifAvStateMachine::StateOpened::OnEnter() { 1684 BTIF_TRACE_DEBUG("%s: Peer %s", __PRETTY_FUNCTION__, 1685 peer_.PeerAddress().ToString().c_str()); 1686 1687 peer_.ClearFlags(BtifAvPeer::kFlagPendingStart | 1688 BtifAvPeer::kFlagPendingStop); 1689 1690 // Set the active peer if the first connected device. 1691 // NOTE: This should be done only if we are A2DP Sink, because the A2DP Sink 1692 // implementation in Java doesn't support active devices (yet). 1693 // For A2DP Source, the setting of the Active device is done by the 1694 // ActiveDeviceManager in Java. 1695 if (peer_.IsSource() && btif_av_sink.ActivePeer().IsEmpty()) { 1696 if (!btif_av_sink.SetActivePeer(peer_.PeerAddress())) { 1697 BTIF_TRACE_ERROR("%s: Error setting %s as active Source peer", __func__, 1698 peer_.PeerAddress().ToString().c_str()); 1699 } 1700 } 1701 } 1702 1703 void BtifAvStateMachine::StateOpened::OnExit() { 1704 BTIF_TRACE_DEBUG("%s: Peer %s", __PRETTY_FUNCTION__, 1705 peer_.PeerAddress().ToString().c_str()); 1706 1707 peer_.ClearFlags(BtifAvPeer::kFlagPendingStart); 1708 } 1709 1710 bool BtifAvStateMachine::StateOpened::ProcessEvent(uint32_t event, 1711 void* p_data) { 1712 tBTA_AV* p_av = (tBTA_AV*)p_data; 1713 1714 BTIF_TRACE_DEBUG("%s: Peer %s : event=%s flags=%s active_peer=%s", 1715 __PRETTY_FUNCTION__, peer_.PeerAddress().ToString().c_str(), 1716 BtifAvEvent::EventName(event).c_str(), 1717 peer_.FlagsToString().c_str(), 1718 logbool(peer_.IsActivePeer()).c_str()); 1719 1720 if ((event == BTA_AV_REMOTE_CMD_EVT) && 1721 peer_.CheckFlags(BtifAvPeer::kFlagRemoteSuspend) && 1722 (p_av->remote_cmd.rc_id == AVRC_ID_PLAY)) { 1723 BTIF_TRACE_EVENT("%s: Peer %s : Resetting remote suspend flag on RC PLAY", 1724 __PRETTY_FUNCTION__, 1725 peer_.PeerAddress().ToString().c_str()); 1726 peer_.ClearFlags(BtifAvPeer::kFlagRemoteSuspend); 1727 } 1728 1729 switch (event) { 1730 case BTIF_AV_STOP_STREAM_REQ_EVT: 1731 case BTIF_AV_SUSPEND_STREAM_REQ_EVT: 1732 case BTIF_AV_ACL_DISCONNECTED: 1733 break; // Ignore 1734 1735 case BTIF_AV_START_STREAM_REQ_EVT: 1736 LOG_INFO(LOG_TAG, "%s: Peer %s : event=%s flags=%s", __PRETTY_FUNCTION__, 1737 peer_.PeerAddress().ToString().c_str(), 1738 BtifAvEvent::EventName(event).c_str(), 1739 peer_.FlagsToString().c_str()); 1740 BTA_AvStart(peer_.BtaHandle()); 1741 peer_.SetFlags(BtifAvPeer::kFlagPendingStart); 1742 break; 1743 1744 case BTA_AV_START_EVT: { 1745 LOG_INFO(LOG_TAG, 1746 "%s: Peer %s : event=%s status=%d suspending=%d " 1747 "initiator=%d flags=%s", 1748 __PRETTY_FUNCTION__, peer_.PeerAddress().ToString().c_str(), 1749 BtifAvEvent::EventName(event).c_str(), p_av->start.status, 1750 p_av->start.suspending, p_av->start.initiator, 1751 peer_.FlagsToString().c_str()); 1752 1753 if ((p_av->start.status == BTA_SUCCESS) && p_av->start.suspending) 1754 return true; 1755 1756 // If remote tries to start A2DP when DUT is A2DP Source, then Suspend. 1757 // If A2DP is Sink and call is active, then disconnect the AVDTP channel. 1758 if (peer_.IsSink() && !peer_.CheckFlags(BtifAvPeer::kFlagPendingStart)) { 1759 BTIF_TRACE_WARNING("%s: Peer %s : trigger Suspend as remote initiated", 1760 __PRETTY_FUNCTION__, 1761 peer_.PeerAddress().ToString().c_str()); 1762 btif_av_source_dispatch_sm_event(peer_.PeerAddress(), 1763 BTIF_AV_SUSPEND_STREAM_REQ_EVT); 1764 } 1765 1766 // If peer is A2DP Source, we do not want to ACK commands on UIPC 1767 if (peer_.IsSink() && 1768 btif_a2dp_on_started( 1769 peer_.PeerAddress(), &p_av->start, 1770 peer_.CheckFlags(BtifAvPeer::kFlagPendingStart))) { 1771 // Only clear pending flag after acknowledgement 1772 peer_.ClearFlags(BtifAvPeer::kFlagPendingStart); 1773 } 1774 1775 // Remain in Open state if status failed 1776 if (p_av->start.status != BTA_AV_SUCCESS) return false; 1777 1778 if (peer_.IsSource() && peer_.IsActivePeer()) { 1779 // Remove flush state, ready for streaming 1780 btif_a2dp_sink_set_rx_flush(false); 1781 } 1782 1783 // Change state to Started, send acknowledgement if start is pending 1784 if (peer_.IsSink() && peer_.CheckFlags(BtifAvPeer::kFlagPendingStart)) { 1785 btif_a2dp_on_started(peer_.PeerAddress(), nullptr, true); 1786 // Pending start flag will be cleared when exit current state 1787 } 1788 peer_.StateMachine().TransitionTo(BtifAvStateMachine::kStateStarted); 1789 1790 } break; 1791 1792 case BTIF_AV_DISCONNECT_REQ_EVT: 1793 BTA_AvClose(peer_.BtaHandle()); 1794 if (peer_.IsSource()) { 1795 BTA_AvCloseRc(peer_.BtaHandle()); 1796 } 1797 1798 // Inform the application that we are disconnecting 1799 btif_report_connection_state(peer_.PeerAddress(), 1800 BTAV_CONNECTION_STATE_DISCONNECTING); 1801 1802 // Wait in closing state until fully closed 1803 peer_.StateMachine().TransitionTo(BtifAvStateMachine::kStateClosing); 1804 break; 1805 1806 case BTA_AV_CLOSE_EVT: 1807 // AVDTP link is closed 1808 if (peer_.IsActivePeer()) { 1809 btif_a2dp_on_stopped(nullptr); 1810 } 1811 1812 // Change state to Idle, send acknowledgement if start is pending 1813 if (peer_.CheckFlags(BtifAvPeer::kFlagPendingStart)) { 1814 BTIF_TRACE_WARNING("%s: Peer %s : failed pending start request", 1815 __PRETTY_FUNCTION__, 1816 peer_.PeerAddress().ToString().c_str()); 1817 btif_a2dp_command_ack(A2DP_CTRL_ACK_FAILURE); 1818 // Pending start flag will be cleared when exit current state 1819 } 1820 1821 // Inform the application that we are disconnected 1822 btif_report_connection_state(peer_.PeerAddress(), 1823 BTAV_CONNECTION_STATE_DISCONNECTED); 1824 peer_.StateMachine().TransitionTo(BtifAvStateMachine::kStateIdle); 1825 break; 1826 1827 case BTA_AV_RECONFIG_EVT: 1828 if (peer_.CheckFlags(BtifAvPeer::kFlagPendingStart) && 1829 (p_av->reconfig.status == BTA_AV_SUCCESS)) { 1830 LOG_INFO(LOG_TAG, 1831 "%s : Peer %s : Reconfig done - calling BTA_AvStart()", 1832 __PRETTY_FUNCTION__, peer_.PeerAddress().ToString().c_str()); 1833 BTA_AvStart(peer_.BtaHandle()); 1834 } else if (peer_.CheckFlags(BtifAvPeer::kFlagPendingStart)) { 1835 BTIF_TRACE_WARNING("%s: Peer %s : failed reconfiguration", 1836 __PRETTY_FUNCTION__, 1837 peer_.PeerAddress().ToString().c_str()); 1838 peer_.ClearFlags(BtifAvPeer::kFlagPendingStart); 1839 btif_a2dp_command_ack(A2DP_CTRL_ACK_FAILURE); 1840 } 1841 break; 1842 1843 case BTIF_AV_CONNECT_REQ_EVT: { 1844 BTIF_TRACE_WARNING("%s: Peer %s : Ignore %s for same device", 1845 __PRETTY_FUNCTION__, 1846 peer_.PeerAddress().ToString().c_str(), 1847 BtifAvEvent::EventName(event).c_str()); 1848 btif_queue_advance(); 1849 } break; 1850 1851 case BTIF_AV_OFFLOAD_START_REQ_EVT: 1852 BTIF_TRACE_ERROR("%s: Peer %s : event=%s: stream is not Opened", 1853 __PRETTY_FUNCTION__, 1854 peer_.PeerAddress().ToString().c_str(), 1855 BtifAvEvent::EventName(event).c_str()); 1856 btif_a2dp_on_offload_started(peer_.PeerAddress(), BTA_AV_FAIL); 1857 break; 1858 1859 case BTIF_AV_AVRCP_REMOTE_PLAY_EVT: 1860 if (peer_.CheckFlags(BtifAvPeer::kFlagRemoteSuspend)) { 1861 BTIF_TRACE_EVENT( 1862 "%s: Peer %s : Resetting remote suspend flag on RC PLAY", 1863 __PRETTY_FUNCTION__, peer_.PeerAddress().ToString().c_str()); 1864 peer_.ClearFlags(BtifAvPeer::kFlagRemoteSuspend); 1865 } 1866 break; 1867 1868 CHECK_RC_EVENT(event, (tBTA_AV*)p_data); 1869 1870 default: 1871 BTIF_TRACE_WARNING("%s: Peer %s : Unhandled event=%s", 1872 __PRETTY_FUNCTION__, 1873 peer_.PeerAddress().ToString().c_str(), 1874 BtifAvEvent::EventName(event).c_str()); 1875 return false; 1876 } 1877 return true; 1878 } 1879 1880 void BtifAvStateMachine::StateStarted::OnEnter() { 1881 BTIF_TRACE_DEBUG("%s: Peer %s", __PRETTY_FUNCTION__, 1882 peer_.PeerAddress().ToString().c_str()); 1883 1884 // We are again in started state, clear any remote suspend flags 1885 peer_.ClearFlags(BtifAvPeer::kFlagRemoteSuspend); 1886 1887 // Report that we have entered the Streaming stage. Usually, this should 1888 // be followed by focus grant. See update_audio_focus_state() 1889 btif_report_audio_state(peer_.PeerAddress(), BTAV_AUDIO_STATE_STARTED); 1890 } 1891 1892 void BtifAvStateMachine::StateStarted::OnExit() { 1893 BTIF_TRACE_DEBUG("%s: Peer %s", __PRETTY_FUNCTION__, 1894 peer_.PeerAddress().ToString().c_str()); 1895 } 1896 1897 bool BtifAvStateMachine::StateStarted::ProcessEvent(uint32_t event, 1898 void* p_data) { 1899 tBTA_AV* p_av = (tBTA_AV*)p_data; 1900 1901 BTIF_TRACE_DEBUG("%s: Peer %s : event=%s flags=%s active_peer=%s", 1902 __PRETTY_FUNCTION__, peer_.PeerAddress().ToString().c_str(), 1903 BtifAvEvent::EventName(event).c_str(), 1904 peer_.FlagsToString().c_str(), 1905 logbool(peer_.IsActivePeer()).c_str()); 1906 1907 switch (event) { 1908 case BTIF_AV_ACL_DISCONNECTED: 1909 break; // Ignore 1910 1911 case BTIF_AV_START_STREAM_REQ_EVT: 1912 LOG_INFO(LOG_TAG, "%s: Peer %s : event=%s flags=%s", __PRETTY_FUNCTION__, 1913 peer_.PeerAddress().ToString().c_str(), 1914 BtifAvEvent::EventName(event).c_str(), 1915 peer_.FlagsToString().c_str()); 1916 // We were started remotely, just ACK back the local request 1917 if (peer_.IsSink()) 1918 btif_a2dp_on_started(peer_.PeerAddress(), nullptr, true); 1919 break; 1920 1921 // FIXME -- use suspend = true always to work around issue with BTA AV 1922 case BTIF_AV_STOP_STREAM_REQ_EVT: 1923 case BTIF_AV_SUSPEND_STREAM_REQ_EVT: 1924 LOG_INFO(LOG_TAG, "%s: Peer %s : event=%s flags=%s", __PRETTY_FUNCTION__, 1925 peer_.PeerAddress().ToString().c_str(), 1926 BtifAvEvent::EventName(event).c_str(), 1927 peer_.FlagsToString().c_str()); 1928 // Set pending flag to ensure the BTIF task is not trying to restart 1929 // the stream while suspend is in progress. 1930 peer_.SetFlags(BtifAvPeer::kFlagLocalSuspendPending); 1931 1932 // If we were remotely suspended but suspend locally, local suspend 1933 // always overrides. 1934 peer_.ClearFlags(BtifAvPeer::kFlagRemoteSuspend); 1935 1936 if (peer_.IsSink()) { 1937 // Immediately stop transmission of frames while suspend is pending 1938 if (peer_.IsActivePeer()) { 1939 if (event == BTIF_AV_STOP_STREAM_REQ_EVT) { 1940 btif_a2dp_on_stopped(nullptr); 1941 } else { 1942 // (event == BTIF_AV_SUSPEND_STREAM_REQ_EVT) 1943 btif_a2dp_source_set_tx_flush(true); 1944 } 1945 } 1946 } else if (peer_.IsSource()) { 1947 btif_a2dp_on_stopped(nullptr); 1948 } 1949 BTA_AvStop(peer_.BtaHandle(), true); 1950 break; 1951 1952 case BTIF_AV_DISCONNECT_REQ_EVT: 1953 LOG_INFO(LOG_TAG, "%s: Peer %s : event=%s flags=%s", __PRETTY_FUNCTION__, 1954 peer_.PeerAddress().ToString().c_str(), 1955 BtifAvEvent::EventName(event).c_str(), 1956 peer_.FlagsToString().c_str()); 1957 1958 // Request AVDTP to close 1959 BTA_AvClose(peer_.BtaHandle()); 1960 if (peer_.IsSource()) { 1961 BTA_AvCloseRc(peer_.BtaHandle()); 1962 } 1963 1964 // Inform the application that we are disconnecting 1965 btif_report_connection_state(peer_.PeerAddress(), 1966 BTAV_CONNECTION_STATE_DISCONNECTING); 1967 1968 // Wait in closing state until fully closed 1969 peer_.StateMachine().TransitionTo(BtifAvStateMachine::kStateClosing); 1970 break; 1971 1972 case BTA_AV_SUSPEND_EVT: { 1973 LOG_INFO(LOG_TAG, 1974 "%s: Peer %s : event=%s status=%d initiator=%d flags=%s", 1975 __PRETTY_FUNCTION__, peer_.PeerAddress().ToString().c_str(), 1976 BtifAvEvent::EventName(event).c_str(), p_av->suspend.status, 1977 p_av->suspend.initiator, peer_.FlagsToString().c_str()); 1978 1979 // A2DP suspended, stop A2DP encoder/decoder until resumed 1980 btif_a2dp_on_suspended(&p_av->suspend); 1981 1982 // If not successful, remain in current state 1983 if (p_av->suspend.status != BTA_AV_SUCCESS) { 1984 peer_.ClearFlags(BtifAvPeer::kFlagLocalSuspendPending); 1985 1986 if (peer_.IsSink() && peer_.IsActivePeer()) { 1987 // Suspend failed, reset back tx flush state 1988 btif_a2dp_source_set_tx_flush(false); 1989 } 1990 return false; 1991 } 1992 1993 btav_audio_state_t state = BTAV_AUDIO_STATE_REMOTE_SUSPEND; 1994 if (p_av->suspend.initiator != true) { 1995 // Remote suspend, notify HAL and await audioflinger to 1996 // suspend/stop stream. 1997 // 1998 // Set remote suspend flag to block media task from restarting 1999 // stream only if we did not already initiate a local suspend. 2000 if (!peer_.CheckFlags(BtifAvPeer::kFlagLocalSuspendPending)) 2001 peer_.SetFlags(BtifAvPeer::kFlagRemoteSuspend); 2002 } else { 2003 state = BTAV_AUDIO_STATE_STOPPED; 2004 } 2005 2006 // Suspend completed, clear pending status 2007 peer_.ClearFlags(BtifAvPeer::kFlagLocalSuspendPending); 2008 2009 btif_report_audio_state(peer_.PeerAddress(), state); 2010 peer_.StateMachine().TransitionTo(BtifAvStateMachine::kStateOpened); 2011 } break; 2012 2013 case BTA_AV_STOP_EVT: 2014 LOG_INFO(LOG_TAG, "%s: Peer %s : event=%s flags=%s", __PRETTY_FUNCTION__, 2015 peer_.PeerAddress().ToString().c_str(), 2016 BtifAvEvent::EventName(event).c_str(), 2017 peer_.FlagsToString().c_str()); 2018 2019 peer_.SetFlags(BtifAvPeer::kFlagPendingStop); 2020 btif_a2dp_on_stopped(&p_av->suspend); 2021 2022 btif_report_audio_state(peer_.PeerAddress(), BTAV_AUDIO_STATE_STOPPED); 2023 2024 // If stop was successful, change state to Open 2025 if (p_av->suspend.status == BTA_AV_SUCCESS) 2026 peer_.StateMachine().TransitionTo(BtifAvStateMachine::kStateOpened); 2027 2028 break; 2029 2030 case BTA_AV_CLOSE_EVT: 2031 LOG_INFO(LOG_TAG, "%s: Peer %s : event=%s flags=%s", __PRETTY_FUNCTION__, 2032 peer_.PeerAddress().ToString().c_str(), 2033 BtifAvEvent::EventName(event).c_str(), 2034 peer_.FlagsToString().c_str()); 2035 2036 peer_.SetFlags(BtifAvPeer::kFlagPendingStop); 2037 2038 // AVDTP link is closed 2039 if (peer_.IsActivePeer()) { 2040 btif_a2dp_on_stopped(nullptr); 2041 } 2042 2043 // Inform the application that we are disconnected 2044 btif_report_connection_state(peer_.PeerAddress(), 2045 BTAV_CONNECTION_STATE_DISCONNECTED); 2046 2047 peer_.StateMachine().TransitionTo(BtifAvStateMachine::kStateIdle); 2048 break; 2049 2050 case BTIF_AV_OFFLOAD_START_REQ_EVT: 2051 BTA_AvOffloadStart(peer_.BtaHandle()); 2052 break; 2053 2054 case BTA_AV_OFFLOAD_START_RSP_EVT: 2055 btif_a2dp_on_offload_started(peer_.PeerAddress(), p_av->status); 2056 break; 2057 2058 CHECK_RC_EVENT(event, (tBTA_AV*)p_data); 2059 2060 default: 2061 BTIF_TRACE_WARNING("%s: Peer %s : Unhandled event=%s", 2062 __PRETTY_FUNCTION__, 2063 peer_.PeerAddress().ToString().c_str(), 2064 BtifAvEvent::EventName(event).c_str()); 2065 return false; 2066 } 2067 2068 return true; 2069 } 2070 2071 void BtifAvStateMachine::StateClosing::OnEnter() { 2072 BTIF_TRACE_DEBUG("%s: Peer %s", __PRETTY_FUNCTION__, 2073 peer_.PeerAddress().ToString().c_str()); 2074 2075 if (peer_.IsActivePeer()) { 2076 if (peer_.IsSink()) { 2077 // Immediately stop transmission of frames 2078 btif_a2dp_source_set_tx_flush(true); 2079 // Wait for Audio Flinger to stop A2DP 2080 } else if (peer_.IsSource()) { 2081 btif_a2dp_sink_set_rx_flush(true); 2082 } 2083 } 2084 } 2085 2086 void BtifAvStateMachine::StateClosing::OnExit() { 2087 BTIF_TRACE_DEBUG("%s: Peer %s", __PRETTY_FUNCTION__, 2088 peer_.PeerAddress().ToString().c_str()); 2089 } 2090 2091 bool BtifAvStateMachine::StateClosing::ProcessEvent(uint32_t event, 2092 void* p_data) { 2093 BTIF_TRACE_DEBUG("%s: Peer %s : event=%s flags=%s active_peer=%s", 2094 __PRETTY_FUNCTION__, peer_.PeerAddress().ToString().c_str(), 2095 BtifAvEvent::EventName(event).c_str(), 2096 peer_.FlagsToString().c_str(), 2097 logbool(peer_.IsActivePeer()).c_str()); 2098 2099 switch (event) { 2100 case BTIF_AV_SUSPEND_STREAM_REQ_EVT: 2101 case BTIF_AV_ACL_DISCONNECTED: 2102 break; // Ignore 2103 2104 case BTA_AV_STOP_EVT: 2105 case BTIF_AV_STOP_STREAM_REQ_EVT: 2106 if (peer_.IsActivePeer()) { 2107 btif_a2dp_on_stopped(nullptr); 2108 } 2109 break; 2110 2111 case BTA_AV_CLOSE_EVT: 2112 // Inform the application that we are disconnecting 2113 btif_report_connection_state(peer_.PeerAddress(), 2114 BTAV_CONNECTION_STATE_DISCONNECTED); 2115 2116 peer_.StateMachine().TransitionTo(BtifAvStateMachine::kStateIdle); 2117 break; 2118 2119 // Handle the RC_CLOSE event for the cleanup 2120 case BTA_AV_RC_CLOSE_EVT: 2121 btif_rc_handler(event, (tBTA_AV*)p_data); 2122 break; 2123 2124 // Handle the RC_BROWSE_CLOSE event for testing 2125 case BTA_AV_RC_BROWSE_CLOSE_EVT: 2126 btif_rc_handler(event, (tBTA_AV*)p_data); 2127 break; 2128 2129 case BTIF_AV_OFFLOAD_START_REQ_EVT: 2130 BTIF_TRACE_ERROR("%s: Peer %s : event=%s: stream is not Opened", 2131 __PRETTY_FUNCTION__, 2132 peer_.PeerAddress().ToString().c_str(), 2133 BtifAvEvent::EventName(event).c_str()); 2134 btif_a2dp_on_offload_started(peer_.PeerAddress(), BTA_AV_FAIL); 2135 break; 2136 2137 default: 2138 BTIF_TRACE_WARNING("%s: Peer %s : Unhandled event=%s", 2139 __PRETTY_FUNCTION__, 2140 peer_.PeerAddress().ToString().c_str(), 2141 BtifAvEvent::EventName(event).c_str()); 2142 return false; 2143 } 2144 return true; 2145 } 2146 2147 /** 2148 * Timer to trigger AV Open on the Source if the remote Sink device establishes 2149 * AVRCP connection without AV connection. The timer is needed to interoperate 2150 * with headsets that do establish AV after AVRCP connection. 2151 */ 2152 static void btif_av_source_initiate_av_open_timer_timeout(void* data) { 2153 BtifAvPeer* peer = (BtifAvPeer*)data; 2154 2155 BTIF_TRACE_DEBUG("%s: Peer %s", __func__, 2156 peer->PeerAddress().ToString().c_str()); 2157 2158 // Check if AVRCP is connected to the peer 2159 if (!btif_rc_is_connected_peer(peer->PeerAddress())) { 2160 BTIF_TRACE_ERROR("%s: AVRCP peer %s is not connected", __func__, 2161 peer->PeerAddress().ToString().c_str()); 2162 return; 2163 } 2164 2165 // Connect to the AVRCP peer 2166 if (btif_av_source.Enabled() && 2167 btif_av_source.FindPeer(peer->PeerAddress()) == peer) { 2168 BTIF_TRACE_DEBUG("%s: Connecting to AVRCP peer %s", __func__, 2169 peer->PeerAddress().ToString().c_str()); 2170 btif_av_source_dispatch_sm_event(peer->PeerAddress(), 2171 BTIF_AV_CONNECT_REQ_EVT); 2172 } 2173 } 2174 2175 /** 2176 * Timer to trigger AV Open on the Sink if the remote Source device establishes 2177 * AVRCP connection without AV connection. 2178 */ 2179 static void btif_av_sink_initiate_av_open_timer_timeout(void* data) { 2180 BtifAvPeer* peer = (BtifAvPeer*)data; 2181 2182 BTIF_TRACE_DEBUG("%s: Peer %s", __func__, 2183 peer->PeerAddress().ToString().c_str()); 2184 2185 // Check if AVRCP is connected to the peer 2186 if (!btif_rc_is_connected_peer(peer->PeerAddress())) { 2187 BTIF_TRACE_ERROR("%s: AVRCP peer %s is not connected", __func__, 2188 peer->PeerAddress().ToString().c_str()); 2189 return; 2190 } 2191 2192 // Connect to the AVRCP peer 2193 if (btif_av_sink.Enabled() && 2194 btif_av_sink.FindPeer(peer->PeerAddress()) == peer) { 2195 BTIF_TRACE_DEBUG("%s: Connecting to AVRCP peer %s", __func__, 2196 peer->PeerAddress().ToString().c_str()); 2197 btif_av_sink_dispatch_sm_event(peer->PeerAddress(), 2198 BTIF_AV_CONNECT_REQ_EVT); 2199 } 2200 } 2201 2202 /** 2203 * Report the A2DP connection state 2204 * 2205 * @param peer_address the peer address 2206 * @param state the connection state 2207 */ 2208 static void btif_report_connection_state(const RawAddress& peer_address, 2209 btav_connection_state_t state) { 2210 LOG_INFO(LOG_TAG, "%s: peer_address=%s state=%d", __func__, 2211 peer_address.ToString().c_str(), state); 2212 2213 if (btif_av_source.Enabled()) { 2214 do_in_jni_thread(FROM_HERE, 2215 base::Bind(btif_av_source.Callbacks()->connection_state_cb, 2216 peer_address, state)); 2217 } else if (btif_av_sink.Enabled()) { 2218 do_in_jni_thread(FROM_HERE, 2219 base::Bind(btif_av_sink.Callbacks()->connection_state_cb, 2220 peer_address, state)); 2221 } 2222 } 2223 2224 /** 2225 * Report the audio state of the A2DP connection. 2226 * The state is updated when either the remote ends starts streaming 2227 * (Started state) or whenever it transitions out of Started state 2228 * (to Opened or Streaming state). 2229 * 2230 * @param peer_address the peer address 2231 * @param state the audio state 2232 */ 2233 static void btif_report_audio_state(const RawAddress& peer_address, 2234 btav_audio_state_t state) { 2235 LOG_INFO(LOG_TAG, "%s: peer_address=%s state=%d", __func__, 2236 peer_address.ToString().c_str(), state); 2237 2238 if (btif_av_source.Enabled()) { 2239 do_in_jni_thread(FROM_HERE, 2240 base::Bind(btif_av_source.Callbacks()->audio_state_cb, 2241 peer_address, state)); 2242 } else if (btif_av_sink.Enabled()) { 2243 do_in_jni_thread(FROM_HERE, 2244 base::Bind(btif_av_sink.Callbacks()->audio_state_cb, 2245 peer_address, state)); 2246 } 2247 } 2248 2249 void btif_av_report_source_codec_state( 2250 const RawAddress& peer_address, 2251 const btav_a2dp_codec_config_t& codec_config, 2252 const std::vector<btav_a2dp_codec_config_t>& codecs_local_capabilities, 2253 const std::vector<btav_a2dp_codec_config_t>& 2254 codecs_selectable_capabilities) { 2255 BTIF_TRACE_EVENT("%s: peer_address=%s", __func__, 2256 peer_address.ToString().c_str()); 2257 if (btif_av_source.Enabled()) { 2258 do_in_jni_thread( 2259 FROM_HERE, 2260 base::Bind(btif_av_source.Callbacks()->audio_config_cb, peer_address, 2261 codec_config, codecs_local_capabilities, 2262 codecs_selectable_capabilities)); 2263 } 2264 } 2265 2266 /** 2267 * Report the audio config state of the A2DP Sink connection. 2268 * 2269 * @param peer_address the peer address 2270 * @param sample_rate the sample rate (in samples per second) 2271 * @param channel_count the channel count (1 for Mono, 2 for Stereo) 2272 */ 2273 static void btif_av_report_sink_audio_config_state( 2274 const RawAddress& peer_address, int sample_rate, int channel_count) { 2275 LOG_INFO(LOG_TAG, "%s: Peer %s : sample_rate=%d channel_count=%d", __func__, 2276 peer_address.ToString().c_str(), sample_rate, channel_count); 2277 if (btif_av_sink.Enabled()) { 2278 do_in_jni_thread(FROM_HERE, 2279 base::Bind(btif_av_sink.Callbacks()->audio_config_cb, 2280 peer_address, sample_rate, channel_count)); 2281 } 2282 } 2283 2284 /** 2285 * Process BTIF or BTA AV or BTA AVRCP events. The processing is done on the 2286 * JNI thread. 2287 * 2288 * @param peer_sep the corresponding peer's SEP: AVDT_TSEP_SRC if the peer 2289 * is A2DP Source, or AVDT_TSEP_SNK if the peer is A2DP Sink. 2290 * @param peer_address the peer address if known, otherwise RawAddress::kEmpty 2291 * @param bta_handle the BTA handle for the peer if known, otherwise 2292 * kBtaHandleUnknown 2293 * @param btif_av_event the corresponding event 2294 */ 2295 static void btif_av_handle_event(uint8_t peer_sep, 2296 const RawAddress& peer_address, 2297 tBTA_AV_HNDL bta_handle, 2298 const BtifAvEvent& btif_av_event) { 2299 BtifAvPeer* peer = nullptr; 2300 BTIF_TRACE_EVENT("%s: peer_sep=%s (%d) peer_address=%s handle=0x%x event=%s", 2301 __func__, (peer_sep == AVDT_TSEP_SRC) ? "Source" : "Sink", 2302 peer_sep, peer_address.ToString().c_str(), bta_handle, 2303 btif_av_event.ToString().c_str()); 2304 2305 // Find the peer 2306 if (peer_address != RawAddress::kEmpty) { 2307 if (peer_sep == AVDT_TSEP_SNK) { 2308 peer = btif_av_source.FindOrCreatePeer(peer_address, bta_handle); 2309 } else if (peer_sep == AVDT_TSEP_SRC) { 2310 peer = btif_av_sink.FindOrCreatePeer(peer_address, bta_handle); 2311 } 2312 } else if (bta_handle != kBtaHandleUnknown) { 2313 if (peer_sep == AVDT_TSEP_SNK) { 2314 peer = btif_av_source.FindPeerByHandle(bta_handle); 2315 } else if (peer_sep == AVDT_TSEP_SRC) { 2316 peer = btif_av_sink.FindPeerByHandle(bta_handle); 2317 } 2318 } 2319 if (peer == nullptr) { 2320 BTIF_TRACE_ERROR( 2321 "%s: Cannot find or create %s peer for peer_address=%s handle=0x%x : " 2322 "event dropped: %s", 2323 __func__, (peer_sep == AVDT_TSEP_SRC) ? "Source" : "Sink", 2324 peer_address.ToString().c_str(), bta_handle, 2325 btif_av_event.ToString().c_str()); 2326 return; 2327 } 2328 2329 peer->StateMachine().ProcessEvent(btif_av_event.Event(), 2330 btif_av_event.Data()); 2331 } 2332 2333 /** 2334 * Process BTA AV or BTA AVRCP events. The processing is done on the JNI 2335 * thread. 2336 * 2337 * @param peer_sep the corresponding peer's SEP: AVDT_TSEP_SRC if the peer 2338 * is A2DP Source, or AVDT_TSEP_SNK if the peer is A2DP Sink. 2339 * @param btif_av_event the corresponding event 2340 */ 2341 static void btif_av_handle_bta_av_event(uint8_t peer_sep, 2342 const BtifAvEvent& btif_av_event) { 2343 RawAddress peer_address = RawAddress::kEmpty; 2344 tBTA_AV_HNDL bta_handle = kBtaHandleUnknown; 2345 tBTA_AV_EVT event = btif_av_event.Event(); 2346 tBTA_AV* p_data = (tBTA_AV*)btif_av_event.Data(); 2347 2348 BTIF_TRACE_DEBUG("%s: peer_sep=%s (%d) event=%s", __func__, 2349 (peer_sep == AVDT_TSEP_SRC) ? "Source" : "Sink", peer_sep, 2350 btif_av_event.ToString().c_str()); 2351 2352 switch (event) { 2353 case BTA_AV_ENABLE_EVT: { 2354 const tBTA_AV_ENABLE& enable = p_data->enable; 2355 BTIF_TRACE_DEBUG("%s: features=0x%x", __func__, enable.features); 2356 return; // Nothing to do 2357 } 2358 case BTA_AV_REGISTER_EVT: { 2359 const tBTA_AV_REGISTER& registr = p_data->registr; 2360 bta_handle = registr.hndl; 2361 uint8_t peer_id = registr.app_id; // The PeerId is used as AppId 2362 BTIF_TRACE_DEBUG("%s: handle=0x%x app_id=%d", __func__, bta_handle, 2363 registr.app_id); 2364 if (peer_sep == AVDT_TSEP_SNK) { 2365 btif_av_source.BtaHandleRegistered(peer_id, bta_handle); 2366 } else if (peer_sep == AVDT_TSEP_SRC) { 2367 btif_av_sink.BtaHandleRegistered(peer_id, bta_handle); 2368 } 2369 return; // Nothing else to do 2370 } 2371 case BTA_AV_OPEN_EVT: { 2372 const tBTA_AV_OPEN& open = p_data->open; 2373 peer_address = open.bd_addr; 2374 bta_handle = open.hndl; 2375 break; 2376 } 2377 case BTA_AV_CLOSE_EVT: { 2378 const tBTA_AV_CLOSE& close = p_data->close; 2379 bta_handle = close.hndl; 2380 break; 2381 } 2382 case BTA_AV_START_EVT: { 2383 const tBTA_AV_START& start = p_data->start; 2384 bta_handle = start.hndl; 2385 break; 2386 } 2387 case BTA_AV_SUSPEND_EVT: 2388 case BTA_AV_STOP_EVT: { 2389 const tBTA_AV_SUSPEND& suspend = p_data->suspend; 2390 bta_handle = suspend.hndl; 2391 break; 2392 } 2393 case BTA_AV_PROTECT_REQ_EVT: { 2394 const tBTA_AV_PROTECT_REQ& protect_req = p_data->protect_req; 2395 bta_handle = protect_req.hndl; 2396 break; 2397 } 2398 case BTA_AV_PROTECT_RSP_EVT: { 2399 const tBTA_AV_PROTECT_RSP& protect_rsp = p_data->protect_rsp; 2400 bta_handle = protect_rsp.hndl; 2401 break; 2402 } 2403 case BTA_AV_RC_OPEN_EVT: { 2404 const tBTA_AV_RC_OPEN& rc_open = p_data->rc_open; 2405 peer_address = rc_open.peer_addr; 2406 break; 2407 } 2408 case BTA_AV_RC_CLOSE_EVT: { 2409 const tBTA_AV_RC_CLOSE& rc_close = p_data->rc_close; 2410 peer_address = rc_close.peer_addr; 2411 break; 2412 } 2413 case BTA_AV_RC_BROWSE_OPEN_EVT: { 2414 const tBTA_AV_RC_BROWSE_OPEN& rc_browse_open = p_data->rc_browse_open; 2415 peer_address = rc_browse_open.peer_addr; 2416 break; 2417 } 2418 case BTA_AV_RC_BROWSE_CLOSE_EVT: { 2419 const tBTA_AV_RC_BROWSE_CLOSE& rc_browse_close = p_data->rc_browse_close; 2420 peer_address = rc_browse_close.peer_addr; 2421 break; 2422 } 2423 case BTA_AV_REMOTE_CMD_EVT: 2424 case BTA_AV_REMOTE_RSP_EVT: 2425 case BTA_AV_VENDOR_CMD_EVT: 2426 case BTA_AV_VENDOR_RSP_EVT: 2427 case BTA_AV_META_MSG_EVT: 2428 case BTA_AV_OFFLOAD_START_RSP_EVT: { 2429 // TODO: Might be wrong - this code will be removed once those 2430 // events are received from the AVRCP module. 2431 if (peer_sep == AVDT_TSEP_SNK) { 2432 peer_address = btif_av_source.ActivePeer(); 2433 } else if (peer_sep == AVDT_TSEP_SRC) { 2434 peer_address = btif_av_sink.ActivePeer(); 2435 } 2436 break; 2437 } 2438 case BTA_AV_RECONFIG_EVT: { 2439 const tBTA_AV_RECONFIG& reconfig = p_data->reconfig; 2440 bta_handle = reconfig.hndl; 2441 break; 2442 } 2443 case BTA_AV_PENDING_EVT: { 2444 const tBTA_AV_PEND& pend = p_data->pend; 2445 peer_address = pend.bd_addr; 2446 break; 2447 } 2448 case BTA_AV_REJECT_EVT: { 2449 const tBTA_AV_REJECT& reject = p_data->reject; 2450 peer_address = reject.bd_addr; 2451 bta_handle = reject.hndl; 2452 break; 2453 } 2454 case BTA_AV_RC_FEAT_EVT: { 2455 const tBTA_AV_RC_FEAT& rc_feat = p_data->rc_feat; 2456 peer_address = rc_feat.peer_addr; 2457 break; 2458 } 2459 } 2460 BTIF_TRACE_DEBUG("%s: peer_address=%s handle=0x%x", __func__, 2461 peer_address.ToString().c_str(), bta_handle); 2462 2463 btif_av_handle_event(peer_sep, peer_address, bta_handle, btif_av_event); 2464 } 2465 2466 static void bta_av_source_callback(tBTA_AV_EVT event, tBTA_AV* p_data) { 2467 BtifAvEvent btif_av_event(event, p_data, sizeof(tBTA_AV)); 2468 BTIF_TRACE_EVENT("%s: event=%s", __func__, btif_av_event.ToString().c_str()); 2469 2470 do_in_bta_thread(FROM_HERE, 2471 base::Bind(&btif_av_handle_bta_av_event, 2472 AVDT_TSEP_SNK /* peer_sep */, btif_av_event)); 2473 } 2474 2475 static void bta_av_sink_callback(tBTA_AV_EVT event, tBTA_AV* p_data) { 2476 BtifAvEvent btif_av_event(event, p_data, sizeof(tBTA_AV)); 2477 do_in_bta_thread(FROM_HERE, 2478 base::Bind(&btif_av_handle_bta_av_event, 2479 AVDT_TSEP_SRC /* peer_sep */, btif_av_event)); 2480 } 2481 2482 // TODO: All processing should be done on the JNI thread 2483 static void bta_av_sink_media_callback(tBTA_AV_EVT event, 2484 tBTA_AV_MEDIA* p_data) { 2485 BTIF_TRACE_EVENT("%s: event=%d", __func__, event); 2486 2487 switch (event) { 2488 case BTA_AV_SINK_MEDIA_DATA_EVT: { 2489 BtifAvPeer* peer = btif_av_sink_find_peer(btif_av_sink.ActivePeer()); 2490 if (peer != nullptr) { 2491 int state = peer->StateMachine().StateId(); 2492 if ((state == BtifAvStateMachine::kStateStarted) || 2493 (state == BtifAvStateMachine::kStateOpened)) { 2494 uint8_t queue_len = btif_a2dp_sink_enqueue_buf((BT_HDR*)p_data); 2495 BTIF_TRACE_DEBUG("%s: Packets in Sink queue %d", __func__, queue_len); 2496 } 2497 } 2498 break; 2499 } 2500 case BTA_AV_SINK_MEDIA_CFG_EVT: { 2501 btif_av_sink_config_req_t config_req; 2502 2503 // Update the codec info of the A2DP Sink decoder 2504 btif_a2dp_sink_update_decoder((uint8_t*)(p_data->avk_config.codec_info)); 2505 2506 config_req.sample_rate = 2507 A2DP_GetTrackSampleRate(p_data->avk_config.codec_info); 2508 if (config_req.sample_rate == -1) { 2509 APPL_TRACE_ERROR("%s: Cannot get the track frequency", __func__); 2510 break; 2511 } 2512 config_req.channel_count = 2513 A2DP_GetTrackChannelCount(p_data->avk_config.codec_info); 2514 if (config_req.channel_count == -1) { 2515 APPL_TRACE_ERROR("%s: Cannot get the channel count", __func__); 2516 break; 2517 } 2518 config_req.peer_address = p_data->avk_config.bd_addr; 2519 BtifAvEvent btif_av_event(BTIF_AV_SINK_CONFIG_REQ_EVT, &config_req, 2520 sizeof(config_req)); 2521 do_in_bta_thread(FROM_HERE, base::Bind(&btif_av_handle_event, 2522 AVDT_TSEP_SRC, // peer_sep 2523 config_req.peer_address, 2524 kBtaHandleUnknown, btif_av_event)); 2525 break; 2526 } 2527 default: 2528 break; 2529 } 2530 } 2531 2532 // Initializes the AV interface for source mode 2533 static bt_status_t init_src( 2534 btav_source_callbacks_t* callbacks, int max_connected_audio_devices, 2535 std::vector<btav_a2dp_codec_config_t> codec_priorities) { 2536 BTIF_TRACE_EVENT("%s", __func__); 2537 return btif_av_source.Init(callbacks, max_connected_audio_devices, 2538 codec_priorities); 2539 } 2540 2541 // Initializes the AV interface for sink mode 2542 static bt_status_t init_sink(btav_sink_callbacks_t* callbacks) { 2543 BTIF_TRACE_EVENT("%s", __func__); 2544 return btif_av_sink.Init(callbacks); 2545 } 2546 2547 // Updates the final focus state reported by components calling this module 2548 static void update_audio_focus_state(int state) { 2549 BTIF_TRACE_DEBUG("%s: state=%d", __func__, state); 2550 btif_a2dp_sink_set_focus_state_req((btif_a2dp_sink_focus_state_t)state); 2551 } 2552 2553 // Updates the track gain (used for ducking). 2554 static void update_audio_track_gain(float gain) { 2555 BTIF_TRACE_DEBUG("%s: gain=%f", __func__, gain); 2556 btif_a2dp_sink_set_audio_track_gain(gain); 2557 } 2558 2559 // Establishes the AV signalling channel with the remote headset 2560 static bt_status_t connect_int(RawAddress* peer_address, uint16_t uuid) { 2561 BTIF_TRACE_EVENT("%s: peer_address=%s uuid=0x%x", __func__, 2562 peer_address->ToString().c_str(), uuid); 2563 2564 BtifAvPeer* peer = nullptr; 2565 if (uuid == UUID_SERVCLASS_AUDIO_SOURCE) { 2566 peer = btif_av_source.FindOrCreatePeer(*peer_address, kBtaHandleUnknown); 2567 if (peer == nullptr) { 2568 return BT_STATUS_FAIL; 2569 } 2570 } else if (uuid == UUID_SERVCLASS_AUDIO_SINK) { 2571 peer = btif_av_sink.FindOrCreatePeer(*peer_address, kBtaHandleUnknown); 2572 if (peer == nullptr) { 2573 return BT_STATUS_FAIL; 2574 } 2575 } 2576 peer->StateMachine().ProcessEvent(BTIF_AV_CONNECT_REQ_EVT, nullptr); 2577 return BT_STATUS_SUCCESS; 2578 } 2579 2580 // Set the active peer 2581 static void set_active_peer_int(uint8_t peer_sep, 2582 const RawAddress& peer_address) { 2583 BTIF_TRACE_EVENT("%s: peer_sep=%s (%d) peer_address=%s", __func__, 2584 (peer_sep == AVDT_TSEP_SRC) ? "Source" : "Sink", peer_sep, 2585 peer_address.ToString().c_str()); 2586 BtifAvPeer* peer = nullptr; 2587 if (peer_sep == AVDT_TSEP_SNK) { 2588 if (!btif_av_source.SetActivePeer(peer_address)) { 2589 BTIF_TRACE_ERROR("%s: Error setting %s as active Sink peer", __func__, 2590 peer_address.ToString().c_str()); 2591 } 2592 return; 2593 } 2594 if (peer_sep == AVDT_TSEP_SRC) { 2595 if (!btif_av_sink.SetActivePeer(peer_address)) { 2596 BTIF_TRACE_ERROR("%s: Error setting %s as active Source peer", __func__, 2597 peer_address.ToString().c_str()); 2598 } 2599 return; 2600 } 2601 // If reached here, we could not set the active peer 2602 BTIF_TRACE_ERROR("%s: Cannot set active %s peer to %s: peer not %s", __func__, 2603 (peer_sep == AVDT_TSEP_SRC) ? "Source" : "Sink", 2604 peer_address.ToString().c_str(), 2605 (peer == nullptr) ? "found" : "connected"); 2606 } 2607 2608 static bt_status_t src_connect_sink(const RawAddress& peer_address) { 2609 BTIF_TRACE_EVENT("%s: Peer %s", __func__, peer_address.ToString().c_str()); 2610 2611 if (!btif_av_source.Enabled()) { 2612 BTIF_TRACE_WARNING("%s: BTIF AV Source is not enabled", __func__); 2613 return BT_STATUS_NOT_READY; 2614 } 2615 2616 RawAddress peer_address_copy(peer_address); 2617 return btif_queue_connect(UUID_SERVCLASS_AUDIO_SOURCE, &peer_address_copy, 2618 connect_int); 2619 } 2620 2621 static bt_status_t sink_connect_src(const RawAddress& peer_address) { 2622 LOG_INFO(LOG_TAG, "%s: Peer %s", __func__, peer_address.ToString().c_str()); 2623 2624 if (!btif_av_sink.Enabled()) { 2625 BTIF_TRACE_WARNING("%s: BTIF AV Sink is not enabled", __func__); 2626 return BT_STATUS_NOT_READY; 2627 } 2628 2629 RawAddress peer_address_copy(peer_address); 2630 return btif_queue_connect(UUID_SERVCLASS_AUDIO_SINK, &peer_address_copy, 2631 connect_int); 2632 } 2633 2634 static bt_status_t src_disconnect_sink(const RawAddress& peer_address) { 2635 LOG_INFO(LOG_TAG, "%s: Peer %s", __func__, peer_address.ToString().c_str()); 2636 2637 if (!btif_av_source.Enabled()) { 2638 BTIF_TRACE_WARNING("%s: BTIF AV Source is not enabled", __func__); 2639 return BT_STATUS_NOT_READY; 2640 } 2641 2642 BtifAvEvent btif_av_event(BTIF_AV_DISCONNECT_REQ_EVT, &peer_address, 2643 sizeof(peer_address)); 2644 return do_in_bta_thread( 2645 FROM_HERE, base::Bind(&btif_av_handle_event, 2646 AVDT_TSEP_SNK, // peer_sep 2647 peer_address, kBtaHandleUnknown, btif_av_event)); 2648 } 2649 2650 static bt_status_t sink_disconnect_src(const RawAddress& peer_address) { 2651 LOG_INFO(LOG_TAG, "%s: Peer %s", __func__, peer_address.ToString().c_str()); 2652 2653 if (!btif_av_sink.Enabled()) { 2654 BTIF_TRACE_WARNING("%s: BTIF AV Sink is not enabled", __func__); 2655 return BT_STATUS_NOT_READY; 2656 } 2657 2658 BtifAvEvent btif_av_event(BTIF_AV_DISCONNECT_REQ_EVT, &peer_address, 2659 sizeof(peer_address)); 2660 return do_in_bta_thread( 2661 FROM_HERE, base::Bind(&btif_av_handle_event, 2662 AVDT_TSEP_SRC, // peer_sep 2663 peer_address, kBtaHandleUnknown, btif_av_event)); 2664 } 2665 2666 static bt_status_t src_set_active_sink(const RawAddress& peer_address) { 2667 BTIF_TRACE_EVENT("%s: Peer %s", __func__, peer_address.ToString().c_str()); 2668 2669 if (!btif_av_source.Enabled()) { 2670 BTIF_TRACE_WARNING("%s: BTIF AV Source is not enabled", __func__); 2671 return BT_STATUS_NOT_READY; 2672 } 2673 2674 return do_in_bta_thread(FROM_HERE, base::Bind(&set_active_peer_int, 2675 AVDT_TSEP_SNK, // peer_sep 2676 peer_address)); 2677 } 2678 2679 static bt_status_t codec_config_src( 2680 const RawAddress& peer_address, 2681 std::vector<btav_a2dp_codec_config_t> codec_preferences) { 2682 BTIF_TRACE_EVENT("%s", __func__); 2683 2684 if (!btif_av_source.Enabled()) { 2685 BTIF_TRACE_WARNING("%s: BTIF AV Source is not enabled", __func__); 2686 return BT_STATUS_NOT_READY; 2687 } 2688 2689 return do_in_bta_thread( 2690 FROM_HERE, base::Bind(&BtifAvSource::UpdateCodecConfig, 2691 base::Unretained(&btif_av_source), peer_address, 2692 codec_preferences)); 2693 } 2694 2695 static void cleanup_src(void) { 2696 BTIF_TRACE_EVENT("%s", __func__); 2697 do_in_bta_thread(FROM_HERE, base::Bind(&BtifAvSource::Cleanup, 2698 base::Unretained(&btif_av_source))); 2699 } 2700 2701 static void cleanup_sink(void) { 2702 BTIF_TRACE_EVENT("%s", __func__); 2703 do_in_bta_thread(FROM_HERE, base::Bind(&BtifAvSink::Cleanup, 2704 base::Unretained(&btif_av_sink))); 2705 } 2706 2707 static const btav_source_interface_t bt_av_src_interface = { 2708 sizeof(btav_source_interface_t), 2709 init_src, 2710 src_connect_sink, 2711 src_disconnect_sink, 2712 src_set_active_sink, 2713 codec_config_src, 2714 cleanup_src, 2715 }; 2716 2717 static const btav_sink_interface_t bt_av_sink_interface = { 2718 sizeof(btav_sink_interface_t), init_sink, sink_connect_src, 2719 sink_disconnect_src, cleanup_sink, update_audio_focus_state, 2720 update_audio_track_gain, 2721 }; 2722 2723 RawAddress btif_av_source_active_peer(void) { 2724 return btif_av_source.ActivePeer(); 2725 } 2726 RawAddress btif_av_sink_active_peer(void) { return btif_av_sink.ActivePeer(); } 2727 2728 bool btif_av_is_sink_enabled(void) { return btif_av_sink.Enabled(); } 2729 2730 void btif_av_stream_start(void) { 2731 LOG_INFO(LOG_TAG, "%s", __func__); 2732 btif_av_source_dispatch_sm_event(btif_av_source_active_peer(), 2733 BTIF_AV_START_STREAM_REQ_EVT); 2734 } 2735 2736 void btif_av_stream_stop(const RawAddress& peer_address) { 2737 LOG_INFO(LOG_TAG, "%s peer %s", __func__, peer_address.ToString().c_str()); 2738 2739 if (!peer_address.IsEmpty()) { 2740 btif_av_source_dispatch_sm_event(peer_address, BTIF_AV_STOP_STREAM_REQ_EVT); 2741 return; 2742 } 2743 2744 // The active peer might have changed and we might be in the process 2745 // of reconfiguring the stream. We need to stop the appopriate peer(s). 2746 for (auto it : btif_av_source.Peers()) { 2747 const BtifAvPeer* peer = it.second; 2748 btif_av_source_dispatch_sm_event(peer->PeerAddress(), 2749 BTIF_AV_STOP_STREAM_REQ_EVT); 2750 } 2751 } 2752 2753 void btif_av_stream_suspend(void) { 2754 LOG_INFO(LOG_TAG, "%s", __func__); 2755 // The active peer might have changed and we might be in the process 2756 // of reconfiguring the stream. We need to suspend the appropriate peer(s). 2757 for (auto it : btif_av_source.Peers()) { 2758 const BtifAvPeer* peer = it.second; 2759 btif_av_source_dispatch_sm_event(peer->PeerAddress(), 2760 BTIF_AV_SUSPEND_STREAM_REQ_EVT); 2761 } 2762 } 2763 2764 void btif_av_stream_start_offload(void) { 2765 LOG_INFO(LOG_TAG, "%s", __func__); 2766 btif_av_source_dispatch_sm_event(btif_av_source_active_peer(), 2767 BTIF_AV_OFFLOAD_START_REQ_EVT); 2768 } 2769 2770 void btif_av_src_disconnect_sink(const RawAddress& peer_address) { 2771 LOG_INFO(LOG_TAG, "%s: peer %s", __func__, peer_address.ToString().c_str()); 2772 src_disconnect_sink(peer_address); 2773 } 2774 2775 bool btif_av_stream_ready(void) { 2776 // Make sure the main adapter is enabled 2777 if (btif_is_enabled() == 0) { 2778 BTIF_TRACE_EVENT("%s: Main adapter is not enabled", __func__); 2779 return false; 2780 } 2781 2782 BtifAvPeer* peer = btif_av_find_active_peer(); 2783 if (peer == nullptr) { 2784 BTIF_TRACE_WARNING("%s: No active peer found", __func__); 2785 return false; 2786 } 2787 2788 int state = peer->StateMachine().StateId(); 2789 LOG_INFO(LOG_TAG, "%s: Peer %s : state=%d, flags=%s", __func__, 2790 peer->PeerAddress().ToString().c_str(), state, 2791 peer->FlagsToString().c_str()); 2792 // check if we are remotely suspended or stop is pending 2793 if (peer->CheckFlags(BtifAvPeer::kFlagRemoteSuspend | 2794 BtifAvPeer::kFlagPendingStop)) { 2795 return false; 2796 } 2797 2798 return (state == BtifAvStateMachine::kStateOpened); 2799 } 2800 2801 bool btif_av_stream_started_ready(void) { 2802 BtifAvPeer* peer = btif_av_find_active_peer(); 2803 if (peer == nullptr) { 2804 BTIF_TRACE_WARNING("%s: No active peer found", __func__); 2805 return false; 2806 } 2807 2808 int state = peer->StateMachine().StateId(); 2809 bool ready = false; 2810 if (peer->CheckFlags(BtifAvPeer::kFlagLocalSuspendPending | 2811 BtifAvPeer::kFlagRemoteSuspend | 2812 BtifAvPeer::kFlagPendingStop)) { 2813 // Disallow media task to start if we have pending actions 2814 ready = false; 2815 } else { 2816 ready = (state == BtifAvStateMachine::kStateStarted); 2817 } 2818 LOG_INFO(LOG_TAG, "%s: Peer %s : state=%d flags=%s ready=%d", __func__, 2819 peer->PeerAddress().ToString().c_str(), state, 2820 peer->FlagsToString().c_str(), ready); 2821 2822 return ready; 2823 } 2824 2825 static void btif_av_source_dispatch_sm_event(const RawAddress& peer_address, 2826 btif_av_sm_event_t event) { 2827 BtifAvEvent btif_av_event(event, nullptr, 0); 2828 BTIF_TRACE_EVENT("%s: peer_address=%s event=%s", __func__, 2829 peer_address.ToString().c_str(), 2830 btif_av_event.ToString().c_str()); 2831 2832 do_in_bta_thread(FROM_HERE, 2833 base::Bind(&btif_av_handle_event, 2834 AVDT_TSEP_SNK, // peer_sep 2835 peer_address, kBtaHandleUnknown, btif_av_event)); 2836 } 2837 2838 static void btif_av_sink_dispatch_sm_event(const RawAddress& peer_address, 2839 btif_av_sm_event_t event) { 2840 BtifAvEvent btif_av_event(event, nullptr, 0); 2841 BTIF_TRACE_EVENT("%s: peer_address=%s event=%s", __func__, 2842 peer_address.ToString().c_str(), 2843 btif_av_event.ToString().c_str()); 2844 2845 do_in_bta_thread(FROM_HERE, 2846 base::Bind(&btif_av_handle_event, 2847 AVDT_TSEP_SRC, // peer_sep 2848 peer_address, kBtaHandleUnknown, btif_av_event)); 2849 } 2850 2851 bt_status_t btif_av_source_execute_service(bool enable) { 2852 BTIF_TRACE_EVENT("%s: Source service: %s", __func__, 2853 (enable) ? "enable" : "disable"); 2854 2855 if (enable) { 2856 // TODO: Removed BTA_SEC_AUTHORIZE since the Java/App does not 2857 // handle this request in order to allow incoming connections to succeed. 2858 // We need to put this back once support for this is added. 2859 2860 // Added BTA_AV_FEAT_NO_SCO_SSPD - this ensures that the BTA does not 2861 // auto-suspend av streaming on AG events(SCO or Call). The suspend shall 2862 // be initiated by the app/audioflinger layers. 2863 // Support for browsing for SDP record should work only if we enable BROWSE 2864 // while registering. 2865 tBTA_AV_FEAT features = BTA_AV_FEAT_RCTG | BTA_AV_FEAT_METADATA | 2866 BTA_AV_FEAT_VENDOR | BTA_AV_FEAT_NO_SCO_SSPD; 2867 2868 if (delay_reporting_enabled()) { 2869 features |= BTA_AV_FEAT_DELAY_RPT; 2870 } 2871 2872 #if (AVRC_ADV_CTRL_INCLUDED == TRUE) 2873 features |= BTA_AV_FEAT_RCCT | BTA_AV_FEAT_ADV_CTRL | BTA_AV_FEAT_BROWSE; 2874 #endif 2875 BTA_AvEnable(BTA_SEC_AUTHENTICATE, features, bta_av_source_callback); 2876 btif_av_source.RegisterAllBtaHandles(); 2877 return BT_STATUS_SUCCESS; 2878 } 2879 2880 // Disable the service 2881 btif_av_source.DeregisterAllBtaHandles(); 2882 BTA_AvDisable(); 2883 return BT_STATUS_SUCCESS; 2884 } 2885 2886 bt_status_t btif_av_sink_execute_service(bool enable) { 2887 BTIF_TRACE_EVENT("%s: Sink service: %s", __func__, 2888 (enable) ? "enable" : "disable"); 2889 2890 if (enable) { 2891 // Added BTA_AV_FEAT_NO_SCO_SSPD - this ensures that the BTA does not 2892 // auto-suspend AV streaming on AG events (SCO or Call). The suspend shall 2893 // be initiated by the app/audioflinger layers. 2894 tBTA_AV_FEAT features = BTA_AV_FEAT_NO_SCO_SSPD | BTA_AV_FEAT_RCCT | 2895 BTA_AV_FEAT_METADATA | BTA_AV_FEAT_VENDOR | 2896 BTA_AV_FEAT_ADV_CTRL | BTA_AV_FEAT_RCTG | 2897 BTA_AV_FEAT_BROWSE; 2898 BTA_AvEnable(BTA_SEC_AUTHENTICATE, features, bta_av_sink_callback); 2899 btif_av_sink.RegisterAllBtaHandles(); 2900 return BT_STATUS_SUCCESS; 2901 } 2902 2903 // Disable the service 2904 btif_av_sink.DeregisterAllBtaHandles(); 2905 BTA_AvDisable(); 2906 return BT_STATUS_SUCCESS; 2907 } 2908 2909 // Get the AV callback interface for A2DP source profile 2910 const btav_source_interface_t* btif_av_get_src_interface(void) { 2911 BTIF_TRACE_EVENT("%s", __func__); 2912 return &bt_av_src_interface; 2913 } 2914 2915 // Get the AV callback interface for A2DP sink profile 2916 const btav_sink_interface_t* btif_av_get_sink_interface(void) { 2917 BTIF_TRACE_EVENT("%s", __func__); 2918 return &bt_av_sink_interface; 2919 } 2920 2921 bool btif_av_is_connected(void) { 2922 BtifAvPeer* peer = btif_av_find_active_peer(); 2923 if (peer == nullptr) { 2924 BTIF_TRACE_WARNING("%s: No active peer found", __func__); 2925 return false; 2926 } 2927 2928 bool connected = peer->IsConnected(); 2929 BTIF_TRACE_DEBUG("%s: Peer %s is %s", __func__, 2930 peer->PeerAddress().ToString().c_str(), 2931 (connected) ? "connected" : "not connected"); 2932 return connected; 2933 } 2934 2935 uint8_t btif_av_get_peer_sep(void) { 2936 BtifAvPeer* peer = btif_av_find_active_peer(); 2937 if (peer == nullptr) { 2938 BTIF_TRACE_WARNING("%s: No active peer found", __func__); 2939 return AVDT_TSEP_SNK; 2940 } 2941 2942 uint8_t peer_sep = peer->PeerSep(); 2943 BTIF_TRACE_DEBUG("%s: Peer %s SEP is %s (%d)", __func__, 2944 peer->PeerAddress().ToString().c_str(), 2945 (peer_sep == AVDT_TSEP_SRC) ? "Source" : "Sink", peer_sep); 2946 return peer_sep; 2947 } 2948 2949 void btif_av_clear_remote_suspend_flag(void) { 2950 BtifAvPeer* peer = btif_av_find_active_peer(); 2951 if (peer == nullptr) { 2952 BTIF_TRACE_WARNING("%s: No active peer found", __func__); 2953 return; 2954 } 2955 2956 BTIF_TRACE_DEBUG("%s: Peer %s : flags=%s are cleared", __func__, 2957 peer->PeerAddress().ToString().c_str(), 2958 peer->FlagsToString().c_str()); 2959 peer->ClearFlags(BtifAvPeer::kFlagRemoteSuspend); 2960 } 2961 2962 void btif_av_avrcp_event_open(const RawAddress& peer_address) { 2963 // TODO: We need a better demultipexing mechanism whether the remote device 2964 // is an A2DP Source or a Sink. 2965 if (btif_av_source.Enabled()) { 2966 BtifAvPeer* peer = 2967 btif_av_source.FindOrCreatePeer(peer_address, kBtaHandleUnknown); 2968 if (peer != nullptr) { 2969 btif_av_source_dispatch_sm_event(peer_address, BTIF_AV_AVRCP_OPEN_EVT); 2970 return; 2971 } 2972 } else if (btif_av_sink.Enabled()) { 2973 BtifAvPeer* peer = 2974 btif_av_sink.FindOrCreatePeer(peer_address, kBtaHandleUnknown); 2975 if (peer != nullptr) { 2976 btif_av_sink_dispatch_sm_event(peer_address, BTIF_AV_AVRCP_OPEN_EVT); 2977 return; 2978 } 2979 } 2980 BTIF_TRACE_ERROR("%s: event ignored: cannot find or create peer state for %s", 2981 __func__, peer_address.ToString().c_str()); 2982 } 2983 2984 void btif_av_avrcp_event_close(const RawAddress& peer_address) { 2985 // TODO: We need a better demultipexing mechanism whether the remote device 2986 // is an A2DP Source or a Sink. 2987 if (btif_av_source.Enabled()) { 2988 btif_av_source_dispatch_sm_event(peer_address, BTIF_AV_AVRCP_CLOSE_EVT); 2989 } else if (btif_av_sink.Enabled()) { 2990 btif_av_sink_dispatch_sm_event(peer_address, BTIF_AV_AVRCP_CLOSE_EVT); 2991 } 2992 } 2993 2994 void btif_av_avrcp_event_remote_play(const RawAddress& peer_address) { 2995 // TODO: We need a better demultipexing mechanism whether the remote device 2996 // is an A2DP Source or a Sink. 2997 if (btif_av_source.Enabled()) { 2998 btif_av_source_dispatch_sm_event(peer_address, 2999 BTIF_AV_AVRCP_REMOTE_PLAY_EVT); 3000 } else if (btif_av_sink.Enabled()) { 3001 btif_av_sink_dispatch_sm_event(peer_address, BTIF_AV_AVRCP_REMOTE_PLAY_EVT); 3002 } 3003 } 3004 3005 bool btif_av_is_peer_edr(const RawAddress& peer_address) { 3006 BtifAvPeer* peer = btif_av_find_peer(peer_address); 3007 if (peer == nullptr) { 3008 BTIF_TRACE_WARNING("%s: No peer found for peer_address=%s", __func__, 3009 peer_address.ToString().c_str()); 3010 return false; 3011 } 3012 if (!peer->IsConnected()) { 3013 BTIF_TRACE_WARNING("%s: Peer %s is not connected", __func__, 3014 peer_address.ToString().c_str()); 3015 return false; 3016 } 3017 3018 bool is_edr = peer->IsEdr(); 3019 BTIF_TRACE_DEBUG("%s: Peer %s : is_edr=%d", __func__, 3020 peer_address.ToString().c_str(), is_edr); 3021 return is_edr; 3022 } 3023 3024 bool btif_av_peer_supports_3mbps(const RawAddress& peer_address) { 3025 BtifAvPeer* peer = btif_av_find_peer(peer_address); 3026 if (peer == nullptr) { 3027 BTIF_TRACE_WARNING("%s: No peer found for peer_address=%s", __func__, 3028 peer_address.ToString().c_str()); 3029 return false; 3030 } 3031 3032 bool is3mbps = peer->Is3Mbps(); 3033 bool is_connected = peer->IsConnected(); 3034 BTIF_TRACE_DEBUG("%s: Peer %s : connected=%d, edr_3mbps=%d", __func__, 3035 peer_address.ToString().c_str(), is_connected, is3mbps); 3036 return (is_connected && is3mbps); 3037 } 3038 3039 void btif_av_acl_disconnected(const RawAddress& peer_address) { 3040 // Inform the application that ACL is disconnected and move to idle state 3041 LOG_INFO(LOG_TAG, "%s: Peer %s : ACL Disconnected", __func__, 3042 peer_address.ToString().c_str()); 3043 3044 if (btif_av_source.Enabled()) { 3045 btif_av_source_dispatch_sm_event(peer_address, BTIF_AV_ACL_DISCONNECTED); 3046 } else if (btif_av_sink.Enabled()) { 3047 btif_av_sink_dispatch_sm_event(peer_address, BTIF_AV_ACL_DISCONNECTED); 3048 } 3049 } 3050 3051 static void btif_debug_av_peer_dump(int fd, const BtifAvPeer& peer) { 3052 std::string state_str; 3053 int state = peer.StateMachine().StateId(); 3054 switch (state) { 3055 case BtifAvStateMachine::kStateIdle: 3056 state_str = "Idle"; 3057 break; 3058 case BtifAvStateMachine::kStateOpening: 3059 state_str = "Opening"; 3060 break; 3061 case BtifAvStateMachine::kStateOpened: 3062 state_str = "Opened"; 3063 break; 3064 case BtifAvStateMachine::kStateStarted: 3065 state_str = "Started"; 3066 break; 3067 case BtifAvStateMachine::kStateClosing: 3068 state_str = "Closing"; 3069 break; 3070 default: 3071 state_str = "Unknown(" + std::to_string(state) + ")"; 3072 break; 3073 } 3074 3075 dprintf(fd, " Peer: %s\n", peer.PeerAddress().ToString().c_str()); 3076 dprintf(fd, " Connected: %s\n", peer.IsConnected() ? "true" : "false"); 3077 dprintf(fd, " Streaming: %s\n", peer.IsStreaming() ? "true" : "false"); 3078 dprintf(fd, " SEP: %d(%s)\n", peer.PeerSep(), 3079 (peer.IsSource()) ? "Source" : "Sink"); 3080 dprintf(fd, " State Machine: %s\n", state_str.c_str()); 3081 dprintf(fd, " Flags: %s\n", peer.FlagsToString().c_str()); 3082 dprintf(fd, " OpenOnRcTimer: %s\n", 3083 alarm_is_scheduled(peer.AvOpenOnRcTimer()) ? "Scheduled" 3084 : "Not scheduled"); 3085 dprintf(fd, " BTA Handle: 0x%x\n", peer.BtaHandle()); 3086 dprintf(fd, " Peer ID: %d\n", peer.PeerId()); 3087 dprintf(fd, " EDR: %s\n", peer.IsEdr() ? "true" : "false"); 3088 dprintf(fd, " Support 3Mbps: %s\n", peer.Is3Mbps() ? "true" : "false"); 3089 dprintf(fd, " Self Initiated Connection: %s\n", 3090 peer.SelfInitiatedConnection() ? "true" : "false"); 3091 } 3092 3093 static void btif_debug_av_source_dump(int fd) { 3094 bool enabled = btif_av_source.Enabled(); 3095 3096 dprintf(fd, "\nA2DP Source State: %s\n", (enabled) ? "Enabled" : "Disabled"); 3097 if (!enabled) return; 3098 dprintf(fd, " Active peer: %s\n", 3099 btif_av_source.ActivePeer().ToString().c_str()); 3100 for (auto it : btif_av_source.Peers()) { 3101 const BtifAvPeer* peer = it.second; 3102 btif_debug_av_peer_dump(fd, *peer); 3103 } 3104 } 3105 3106 static void btif_debug_av_sink_dump(int fd) { 3107 bool enabled = btif_av_sink.Enabled(); 3108 3109 dprintf(fd, "\nA2DP Sink State: %s\n", (enabled) ? "Enabled" : "Disabled"); 3110 if (!enabled) return; 3111 dprintf(fd, " Active peer: %s\n", 3112 btif_av_sink.ActivePeer().ToString().c_str()); 3113 dprintf(fd, " Peers:\n"); 3114 for (auto it : btif_av_sink.Peers()) { 3115 const BtifAvPeer* peer = it.second; 3116 btif_debug_av_peer_dump(fd, *peer); 3117 } 3118 } 3119 3120 void btif_debug_av_dump(int fd) { 3121 btif_debug_av_source_dump(fd); 3122 btif_debug_av_sink_dump(fd); 3123 } 3124 3125 void btif_av_set_audio_delay(uint16_t delay) { 3126 btif_a2dp_control_set_audio_delay(delay); 3127 } 3128 3129 void btif_av_reset_audio_delay(void) { btif_a2dp_control_reset_audio_delay(); } 3130 3131 bool btif_av_is_a2dp_offload_enabled() { 3132 return btif_av_source.A2dpOffloadEnabled(); 3133 } 3134
