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
Event() const97 uint32_t Event() const { return event_; }
Data() const98 void* Data() const { return data_; }
DataLength() const99 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:
StateIdle(BtifAvStateMachine & sm)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:
StateOpening(BtifAvStateMachine & sm)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:
StateOpened(BtifAvStateMachine & sm)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:
StateStarted(BtifAvStateMachine & sm)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:
StateClosing(BtifAvStateMachine & sm)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
BtifAvStateMachine(BtifAvPeer & btif_av_peer)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
Peer()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 */
IsActivePeer() const243 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
PeerAddress() const252 const RawAddress& PeerAddress() const { return peer_address_; }
IsSource() const253 bool IsSource() const { return (peer_sep_ == AVDT_TSEP_SRC); }
IsSink() const254 bool IsSink() const { return (peer_sep_ == AVDT_TSEP_SNK); }
PeerSep() const255 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 */
LocalUuidServiceClass() const262 uint16_t LocalUuidServiceClass() const {
263 return (IsSink() ? UUID_SERVCLASS_AUDIO_SOURCE : UUID_SERVCLASS_AUDIO_SINK);
264 }
BtaHandle() const265 tBTA_AV_HNDL BtaHandle() const { return bta_handle_; }
SetBtaHandle(tBTA_AV_HNDL bta_handle)266 void SetBtaHandle(tBTA_AV_HNDL bta_handle) { bta_handle_ = bta_handle; }
PeerId() const267 uint8_t PeerId() const { return peer_id_; }
268
StateMachine()269 BtifAvStateMachine& StateMachine() { return state_machine_; }
StateMachine() const270 const BtifAvStateMachine& StateMachine() const { return state_machine_; }
AvOpenOnRcTimer()271 alarm_t* AvOpenOnRcTimer() { return av_open_on_rc_timer_; }
AvOpenOnRcTimer() const272 const alarm_t* AvOpenOnRcTimer() const { return av_open_on_rc_timer_; }
273
SetEdr(tBTA_AV_EDR edr)274 void SetEdr(tBTA_AV_EDR edr) { edr_ = edr; }
IsEdr() const275 bool IsEdr() const { return (edr_ != 0); }
Is3Mbps() const276 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 */
CheckFlags(uint8_t bitflags_mask) const287 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 */
SetFlags(uint8_t bitflags_mask)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 */
ClearFlags(uint8_t bitflags_mask)303 void ClearFlags(uint8_t bitflags_mask) { flags_ &= ~bitflags_mask; }
304
305 /**
306 * Clear all flags.
307 */
ClearAllFlags()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
SelfInitiatedConnection() const315 bool SelfInitiatedConnection() const { return self_initiated_connection_; }
SetSelfInitiatedConnection(bool v)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
BtifAvSource()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
Callbacks()348 btav_source_callbacks_t* Callbacks() { return callbacks_; }
Enabled() const349 bool Enabled() const { return enabled_; }
A2dpOffloadEnabled() const350 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 */
ActivePeer() const386 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 */
SetActivePeer(const RawAddress & peer_address)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 */
UpdateCodecConfig(const RawAddress & peer_address,const std::vector<btav_a2dp_codec_config_t> & codec_preferences)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
Peers() const453 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
BtifAvSink()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
Callbacks()486 btav_sink_callbacks_t* Callbacks() { return callbacks_; }
Enabled() const487 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 */
ActivePeer() const523 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 */
SetActivePeer(const RawAddress & peer_address)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
Peers() const564 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
btif_av_source_find_peer(const RawAddress & peer_address)622 static BtifAvPeer* btif_av_source_find_peer(const RawAddress& peer_address) {
623 return btif_av_source.FindPeer(peer_address);
624 }
btif_av_sink_find_peer(const RawAddress & peer_address)625 static BtifAvPeer* btif_av_sink_find_peer(const RawAddress& peer_address) {
626 return btif_av_sink.FindPeer(peer_address);
627 }
btif_av_find_peer(const RawAddress & peer_address)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 }
btif_av_find_active_peer()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
dump_av_sm_event_name(btif_av_sm_event_t event)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
BtifAvEvent(uint32_t event,const void * p_data,size_t data_length)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
BtifAvEvent(const BtifAvEvent & other)691 BtifAvEvent::BtifAvEvent(const BtifAvEvent& other)
692 : event_(0), data_(nullptr), data_length_(0) {
693 *this = other;
694 }
695
operator =(const BtifAvEvent & other)696 BtifAvEvent& BtifAvEvent::operator=(const BtifAvEvent& other) {
697 DeepFree();
698 DeepCopy(other.Event(), other.Data(), other.DataLength());
699 return *this;
700 }
701
~BtifAvEvent()702 BtifAvEvent::~BtifAvEvent() { DeepFree(); }
703
ToString() const704 std::string BtifAvEvent::ToString() const {
705 return BtifAvEvent::EventName(event_);
706 }
707
EventName(uint32_t event)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
DeepCopy(uint32_t event,const void * p_data,size_t data_length)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
DeepFree()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
BtifAvPeer(const RawAddress & peer_address,uint8_t peer_sep,tBTA_AV_HNDL bta_handle,uint8_t peer_id)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
~BtifAvPeer()804 BtifAvPeer::~BtifAvPeer() { alarm_free(av_open_on_rc_timer_); }
805
FlagsToString() const806 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
Init()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
Cleanup()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
CanBeDeleted() const844 bool BtifAvPeer::CanBeDeleted() const {
845 return (
846 (state_machine_.StateId() == BtifAvStateMachine::kStateIdle) &&
847 (state_machine_.PreviousStateId() != BtifAvStateMachine::kStateInvalid));
848 }
849
ActivePeerAddress() const850 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
IsConnected() const862 bool BtifAvPeer::IsConnected() const {
863 int state = state_machine_.StateId();
864 return ((state == BtifAvStateMachine::kStateOpened) ||
865 (state == BtifAvStateMachine::kStateStarted));
866 }
867
IsStreaming() const868 bool BtifAvPeer::IsStreaming() const {
869 int state = state_machine_.StateId();
870 return (state == BtifAvStateMachine::kStateStarted);
871 }
872
~BtifAvSource()873 BtifAvSource::~BtifAvSource() { CleanupAllPeers(); }
874
Init(btav_source_callbacks_t * callbacks,int max_connected_audio_devices,const std::vector<btav_a2dp_codec_config_t> & codec_priorities)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
Cleanup()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
FindPeer(const RawAddress & peer_address)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
FindPeerByHandle(tBTA_AV_HNDL bta_handle)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
FindPeerByPeerId(uint8_t peer_id)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
FindOrCreatePeer(const RawAddress & peer_address,tBTA_AV_HNDL bta_handle)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
AllowedToConnect(const RawAddress & peer_address) const988 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
DeletePeer(const RawAddress & peer_address)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
DeleteIdlePeers()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
CleanupAllPeers()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
RegisterAllBtaHandles()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
DeregisterAllBtaHandles()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
BtaHandleRegistered(uint8_t peer_id,tBTA_AV_HNDL bta_handle)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
~BtifAvSink()1069 BtifAvSink::~BtifAvSink() { CleanupAllPeers(); }
1070
Init(btav_sink_callbacks_t * callbacks)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
Cleanup()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
FindPeer(const RawAddress & peer_address)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
FindPeerByHandle(tBTA_AV_HNDL bta_handle)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
FindPeerByPeerId(uint8_t peer_id)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
FindOrCreatePeer(const RawAddress & peer_address,tBTA_AV_HNDL bta_handle)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
AllowedToConnect(const RawAddress & peer_address) const1174 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
DeletePeer(const RawAddress & peer_address)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
DeleteIdlePeers()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
CleanupAllPeers()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
RegisterAllBtaHandles()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
DeregisterAllBtaHandles()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
BtaHandleRegistered(uint8_t peer_id,tBTA_AV_HNDL bta_handle)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
OnEnter()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
OnExit()1286 void BtifAvStateMachine::StateIdle::OnExit() {
1287 BTIF_TRACE_DEBUG("%s: Peer %s", __PRETTY_FUNCTION__,
1288 peer_.PeerAddress().ToString().c_str());
1289 }
1290
ProcessEvent(uint32_t event,void * p_data)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
OnEnter()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
OnExit()1512 void BtifAvStateMachine::StateOpening::OnExit() {
1513 BTIF_TRACE_DEBUG("%s: Peer %s", __PRETTY_FUNCTION__,
1514 peer_.PeerAddress().ToString().c_str());
1515 }
1516
ProcessEvent(uint32_t event,void * p_data)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
OnEnter()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
OnExit()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
ProcessEvent(uint32_t event,void * p_data)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
OnEnter()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
OnExit()1892 void BtifAvStateMachine::StateStarted::OnExit() {
1893 BTIF_TRACE_DEBUG("%s: Peer %s", __PRETTY_FUNCTION__,
1894 peer_.PeerAddress().ToString().c_str());
1895 }
1896
ProcessEvent(uint32_t event,void * p_data)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
OnEnter()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
OnExit()2086 void BtifAvStateMachine::StateClosing::OnExit() {
2087 BTIF_TRACE_DEBUG("%s: Peer %s", __PRETTY_FUNCTION__,
2088 peer_.PeerAddress().ToString().c_str());
2089 }
2090
ProcessEvent(uint32_t event,void * p_data)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 */
btif_av_source_initiate_av_open_timer_timeout(void * data)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 */
btif_av_sink_initiate_av_open_timer_timeout(void * data)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 */
btif_report_connection_state(const RawAddress & peer_address,btav_connection_state_t state)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 */
btif_report_audio_state(const RawAddress & peer_address,btav_audio_state_t state)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
btif_av_report_source_codec_state(const RawAddress & peer_address,const btav_a2dp_codec_config_t & codec_config,const std::vector<btav_a2dp_codec_config_t> & codecs_local_capabilities,const std::vector<btav_a2dp_codec_config_t> & codecs_selectable_capabilities)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 */
btif_av_report_sink_audio_config_state(const RawAddress & peer_address,int sample_rate,int channel_count)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 */
btif_av_handle_event(uint8_t peer_sep,const RawAddress & peer_address,tBTA_AV_HNDL bta_handle,const BtifAvEvent & btif_av_event)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 */
btif_av_handle_bta_av_event(uint8_t peer_sep,const BtifAvEvent & btif_av_event)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
bta_av_source_callback(tBTA_AV_EVT event,tBTA_AV * p_data)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
bta_av_sink_callback(tBTA_AV_EVT event,tBTA_AV * p_data)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
bta_av_sink_media_callback(tBTA_AV_EVT event,tBTA_AV_MEDIA * p_data)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
init_src(btav_source_callbacks_t * callbacks,int max_connected_audio_devices,std::vector<btav_a2dp_codec_config_t> codec_priorities)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
init_sink(btav_sink_callbacks_t * callbacks)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
update_audio_focus_state(int state)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).
update_audio_track_gain(float gain)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
connect_int(RawAddress * peer_address,uint16_t uuid)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
set_active_peer_int(uint8_t peer_sep,const RawAddress & peer_address)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
src_connect_sink(const RawAddress & peer_address)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
sink_connect_src(const RawAddress & peer_address)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
src_disconnect_sink(const RawAddress & peer_address)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
sink_disconnect_src(const RawAddress & peer_address)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
src_set_active_sink(const RawAddress & peer_address)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
codec_config_src(const RawAddress & peer_address,std::vector<btav_a2dp_codec_config_t> codec_preferences)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
cleanup_src(void)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
cleanup_sink(void)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
btif_av_source_active_peer(void)2723 RawAddress btif_av_source_active_peer(void) {
2724 return btif_av_source.ActivePeer();
2725 }
btif_av_sink_active_peer(void)2726 RawAddress btif_av_sink_active_peer(void) { return btif_av_sink.ActivePeer(); }
2727
btif_av_is_sink_enabled(void)2728 bool btif_av_is_sink_enabled(void) { return btif_av_sink.Enabled(); }
2729
btif_av_stream_start(void)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
btif_av_stream_stop(const RawAddress & peer_address)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
btif_av_stream_suspend(void)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
btif_av_stream_start_offload(void)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
btif_av_src_disconnect_sink(const RawAddress & peer_address)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
btif_av_stream_ready(void)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
btif_av_stream_started_ready(void)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
btif_av_source_dispatch_sm_event(const RawAddress & peer_address,btif_av_sm_event_t event)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
btif_av_sink_dispatch_sm_event(const RawAddress & peer_address,btif_av_sm_event_t event)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
btif_av_source_execute_service(bool enable)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
btif_av_sink_execute_service(bool enable)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
btif_av_get_src_interface(void)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
btif_av_get_sink_interface(void)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
btif_av_is_connected(void)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
btif_av_get_peer_sep(void)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
btif_av_clear_remote_suspend_flag(void)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
btif_av_avrcp_event_open(const RawAddress & peer_address)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
btif_av_avrcp_event_close(const RawAddress & peer_address)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
btif_av_avrcp_event_remote_play(const RawAddress & peer_address)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
btif_av_is_peer_edr(const RawAddress & peer_address)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
btif_av_peer_supports_3mbps(const RawAddress & peer_address)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
btif_av_acl_disconnected(const RawAddress & peer_address)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
btif_debug_av_peer_dump(int fd,const BtifAvPeer & peer)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
btif_debug_av_source_dump(int fd)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
btif_debug_av_sink_dump(int fd)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
btif_debug_av_dump(int fd)3120 void btif_debug_av_dump(int fd) {
3121 btif_debug_av_source_dump(fd);
3122 btif_debug_av_sink_dump(fd);
3123 }
3124
btif_av_set_audio_delay(uint16_t delay)3125 void btif_av_set_audio_delay(uint16_t delay) {
3126 btif_a2dp_control_set_audio_delay(delay);
3127 }
3128
btif_av_reset_audio_delay(void)3129 void btif_av_reset_audio_delay(void) { btif_a2dp_control_reset_audio_delay(); }
3130
btif_av_is_a2dp_offload_enabled()3131 bool btif_av_is_a2dp_offload_enabled() {
3132 return btif_av_source.A2dpOffloadEnabled();
3133 }
3134