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