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 "bluetooth-a2dp"
20
21 #include "btif/include/btif_av.h"
22
23 #include <base/functional/bind.h>
24 #include <bluetooth/log.h>
25 #include <com_android_bluetooth_flags.h>
26 #include <frameworks/proto_logging/stats/enums/bluetooth/a2dp/enums.pb.h>
27 #include <frameworks/proto_logging/stats/enums/bluetooth/enums.pb.h>
28 #include <stdio.h>
29
30 #include <chrono>
31 #include <cstdint>
32 #include <cstdio>
33 #include <cstring>
34 #include <future>
35 #include <ios>
36 #include <map>
37 #include <mutex>
38 #include <optional>
39 #include <set>
40 #include <sstream>
41 #include <string>
42 #include <utility>
43 #include <vector>
44
45 #include "audio_hal_interface/a2dp_encoding.h"
46 #include "bta/include/bta_api.h"
47 #include "bta/include/bta_api_data_types.h"
48 #include "bta/include/bta_av_api.h"
49 #include "btif/avrcp/avrcp_service.h"
50 #include "btif/include/btif_a2dp.h"
51 #include "btif/include/btif_a2dp_sink.h"
52 #include "btif/include/btif_a2dp_source.h"
53 #include "btif/include/btif_av_co.h"
54 #include "btif/include/btif_common.h"
55 #include "btif/include/btif_profile_queue.h"
56 #include "btif/include/btif_rc.h"
57 #include "btif/include/btif_util.h"
58 #include "btif/include/stack_manager_t.h"
59 #include "common/state_machine.h"
60 #include "device/include/device_iot_conf_defs.h"
61 #include "device/include/device_iot_config.h"
62 #include "hardware/bluetooth.h"
63 #include "hardware/bt_av.h"
64 #include "include/hardware/bt_rc.h"
65 #include "main/shim/metrics_api.h"
66 #include "osi/include/alarm.h"
67 #include "osi/include/allocator.h"
68 #include "osi/include/properties.h"
69 #include "stack/include/a2dp_codec_api.h"
70 #include "stack/include/avdt_api.h"
71 #include "stack/include/avrc_api.h"
72 #include "stack/include/avrc_defs.h"
73 #include "stack/include/bt_hdr.h"
74 #include "stack/include/bt_uuid16.h"
75 #include "stack/include/btm_ble_api.h"
76 #include "stack/include/btm_ble_api_types.h"
77 #include "stack/include/btm_log_history.h"
78 #include "stack/include/main_thread.h"
79 #include "types/raw_address.h"
80
81 #ifdef __ANDROID__
82 #include <android/sysprop/BluetoothProperties.sysprop.h>
83 #endif
84
85 using namespace bluetooth;
86
87 /*****************************************************************************
88 * Constants & Macros
89 *****************************************************************************/
90 static const char kBtifAvSourceServiceName[] = "Advanced Audio Source";
91 static const char kBtifAvSinkServiceName[] = "Advanced Audio Sink";
92 static constexpr int kDefaultMaxConnectedAudioDevices = 1;
93 static constexpr tBTA_AV_HNDL kBtaHandleUnknown = 0;
94
95 namespace {
96 constexpr char kBtmLogHistoryTag[] = "A2DP";
97 }
98
delay_reporting_enabled()99 static bool delay_reporting_enabled() {
100 return !osi_property_get_bool("persist.bluetooth.disabledelayreports", false);
101 }
102
103 /*****************************************************************************
104 * Local type definitions
105 *****************************************************************************/
106
107 typedef struct {
108 int sample_rate;
109 int channel_count;
110 RawAddress peer_address;
111 } btif_av_sink_config_req_t;
112
113 typedef struct {
114 bool use_latency_mode;
115 } btif_av_start_stream_req_t;
116
117 typedef struct {
118 bool is_low_latency;
119 } btif_av_set_latency_req_t;
120
121 typedef struct {
122 std::vector<btav_a2dp_codec_config_t> codec_preferences;
123 std::promise<void> reconf_ready_promise;
124 } btif_av_reconfig_req_t;
125
126 /**
127 * BTIF AV events
128 */
129 typedef enum {
130 /* Reuse BTA_AV_XXX_EVT - No need to redefine them here */
131 BTIF_AV_CONNECT_REQ_EVT = BTA_AV_MAX_EVT,
132 BTIF_AV_DISCONNECT_REQ_EVT,
133 BTIF_AV_START_STREAM_REQ_EVT,
134 BTIF_AV_STOP_STREAM_REQ_EVT,
135 BTIF_AV_SUSPEND_STREAM_REQ_EVT,
136 BTIF_AV_SINK_CONFIG_REQ_EVT,
137 BTIF_AV_ACL_DISCONNECTED,
138 BTIF_AV_OFFLOAD_START_REQ_EVT,
139 BTIF_AV_AVRCP_OPEN_EVT,
140 BTIF_AV_AVRCP_CLOSE_EVT,
141 BTIF_AV_AVRCP_REMOTE_PLAY_EVT,
142 BTIF_AV_SET_LATENCY_REQ_EVT,
143 BTIF_AV_RECONFIGURE_REQ_EVT,
144 } btif_av_sm_event_t;
145
146 class BtifAvEvent {
147 public:
148 BtifAvEvent(uint32_t event, const void* p_data, size_t data_length);
149 BtifAvEvent(const BtifAvEvent& other);
150 BtifAvEvent() = delete;
151 ~BtifAvEvent();
152 BtifAvEvent& operator=(const BtifAvEvent& other);
153
Event() const154 uint32_t Event() const { return event_; }
Data() const155 void* Data() const { return data_; }
DataLength() const156 size_t DataLength() const { return data_length_; }
157 std::string ToString() const;
158 static std::string EventName(uint32_t event);
159
160 private:
161 void DeepCopy(uint32_t event, const void* p_data, size_t data_length);
162 void DeepFree();
163
164 uint32_t event_;
165 void* data_;
166 size_t data_length_;
167 };
168
169 class BtifAvPeer;
170
171 // Should not need dedicated Suspend state as actual actions are no
172 // different than Open state. Suspend flags are needed however to prevent
173 // media task from trying to restart stream during remote Suspend or while
174 // we are in the process of a local Suspend.
175 class BtifAvStateMachine : public bluetooth::common::StateMachine {
176 public:
177 enum {
178 kStateIdle, // AVDTP disconnected
179 kStateOpening, // Opening AVDTP connection
180 kStateOpened, // AVDTP is in OPEN state
181 kStateStarted, // A2DP stream started
182 kStateClosing, // Closing AVDTP connection
183 };
184
185 class StateIdle : public State {
186 public:
StateIdle(BtifAvStateMachine & sm)187 explicit StateIdle(BtifAvStateMachine& sm) : State(sm, kStateIdle), peer_(sm.Peer()) {}
188 void OnEnter() override;
189 void OnExit() override;
190 bool ProcessEvent(uint32_t event, void* p_data) override;
191
192 private:
193 BtifAvPeer& peer_;
194 };
195
196 class StateOpening : public State {
197 public:
StateOpening(BtifAvStateMachine & sm)198 explicit StateOpening(BtifAvStateMachine& sm) : State(sm, kStateOpening), peer_(sm.Peer()) {}
199 void OnEnter() override;
200 void OnExit() override;
201 bool ProcessEvent(uint32_t event, void* p_data) override;
202
203 private:
204 BtifAvPeer& peer_;
205 };
206
207 class StateOpened : public State {
208 public:
StateOpened(BtifAvStateMachine & sm)209 explicit StateOpened(BtifAvStateMachine& sm) : State(sm, kStateOpened), peer_(sm.Peer()) {}
210 void OnEnter() override;
211 void OnExit() override;
212 bool ProcessEvent(uint32_t event, void* p_data) override;
213
214 private:
215 BtifAvPeer& peer_;
216 };
217
218 class StateStarted : public State {
219 public:
StateStarted(BtifAvStateMachine & sm)220 explicit StateStarted(BtifAvStateMachine& sm) : State(sm, kStateStarted), peer_(sm.Peer()) {}
221 void OnEnter() override;
222 void OnExit() override;
223 bool ProcessEvent(uint32_t event, void* p_data) override;
224
225 private:
226 BtifAvPeer& peer_;
227 };
228
229 class StateClosing : public State {
230 public:
StateClosing(BtifAvStateMachine & sm)231 explicit StateClosing(BtifAvStateMachine& sm) : State(sm, kStateClosing), peer_(sm.Peer()) {}
232 void OnEnter() override;
233 void OnExit() override;
234 bool ProcessEvent(uint32_t event, void* p_data) override;
235
236 private:
237 BtifAvPeer& peer_;
238 };
239
BtifAvStateMachine(BtifAvPeer & btif_av_peer)240 explicit BtifAvStateMachine(BtifAvPeer& btif_av_peer) : peer_(btif_av_peer) {
241 state_idle_ = new StateIdle(*this);
242 state_opening_ = new StateOpening(*this);
243 state_opened_ = new StateOpened(*this);
244 state_started_ = new StateStarted(*this);
245 state_closing_ = new StateClosing(*this);
246
247 AddState(state_idle_);
248 AddState(state_opening_);
249 AddState(state_opened_);
250 AddState(state_started_);
251 AddState(state_closing_);
252 SetInitialState(state_idle_);
253 }
254
Peer()255 BtifAvPeer& Peer() { return peer_; }
256
257 private:
258 BtifAvPeer& peer_;
259 StateIdle* state_idle_;
260 StateOpening* state_opening_;
261 StateOpened* state_opened_;
262 StateStarted* state_started_;
263 StateClosing* state_closing_;
264 };
265
266 class BtifAvPeer {
267 public:
268 enum {
269 kFlagLocalSuspendPending = 0x1,
270 kFlagRemoteSuspend = 0x2,
271 kFlagPendingStart = 0x4,
272 kFlagPendingStop = 0x8,
273 kFlagPendingReconfigure = 0x10,
274 };
275 static constexpr uint64_t kTimeoutAvOpenOnRcMs = 2 * 1000; // 2s
276
277 BtifAvPeer(const RawAddress& peer_address, uint8_t peer_sep, tBTA_AV_HNDL bta_handle,
278 uint8_t peer_id);
279 ~BtifAvPeer();
280
281 bt_status_t Init();
282 void Cleanup();
283
284 /**
285 * Check whether the peer can be deleted.
286 *
287 * @return true if the pair can be deleted, otherwise false
288 */
289 bool CanBeDeleted() const;
290
291 /**
292 * Check whether the peer is the active one.
293 *
294 * @return true if this peer is the active one
295 */
IsActivePeer() const296 bool IsActivePeer() const { return PeerAddress() == ActivePeerAddress(); }
297
298 /**
299 * Get the address of the active peer.
300 *
301 * @return the address of the active peer
302 */
303 const RawAddress& ActivePeerAddress() const;
304
PeerAddress() const305 const RawAddress& PeerAddress() const { return peer_address_; }
IsSource() const306 bool IsSource() const { return peer_sep_ == AVDT_TSEP_SRC; }
IsSink() const307 bool IsSink() const { return peer_sep_ == AVDT_TSEP_SNK; }
PeerSep() const308 uint8_t PeerSep() const { return peer_sep_; }
SetSep(uint8_t sep_type)309 void SetSep(uint8_t sep_type) { peer_sep_ = sep_type; }
310 /**
311 * Get the local device's Service Class UUID
312 *
313 * @return the local device's Service Class UUID: UUID_SERVCLASS_AUDIO_SOURCE
314 * or UUID_SERVCLASS_AUDIO_SINK
315 */
LocalUuidServiceClass() const316 uint16_t LocalUuidServiceClass() const {
317 return IsSink() ? UUID_SERVCLASS_AUDIO_SOURCE : UUID_SERVCLASS_AUDIO_SINK;
318 }
BtaHandle() const319 tBTA_AV_HNDL BtaHandle() const { return bta_handle_; }
SetBtaHandle(tBTA_AV_HNDL bta_handle)320 void SetBtaHandle(tBTA_AV_HNDL bta_handle) { bta_handle_ = bta_handle; }
PeerId() const321 uint8_t PeerId() const { return peer_id_; }
322
StateMachine()323 BtifAvStateMachine& StateMachine() { return state_machine_; }
StateMachine() const324 const BtifAvStateMachine& StateMachine() const { return state_machine_; }
AvOpenOnRcTimer()325 alarm_t* AvOpenOnRcTimer() { return av_open_on_rc_timer_; }
AvOpenOnRcTimer() const326 const alarm_t* AvOpenOnRcTimer() const { return av_open_on_rc_timer_; }
327
SetEdr(tBTA_AV_EDR edr)328 void SetEdr(tBTA_AV_EDR edr) { edr_ = edr; }
IsEdr() const329 bool IsEdr() const { return edr_ != 0; }
Is3Mbps() const330 bool Is3Mbps() const { return (edr_ & BTA_AV_EDR_3MBPS) != 0; }
331
332 bool IsConnected() const;
333 bool IsStreaming() const;
IsInSilenceMode() const334 bool IsInSilenceMode() const { return is_silenced_; }
335
SetSilence(bool silence)336 void SetSilence(bool silence) { is_silenced_ = silence; }
337
338 // AVDTP delay reporting in 1/10 milliseconds
SetDelayReport(uint16_t delay)339 void SetDelayReport(uint16_t delay) { delay_report_ = delay; }
GetDelayReport() const340 uint16_t GetDelayReport() const { return delay_report_; }
341
SetMandatoryCodecPreferred(bool preferred)342 void SetMandatoryCodecPreferred(bool preferred) { mandatory_codec_preferred_ = preferred; }
IsMandatoryCodecPreferred() const343 bool IsMandatoryCodecPreferred() const { return mandatory_codec_preferred_; }
344
345 /**
346 * Check whether any of the flags specified by the bitlags mask is set.
347 *
348 * @param bitflags_mask the bitflags to check
349 * @return true if any of the flags to check is set, otherwise false.
350 */
CheckFlags(uint8_t bitflags_mask) const351 bool CheckFlags(uint8_t bitflags_mask) const { return (flags_ & bitflags_mask) != 0; }
352
353 /**
354 * Set only the flags as specified by the bitflags mask.
355 *
356 * @param bitflags_mask the bitflags to set
357 */
SetFlags(uint8_t bitflags_mask)358 void SetFlags(uint8_t bitflags_mask) { flags_ |= bitflags_mask; }
359
360 /**
361 * Clear only the flags as specified by the bitflags mask.
362 *
363 * @param bitflags_mask the bitflags to clear
364 */
ClearFlags(uint8_t bitflags_mask)365 void ClearFlags(uint8_t bitflags_mask) { flags_ &= ~bitflags_mask; }
366
367 /**
368 * Clear all flags.
369 */
ClearAllFlags()370 void ClearAllFlags() { flags_ = 0; }
371
372 /**
373 * Get a string representation of the flags that are set.
374 */
375 std::string FlagsToString() const;
376
SelfInitiatedConnection() const377 bool SelfInitiatedConnection() const { return self_initiated_connection_; }
SetSelfInitiatedConnection(bool v)378 void SetSelfInitiatedConnection(bool v) { self_initiated_connection_ = v; }
379
UseLatencyMode() const380 bool UseLatencyMode() const { return use_latency_mode_; }
SetUseLatencyMode(bool use_latency_mode)381 void SetUseLatencyMode(bool use_latency_mode) { use_latency_mode_ = use_latency_mode; }
382
SetReconfigureStreamData(btif_av_reconfig_req_t && req)383 void SetReconfigureStreamData(btif_av_reconfig_req_t&& req) {
384 reconfig_req_ = std::make_optional<btif_av_reconfig_req_t>(std::move(req));
385 }
386
GetReconfigureStreamData()387 std::optional<btif_av_reconfig_req_t> GetReconfigureStreamData() {
388 std::optional<btif_av_reconfig_req_t> data = std::move(reconfig_req_);
389 reconfig_req_ = std::nullopt;
390 return data;
391 }
392
393 private:
394 const RawAddress peer_address_;
395 uint8_t peer_sep_; // SEP type of peer device
396 tBTA_AV_HNDL bta_handle_;
397 const uint8_t peer_id_;
398 BtifAvStateMachine state_machine_;
399 alarm_t* av_open_on_rc_timer_;
400 tBTA_AV_EDR edr_;
401 uint8_t flags_;
402 bool self_initiated_connection_;
403 bool is_silenced_;
404 uint16_t delay_report_;
405 bool mandatory_codec_preferred_ = false;
406 bool use_latency_mode_ = false;
407 std::optional<btif_av_reconfig_req_t> reconfig_req_;
408 };
409
410 class BtifAvSource {
411 public:
412 // The PeerId is used as AppId for BTA_AvRegister() purpose
413 static constexpr uint8_t kPeerIdMin = 0;
414 static constexpr uint8_t kPeerIdMax = BTA_AV_NUM_STRS;
415
BtifAvSource()416 BtifAvSource()
417 : callbacks_(nullptr),
418 enabled_(false),
419 a2dp_offload_enabled_(false),
420 max_connected_peers_(kDefaultMaxConnectedAudioDevices) {}
421 ~BtifAvSource();
422
423 void Init(btav_source_callbacks_t* callbacks, int max_connected_audio_devices,
424 const std::vector<btav_a2dp_codec_config_t>& codec_priorities,
425 const std::vector<btav_a2dp_codec_config_t>& offloading_preference,
426 std::vector<btav_a2dp_codec_info_t>* supported_codecs,
427 std::promise<bt_status_t> complete_promise);
428 void Cleanup();
429
Callbacks()430 btav_source_callbacks_t* Callbacks() { return callbacks_; }
Enabled() const431 bool Enabled() const { return enabled_; }
A2dpOffloadEnabled() const432 bool A2dpOffloadEnabled() const { return a2dp_offload_enabled_; }
433 BtifAvPeer* FindPeer(const RawAddress& peer_address);
434 BtifAvPeer* FindPeerByHandle(tBTA_AV_HNDL bta_handle);
435 BtifAvPeer* FindPeerByPeerId(uint8_t peer_id);
436 BtifAvPeer* FindOrCreatePeer(const RawAddress& peer_address, tBTA_AV_HNDL bta_handle);
437
438 /**
439 * Check whether a connection to a peer is allowed.
440 * The check considers the maximum number of connected peers.
441 *
442 * @param peer_address the peer address to connect to
443 * @return true if connection is allowed, otherwise false
444 */
445 bool AllowedToConnect(const RawAddress& peer_address) const;
446
447 /**
448 * Delete all peers that have transitioned to Idle state and can be deleted.
449 * If a peer was just created/initialized, then it cannot be deleted yet.
450 */
451 void DeleteIdlePeers();
452
453 /**
454 * Get the active peer.
455 *
456 * @return the active peer
457 */
ActivePeer() const458 const RawAddress& ActivePeer() const { return active_peer_; }
459
460 /**
461 * Check whether peer is silenced
462 *
463 * @param peer_address the peer to check
464 * @return true on silence mode enabled, otherwise false
465 */
IsPeerSilenced(const RawAddress & peer_address)466 bool IsPeerSilenced(const RawAddress& peer_address) {
467 if (peer_address.IsEmpty()) {
468 return false;
469 }
470 BtifAvPeer* peer = FindPeer(peer_address);
471 if (peer == nullptr) {
472 log::warn("peer is null");
473 return false;
474 }
475 if (!peer->IsConnected()) {
476 log::warn("peer is not connected");
477 return false;
478 }
479 return peer->IsInSilenceMode();
480 }
481
482 /**
483 * Set peer silence mode
484 *
485 * @param peer_address the peer to set
486 * @param silence true on enable silence mode, false on disable
487 * @return true on success, otherwise false
488 */
SetSilencePeer(const RawAddress & peer_address,const bool silence)489 bool SetSilencePeer(const RawAddress& peer_address, const bool silence) {
490 if (peer_address.IsEmpty()) {
491 return false;
492 }
493 log::info("peer: {}", peer_address);
494 BtifAvPeer* peer = FindPeer(peer_address);
495 if (peer == nullptr) {
496 log::warn("peer is null");
497 return false;
498 }
499 if (!peer->IsConnected()) {
500 log::warn("peer is not connected");
501 return false;
502 }
503 peer->SetSilence(silence);
504 return true;
505 }
506
507 /**
508 * Set the active peer.
509 *
510 * @param peer_address the active peer address or RawAddress::kEmpty to
511 * reset the active peer
512 * @return true on success, otherwise false
513 */
SetActivePeer(const RawAddress & peer_address,std::promise<void> peer_ready_promise)514 bool SetActivePeer(const RawAddress& peer_address, std::promise<void> peer_ready_promise) {
515 log::info("peer={} active_peer={}", peer_address, active_peer_);
516
517 if (active_peer_ == peer_address) {
518 peer_ready_promise.set_value();
519 return true; // Nothing has changed
520 }
521 if (peer_address.IsEmpty()) {
522 log::info("peer address is empty, shutdown the Audio source");
523 if (!bta_av_co_set_active_source_peer(peer_address)) {
524 log::warn("unable to set active peer to empty in BtaAvCo");
525 }
526
527 btif_a2dp_source_end_session(active_peer_);
528 std::promise<void> shutdown_complete_promise;
529 std::future<void> shutdown_complete_future = shutdown_complete_promise.get_future();
530 btif_a2dp_source_shutdown(std::move(shutdown_complete_promise));
531 using namespace std::chrono_literals;
532 if (shutdown_complete_future.wait_for(1s) == std::future_status::timeout) {
533 log::error("Timed out waiting for A2DP source shutdown to complete.");
534 }
535 active_peer_ = peer_address;
536 peer_ready_promise.set_value();
537 return true;
538 }
539
540 BtifAvPeer* peer = FindPeer(peer_address);
541 if (peer == nullptr || !peer->IsConnected()) {
542 log::error("Error setting {} as active Source peer", peer_address);
543 peer_ready_promise.set_value();
544 return false;
545 }
546
547 if (!btif_a2dp_source_restart_session(active_peer_, peer_address,
548 std::move(peer_ready_promise))) {
549 // cannot set promise but need to be handled within restart_session
550 return false;
551 }
552 active_peer_ = peer_address;
553 return true;
554 }
555
556 /**
557 * Update source codec configuration for a peer.
558 *
559 * @param peer_address the address of the peer to update
560 * @param codec_preferences the updated codec preferences
561 */
UpdateCodecConfig(const RawAddress & peer_address,const std::vector<btav_a2dp_codec_config_t> & codec_preferences,std::promise<void> peer_ready_promise)562 void UpdateCodecConfig(const RawAddress& peer_address,
563 const std::vector<btav_a2dp_codec_config_t>& codec_preferences,
564 std::promise<void> peer_ready_promise) {
565 // Restart the session if the codec for the active peer is updated
566 if (!peer_address.IsEmpty() && active_peer_ == peer_address) {
567 btif_a2dp_source_end_session(active_peer_);
568 }
569
570 btif_a2dp_source_encoder_user_config_update_req(peer_address, codec_preferences,
571 std::move(peer_ready_promise));
572 }
573
574 /**
575 * Get number of saved peers.
576 */
GetPeersCount() const577 int GetPeersCount() const {
578 std::lock_guard<std::recursive_mutex> lock(btifavsource_peers_lock_);
579 return peers_.size();
580 }
581
582 /**
583 * Dispatch SUSPEND or STOP A2DP stream event on all peer devices.
584 * Returns true if succeeded.
585 * @param event SUSPEND or STOP event
586 */
587 void DispatchSuspendStreamEvent(btif_av_sm_event_t event);
588
589 /**
590 * Set peer reconfigure stream data.
591 *
592 * @param peer_address the peer address to reconfigure stream
593 * @param codec_preferences codec preferences for stream reconfiguration
594 * @param reconf_ready_promise promise fulfilled when the reconfiguration done
595 */
SetPeerReconfigureStreamData(const RawAddress & peer_address,const std::vector<btav_a2dp_codec_config_t> & codec_preferences,std::promise<void> reconf_ready_promise)596 bt_status_t SetPeerReconfigureStreamData(const RawAddress& peer_address,
597 const std::vector<btav_a2dp_codec_config_t>& codec_preferences,
598 std::promise<void> reconf_ready_promise) {
599 std::lock_guard<std::recursive_mutex> lock(btifavsource_peers_lock_);
600
601 BtifAvPeer* peer = FindPeer(peer_address);
602 if (peer == nullptr) {
603 log::error("Can not find peer: {}", peer_address.ToString());
604 return BT_STATUS_NOT_READY;
605 }
606
607 btif_av_reconfig_req_t reconf_stream_req = {
608 .codec_preferences = codec_preferences,
609 .reconf_ready_promise = std::move(reconf_ready_promise),
610 };
611
612 peer->SetReconfigureStreamData(std::move(reconf_stream_req));
613 return BT_STATUS_SUCCESS;
614 }
615
616 void DumpPeersInfo(int fd);
617 void RegisterAllBtaHandles();
618 void DeregisterAllBtaHandles();
619 void BtaHandleRegistered(uint8_t peer_id, tBTA_AV_HNDL bta_handle);
620 BtifAvPeer* popPeer(const RawAddress& peer_address);
621 void AddPeer(BtifAvPeer* peer);
622
623 private:
624 void CleanupAllPeers();
625
626 btav_source_callbacks_t* callbacks_;
627 bool enabled_;
628 bool a2dp_offload_enabled_;
629 int max_connected_peers_;
630 std::map<RawAddress, BtifAvPeer*> peers_;
631 std::set<RawAddress> silenced_peers_;
632 RawAddress active_peer_;
633 std::map<uint8_t, tBTA_AV_HNDL> peer_id2bta_handle_;
634 // protect for BtifAvSource::peers_
635 mutable std::recursive_mutex btifavsource_peers_lock_;
636 };
637
638 class BtifAvSink {
639 public:
640 // The PeerId is used as AppId for BTA_AvRegister() purpose
641 static constexpr uint8_t kPeerIdMin = 0;
642 static constexpr uint8_t kPeerIdMax = BTA_AV_NUM_STRS;
643
BtifAvSink()644 BtifAvSink()
645 : callbacks_(nullptr),
646 enabled_(false),
647 max_connected_peers_(kDefaultMaxConnectedAudioDevices) {}
648 ~BtifAvSink();
649
650 void Init(btav_sink_callbacks_t* callbacks, int max_connected_audio_devices,
651 std::promise<bt_status_t> complete_promise);
652 void Cleanup();
653
Callbacks()654 btav_sink_callbacks_t* Callbacks() { return callbacks_; }
Enabled() const655 bool Enabled() const { return enabled_; }
656
657 BtifAvPeer* FindPeer(const RawAddress& peer_address);
658 BtifAvPeer* FindPeerByHandle(tBTA_AV_HNDL bta_handle);
659 BtifAvPeer* FindPeerByPeerId(uint8_t peer_id);
660 BtifAvPeer* FindOrCreatePeer(const RawAddress& peer_address, tBTA_AV_HNDL bta_handle);
661
662 /**
663 * Check whether a connection to a peer is allowed.
664 * The check considers the maximum number of connected peers.
665 *
666 * @param peer_address the peer address to connect to
667 * @return true if connection is allowed, otherwise false
668 */
669 bool AllowedToConnect(const RawAddress& peer_address) const;
670
671 /**
672 * Delete all peers that have transitioned to Idle state and can be deleted.
673 * If a peer was just created/initialized, then it cannot be deleted yet.
674 */
675 void DeleteIdlePeers();
676
677 /**
678 * Get the active peer.
679 *
680 * @return the active peer
681 */
ActivePeer() const682 const RawAddress& ActivePeer() const { return active_peer_; }
683
684 /**
685 * Set the active peer.
686 *
687 * @param peer_address the active peer address or RawAddress::kEmpty to
688 * reset the active peer
689 * @return true on success, otherwise false
690 */
SetActivePeer(const RawAddress & peer_address,std::promise<void> peer_ready_promise)691 bool SetActivePeer(const RawAddress& peer_address, std::promise<void> peer_ready_promise) {
692 log::info("peer={} active_peer={}", peer_address, active_peer_);
693
694 if (active_peer_ == peer_address) {
695 peer_ready_promise.set_value();
696 return true; // Nothing has changed
697 }
698 if (peer_address.IsEmpty()) {
699 log::verbose("peer address is empty, shutdown the Audio sink");
700 if (!bta_av_co_set_active_sink_peer(peer_address)) {
701 log::warn("unable to set active peer to empty in BtaAvCo");
702 }
703
704 btif_a2dp_sink_end_session(active_peer_);
705 btif_a2dp_sink_shutdown();
706 active_peer_ = peer_address;
707 peer_ready_promise.set_value();
708 return true;
709 }
710
711 BtifAvPeer* peer = FindPeer(peer_address);
712 if (peer == nullptr || !peer->IsConnected()) {
713 log::error("Error setting {} as active Sink peer", peer_address);
714 peer_ready_promise.set_value();
715 return false;
716 }
717
718 if (!btif_a2dp_sink_restart_session(active_peer_, peer_address,
719 std::move(peer_ready_promise))) {
720 // cannot set promise but need to be handled within restart_session
721 return false;
722 }
723 log::info("Setting the active peer to peer address {}", peer_address);
724 active_peer_ = peer_address;
725 return true;
726 }
727
728 /**
729 * Get number of saved peers.
730 */
GetPeersCount() const731 int GetPeersCount() const {
732 std::lock_guard<std::recursive_mutex> lock(btifavsink_peers_lock_);
733 return peers_.size();
734 }
735
736 void DumpPeersInfo(int fd);
737 void RegisterAllBtaHandles();
738 void DeregisterAllBtaHandles();
739 void BtaHandleRegistered(uint8_t peer_id, tBTA_AV_HNDL bta_handle);
740 BtifAvPeer* popPeer(const RawAddress& peer_address);
741 void AddPeer(BtifAvPeer* peer);
742
743 private:
744 void CleanupAllPeers();
745
746 btav_sink_callbacks_t* callbacks_;
747 bool enabled_;
748 int max_connected_peers_;
749 std::map<RawAddress, BtifAvPeer*> peers_;
750 RawAddress active_peer_;
751 std::map<uint8_t, tBTA_AV_HNDL> peer_id2bta_handle_;
752 // protect for BtifAvSink::peers_
753 mutable std::recursive_mutex btifavsink_peers_lock_;
754 };
755
756 /*****************************************************************************
757 * Static variables
758 *****************************************************************************/
759 static BtifAvSource btif_av_source;
760 static BtifAvSink btif_av_sink;
761
762 /* Helper macro to avoid code duplication in the state machine handlers */
763 #define CHECK_RC_EVENT(e, d) \
764 case BTA_AV_RC_OPEN_EVT: \
765 case BTA_AV_RC_BROWSE_OPEN_EVT: \
766 case BTA_AV_RC_CLOSE_EVT: \
767 case BTA_AV_RC_BROWSE_CLOSE_EVT: \
768 case BTA_AV_REMOTE_CMD_EVT: \
769 case BTA_AV_VENDOR_CMD_EVT: \
770 case BTA_AV_META_MSG_EVT: \
771 case BTA_AV_RC_FEAT_EVT: \
772 case BTA_AV_RC_PSM_EVT: \
773 case BTA_AV_REMOTE_RSP_EVT: { \
774 btif_rc_handler(e, d); \
775 } break;
776
777 static void btif_av_source_dispatch_sm_event(const RawAddress& peer_address,
778 btif_av_sm_event_t event);
779 static void btif_av_sink_dispatch_sm_event(const RawAddress& peer_address,
780 btif_av_sm_event_t event);
781 static void btif_av_handle_event(uint8_t peer_sep, const RawAddress& peer_address,
782 tBTA_AV_HNDL bta_handle, const BtifAvEvent& btif_av_event);
783 static void btif_debug_av_peer_dump(int fd, const BtifAvPeer& peer);
784 static void btif_report_connection_state(const RawAddress& peer_address,
785 btav_connection_state_t state, const bt_status_t status,
786 uint8_t error_code, const A2dpType local_a2dp_type);
787 static void btif_report_audio_state(const RawAddress& peer_address, btav_audio_state_t state,
788 const A2dpType local_a2dp_type);
789 static void btif_av_report_sink_audio_config_state(const RawAddress& peer_address, int sample_rate,
790 int channel_count);
791 static void btif_av_query_mandatory_codec_priority(const RawAddress& peer_address);
792 static void btif_av_source_initiate_av_open_timer_timeout(void* data);
793 static void btif_av_sink_initiate_av_open_timer_timeout(void* data);
794 static void bta_av_sink_media_callback(const RawAddress& peer_address, tBTA_AV_EVT event,
795 tBTA_AV_MEDIA* p_data);
796
btif_av_source_find_peer(const RawAddress & peer_address)797 static BtifAvPeer* btif_av_source_find_peer(const RawAddress& peer_address) {
798 return btif_av_source.FindPeer(peer_address);
799 }
800
btif_av_sink_find_peer(const RawAddress & peer_address)801 static BtifAvPeer* btif_av_sink_find_peer(const RawAddress& peer_address) {
802 return btif_av_sink.FindPeer(peer_address);
803 }
804
btif_av_find_peer(const RawAddress & peer_address,const A2dpType local_a2dp_type)805 static BtifAvPeer* btif_av_find_peer(const RawAddress& peer_address,
806 const A2dpType local_a2dp_type) {
807 if (btif_av_source.Enabled() && local_a2dp_type == A2dpType::kSource) {
808 BtifAvPeer* sourcePeer = btif_av_source_find_peer(peer_address);
809 if (sourcePeer != nullptr) {
810 return sourcePeer;
811 }
812 }
813 if (btif_av_sink.Enabled() && local_a2dp_type == A2dpType::kSink) {
814 BtifAvPeer* sinkPeer = btif_av_sink_find_peer(peer_address);
815 if (sinkPeer != nullptr) {
816 return sinkPeer;
817 }
818 }
819 if (btif_av_source.Enabled()) {
820 BtifAvPeer* sourcePeer = btif_av_source_find_peer(peer_address);
821 if (sourcePeer != nullptr) {
822 return sourcePeer;
823 }
824 }
825 if (btif_av_sink.Enabled()) {
826 BtifAvPeer* sinkPeer = btif_av_sink_find_peer(peer_address);
827 if (sinkPeer != nullptr) {
828 return sinkPeer;
829 }
830 }
831 log::info("Unable to find the peer {}", peer_address);
832 return nullptr;
833 }
834
btif_av_find_active_peer(const A2dpType local_a2dp_type)835 static BtifAvPeer* btif_av_find_active_peer(const A2dpType local_a2dp_type) {
836 if (btif_av_source.Enabled() && local_a2dp_type == A2dpType::kSource) {
837 return btif_av_source_find_peer(btif_av_source.ActivePeer());
838 }
839 if (btif_av_sink.Enabled() && local_a2dp_type == A2dpType::kSink) {
840 return btif_av_sink_find_peer(btif_av_sink.ActivePeer());
841 }
842 return nullptr;
843 }
844
btif_av_find_by_handle(tBTA_AV_HNDL bta_handle)845 const RawAddress& btif_av_find_by_handle(tBTA_AV_HNDL bta_handle) {
846 BtifAvPeer* peer = nullptr;
847 if (btif_av_both_enable()) {
848 peer = btif_av_source.FindPeerByHandle(bta_handle);
849 if (peer == nullptr) {
850 peer = btif_av_sink.FindPeerByHandle(bta_handle);
851 }
852 if (peer == nullptr) {
853 return RawAddress::kEmpty;
854 }
855
856 return peer->PeerAddress();
857 }
858 if (btif_av_source.Enabled()) {
859 peer = btif_av_source.FindPeerByHandle(bta_handle);
860 }
861 if (btif_av_sink.Enabled()) {
862 peer = btif_av_sink.FindPeerByHandle(bta_handle);
863 }
864
865 if (peer == nullptr) {
866 return RawAddress::kEmpty;
867 }
868
869 return peer->PeerAddress();
870 }
871
872 /*****************************************************************************
873 * Local helper functions
874 *****************************************************************************/
875
dump_av_sm_event_name(btif_av_sm_event_t event)876 static const char* dump_av_sm_event_name(btif_av_sm_event_t event) {
877 switch (static_cast<int>(event)) {
878 CASE_RETURN_STR(BTA_AV_ENABLE_EVT)
879 CASE_RETURN_STR(BTA_AV_REGISTER_EVT)
880 CASE_RETURN_STR(BTA_AV_OPEN_EVT)
881 CASE_RETURN_STR(BTA_AV_CLOSE_EVT)
882 CASE_RETURN_STR(BTA_AV_START_EVT)
883 CASE_RETURN_STR(BTA_AV_STOP_EVT)
884 CASE_RETURN_STR(BTA_AV_PROTECT_REQ_EVT)
885 CASE_RETURN_STR(BTA_AV_PROTECT_RSP_EVT)
886 CASE_RETURN_STR(BTA_AV_RC_OPEN_EVT)
887 CASE_RETURN_STR(BTA_AV_RC_CLOSE_EVT)
888 CASE_RETURN_STR(BTA_AV_RC_BROWSE_OPEN_EVT)
889 CASE_RETURN_STR(BTA_AV_RC_BROWSE_CLOSE_EVT)
890 CASE_RETURN_STR(BTA_AV_REMOTE_CMD_EVT)
891 CASE_RETURN_STR(BTA_AV_REMOTE_RSP_EVT)
892 CASE_RETURN_STR(BTA_AV_VENDOR_CMD_EVT)
893 CASE_RETURN_STR(BTA_AV_VENDOR_RSP_EVT)
894 CASE_RETURN_STR(BTA_AV_RECONFIG_EVT)
895 CASE_RETURN_STR(BTA_AV_SUSPEND_EVT)
896 CASE_RETURN_STR(BTA_AV_PENDING_EVT)
897 CASE_RETURN_STR(BTA_AV_META_MSG_EVT)
898 CASE_RETURN_STR(BTA_AV_REJECT_EVT)
899 CASE_RETURN_STR(BTA_AV_RC_FEAT_EVT)
900 CASE_RETURN_STR(BTA_AV_RC_PSM_EVT)
901 CASE_RETURN_STR(BTA_AV_OFFLOAD_START_RSP_EVT)
902 CASE_RETURN_STR(BTIF_AV_CONNECT_REQ_EVT)
903 CASE_RETURN_STR(BTIF_AV_DISCONNECT_REQ_EVT)
904 CASE_RETURN_STR(BTIF_AV_START_STREAM_REQ_EVT)
905 CASE_RETURN_STR(BTIF_AV_STOP_STREAM_REQ_EVT)
906 CASE_RETURN_STR(BTIF_AV_SUSPEND_STREAM_REQ_EVT)
907 CASE_RETURN_STR(BTIF_AV_SINK_CONFIG_REQ_EVT)
908 CASE_RETURN_STR(BTIF_AV_ACL_DISCONNECTED)
909 CASE_RETURN_STR(BTIF_AV_OFFLOAD_START_REQ_EVT)
910 CASE_RETURN_STR(BTIF_AV_AVRCP_OPEN_EVT)
911 CASE_RETURN_STR(BTIF_AV_AVRCP_CLOSE_EVT)
912 CASE_RETURN_STR(BTIF_AV_AVRCP_REMOTE_PLAY_EVT)
913 CASE_RETURN_STR(BTIF_AV_SET_LATENCY_REQ_EVT)
914 CASE_RETURN_STR(BTIF_AV_RECONFIGURE_REQ_EVT)
915 default:
916 return "UNKNOWN_EVENT";
917 }
918 }
919
BtifAvEvent(uint32_t event,const void * p_data,size_t data_length)920 BtifAvEvent::BtifAvEvent(uint32_t event, const void* p_data, size_t data_length)
921 : event_(event), data_(nullptr), data_length_(0) {
922 DeepCopy(event, p_data, data_length);
923 }
924
BtifAvEvent(const BtifAvEvent & other)925 BtifAvEvent::BtifAvEvent(const BtifAvEvent& other) : event_(0), data_(nullptr), data_length_(0) {
926 *this = other;
927 }
928
operator =(const BtifAvEvent & other)929 BtifAvEvent& BtifAvEvent::operator=(const BtifAvEvent& other) {
930 DeepFree();
931 DeepCopy(other.Event(), other.Data(), other.DataLength());
932 return *this;
933 }
934
~BtifAvEvent()935 BtifAvEvent::~BtifAvEvent() { DeepFree(); }
936
ToString() const937 std::string BtifAvEvent::ToString() const { return BtifAvEvent::EventName(event_); }
938
EventName(uint32_t event)939 std::string BtifAvEvent::EventName(uint32_t event) {
940 std::string name = dump_av_sm_event_name(static_cast<btif_av_sm_event_t>(event));
941 std::stringstream ss_value;
942 ss_value << "(0x" << std::hex << event << ")";
943 return name + ss_value.str();
944 }
945
DeepCopy(uint32_t event,const void * p_data,size_t data_length)946 void BtifAvEvent::DeepCopy(uint32_t event, const void* p_data, size_t data_length) {
947 event_ = event;
948 data_length_ = data_length;
949 if (data_length == 0) {
950 data_ = nullptr;
951 } else {
952 data_ = osi_malloc(data_length_);
953 memcpy(data_, p_data, data_length);
954 }
955
956 switch (event) {
957 case BTA_AV_META_MSG_EVT: {
958 log::assert_that(data_length >= sizeof(tBTA_AV),
959 "assert failed: data_length >= sizeof(tBTA_AV)");
960 const tBTA_AV* av_src = (const tBTA_AV*)p_data;
961 tBTA_AV* av_dest = reinterpret_cast<tBTA_AV*>(data_);
962 if (av_src->meta_msg.p_data && av_src->meta_msg.len) {
963 av_dest->meta_msg.p_data = reinterpret_cast<uint8_t*>(osi_calloc(av_src->meta_msg.len));
964 memcpy(av_dest->meta_msg.p_data, av_src->meta_msg.p_data, av_src->meta_msg.len);
965 }
966
967 if (av_src->meta_msg.p_msg) {
968 av_dest->meta_msg.p_msg = reinterpret_cast<tAVRC_MSG*>(osi_calloc(sizeof(tAVRC_MSG)));
969 memcpy(av_dest->meta_msg.p_msg, av_src->meta_msg.p_msg, sizeof(tAVRC_MSG));
970
971 tAVRC_MSG* p_msg_src = av_src->meta_msg.p_msg;
972 tAVRC_MSG* p_msg_dest = av_dest->meta_msg.p_msg;
973
974 if ((p_msg_src->hdr.opcode == AVRC_OP_VENDOR) &&
975 (p_msg_src->vendor.p_vendor_data && p_msg_src->vendor.vendor_len)) {
976 p_msg_dest->vendor.p_vendor_data =
977 reinterpret_cast<uint8_t*>(osi_calloc(p_msg_src->vendor.vendor_len));
978 memcpy(p_msg_dest->vendor.p_vendor_data, p_msg_src->vendor.p_vendor_data,
979 p_msg_src->vendor.vendor_len);
980 }
981 if ((p_msg_src->hdr.opcode == AVRC_OP_BROWSE) && p_msg_src->browse.p_browse_data &&
982 p_msg_src->browse.browse_len) {
983 p_msg_dest->browse.p_browse_data =
984 reinterpret_cast<uint8_t*>(osi_calloc(p_msg_src->browse.browse_len));
985 memcpy(p_msg_dest->browse.p_browse_data, p_msg_src->browse.p_browse_data,
986 p_msg_src->browse.browse_len);
987 }
988 }
989 } break;
990
991 default:
992 break;
993 }
994 }
995
DeepFree()996 void BtifAvEvent::DeepFree() {
997 switch (event_) {
998 case BTA_AV_META_MSG_EVT: {
999 tBTA_AV* av = reinterpret_cast<tBTA_AV*>(data_);
1000 osi_free(av->meta_msg.p_data);
1001 av->meta_msg.p_data = nullptr;
1002
1003 if (av->meta_msg.p_msg) {
1004 if (av->meta_msg.p_msg->hdr.opcode == AVRC_OP_VENDOR) {
1005 osi_free(av->meta_msg.p_msg->vendor.p_vendor_data);
1006 }
1007 if (av->meta_msg.p_msg->hdr.opcode == AVRC_OP_BROWSE) {
1008 osi_free(av->meta_msg.p_msg->browse.p_browse_data);
1009 }
1010 osi_free(av->meta_msg.p_msg);
1011 av->meta_msg.p_msg = nullptr;
1012 }
1013 } break;
1014
1015 default:
1016 break;
1017 }
1018
1019 osi_free(data_);
1020 data_ = nullptr;
1021 data_length_ = 0;
1022 }
1023
BtifAvPeer(const RawAddress & peer_address,uint8_t peer_sep,tBTA_AV_HNDL bta_handle,uint8_t peer_id)1024 BtifAvPeer::BtifAvPeer(const RawAddress& peer_address, uint8_t peer_sep, tBTA_AV_HNDL bta_handle,
1025 uint8_t peer_id)
1026 : peer_address_(peer_address),
1027 peer_sep_(peer_sep),
1028 bta_handle_(bta_handle),
1029 peer_id_(peer_id),
1030 state_machine_(*this),
1031 av_open_on_rc_timer_(nullptr),
1032 edr_(0),
1033 flags_(0),
1034 self_initiated_connection_(false),
1035 delay_report_(0) {}
1036
~BtifAvPeer()1037 BtifAvPeer::~BtifAvPeer() { alarm_free(av_open_on_rc_timer_); }
1038
FlagsToString() const1039 std::string BtifAvPeer::FlagsToString() const {
1040 std::string result;
1041
1042 if (flags_ & BtifAvPeer::kFlagLocalSuspendPending) {
1043 if (!result.empty()) {
1044 result += "|";
1045 }
1046 result += "LOCAL_SUSPEND_PENDING";
1047 }
1048 if (flags_ & BtifAvPeer::kFlagRemoteSuspend) {
1049 if (!result.empty()) {
1050 result += "|";
1051 }
1052 result += "REMOTE_SUSPEND";
1053 }
1054 if (flags_ & BtifAvPeer::kFlagPendingStart) {
1055 if (!result.empty()) {
1056 result += "|";
1057 }
1058 result += "PENDING_START";
1059 }
1060 if (flags_ & BtifAvPeer::kFlagPendingStop) {
1061 if (!result.empty()) {
1062 result += "|";
1063 }
1064 result += "PENDING_STOP";
1065 }
1066 if (flags_ & BtifAvPeer::kFlagPendingReconfigure) {
1067 if (!result.empty()) {
1068 result += "|";
1069 }
1070 result += "PENDING_RECONFIGURE";
1071 }
1072 if (result.empty()) {
1073 result = "None";
1074 }
1075
1076 return std::format("0x{:x}({})", flags_, result);
1077 }
1078
Init()1079 bt_status_t BtifAvPeer::Init() {
1080 alarm_free(av_open_on_rc_timer_);
1081 av_open_on_rc_timer_ = alarm_new("btif_av_peer.av_open_on_rc_timer");
1082 is_silenced_ = false;
1083
1084 state_machine_.Start();
1085 return BT_STATUS_SUCCESS;
1086 }
1087
Cleanup()1088 void BtifAvPeer::Cleanup() {
1089 state_machine_.Quit();
1090 alarm_free(av_open_on_rc_timer_);
1091 av_open_on_rc_timer_ = nullptr;
1092 }
1093
CanBeDeleted() const1094 bool BtifAvPeer::CanBeDeleted() const {
1095 return (state_machine_.StateId() == BtifAvStateMachine::kStateIdle) &&
1096 (state_machine_.PreviousStateId() != BtifAvStateMachine::kStateInvalid);
1097 }
1098
ActivePeerAddress() const1099 const RawAddress& BtifAvPeer::ActivePeerAddress() const {
1100 if (IsSource()) {
1101 return btif_av_sink.ActivePeer();
1102 }
1103 if (IsSink()) {
1104 return btif_av_source.ActivePeer();
1105 }
1106
1107 log::fatal("A2DP peer {} is neither Source nor Sink", PeerAddress());
1108 return RawAddress::kEmpty;
1109 }
1110
IsConnected() const1111 bool BtifAvPeer::IsConnected() const {
1112 int state = state_machine_.StateId();
1113 return (state == BtifAvStateMachine::kStateOpened) ||
1114 (state == BtifAvStateMachine::kStateStarted);
1115 }
1116
IsStreaming() const1117 bool BtifAvPeer::IsStreaming() const {
1118 int state = state_machine_.StateId();
1119 return state == BtifAvStateMachine::kStateStarted;
1120 }
1121
~BtifAvSource()1122 BtifAvSource::~BtifAvSource() { CleanupAllPeers(); }
1123
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,std::vector<btav_a2dp_codec_info_t> * supported_codecs,std::promise<bt_status_t> complete_promise)1124 void BtifAvSource::Init(btav_source_callbacks_t* callbacks, int max_connected_audio_devices,
1125 const std::vector<btav_a2dp_codec_config_t>& codec_priorities,
1126 const std::vector<btav_a2dp_codec_config_t>& offloading_preference,
1127 std::vector<btav_a2dp_codec_info_t>* supported_codecs,
1128 std::promise<bt_status_t> complete_promise) {
1129 callbacks_ = callbacks;
1130 max_connected_peers_ = max_connected_audio_devices;
1131 log::info("max_connected_audio_devices={}", max_connected_audio_devices);
1132
1133 Cleanup();
1134 CleanupAllPeers();
1135
1136 a2dp_offload_enabled_ = GetInterfaceToProfiles()->config->isA2DPOffloadEnabled();
1137 log::info("a2dp_offload.enable={}", a2dp_offload_enabled_);
1138
1139 if (a2dp_offload_enabled_) {
1140 tBTM_BLE_VSC_CB vsc_cb = {};
1141 BTM_BleGetVendorCapabilities(&vsc_cb);
1142 bool supports_a2dp_hw_offload_v2 =
1143 vsc_cb.version_supported >= 0x0104 && vsc_cb.a2dp_offload_v2_support;
1144 bluetooth::audio::a2dp::update_codec_offloading_capabilities(offloading_preference,
1145 supports_a2dp_hw_offload_v2);
1146 }
1147
1148 bta_av_co_init(codec_priorities, supported_codecs);
1149
1150 if (!btif_a2dp_source_init()) {
1151 complete_promise.set_value(BT_STATUS_FAIL);
1152 return;
1153 }
1154
1155 enabled_ = true;
1156 btif_enable_service(BTA_A2DP_SOURCE_SERVICE_ID);
1157 complete_promise.set_value(BT_STATUS_SUCCESS);
1158 }
1159
Cleanup()1160 void BtifAvSource::Cleanup() {
1161 log::info("");
1162 if (!enabled_) {
1163 return;
1164 }
1165 enabled_ = false;
1166
1167 btif_queue_cleanup(UUID_SERVCLASS_AUDIO_SOURCE);
1168
1169 std::promise<void> peer_ready_promise;
1170 btif_av_source.SetActivePeer(RawAddress::kEmpty, std::move(peer_ready_promise));
1171 btif_a2dp_source_cleanup();
1172
1173 btif_disable_service(BTA_A2DP_SOURCE_SERVICE_ID);
1174 CleanupAllPeers();
1175
1176 callbacks_ = nullptr;
1177 }
1178
FindPeer(const RawAddress & peer_address)1179 BtifAvPeer* BtifAvSource::FindPeer(const RawAddress& peer_address) {
1180 auto it = peers_.find(peer_address);
1181 if (it != peers_.end()) {
1182 return it->second;
1183 }
1184 return nullptr;
1185 }
1186
FindPeerByHandle(tBTA_AV_HNDL bta_handle)1187 BtifAvPeer* BtifAvSource::FindPeerByHandle(tBTA_AV_HNDL bta_handle) {
1188 std::lock_guard<std::recursive_mutex> lock(btifavsource_peers_lock_);
1189 for (auto it : peers_) {
1190 BtifAvPeer* peer = it.second;
1191 if (peer->BtaHandle() == bta_handle) {
1192 return peer;
1193 }
1194 }
1195 return nullptr;
1196 }
1197
FindPeerByPeerId(uint8_t peer_id)1198 BtifAvPeer* BtifAvSource::FindPeerByPeerId(uint8_t peer_id) {
1199 std::lock_guard<std::recursive_mutex> lock(btifavsource_peers_lock_);
1200 for (auto it : peers_) {
1201 BtifAvPeer* peer = it.second;
1202 if (peer->PeerId() == peer_id) {
1203 return peer;
1204 }
1205 }
1206 return nullptr;
1207 }
1208
FindOrCreatePeer(const RawAddress & peer_address,tBTA_AV_HNDL bta_handle)1209 BtifAvPeer* BtifAvSource::FindOrCreatePeer(const RawAddress& peer_address,
1210 tBTA_AV_HNDL bta_handle) {
1211 std::lock_guard<std::recursive_mutex> lock(btifavsource_peers_lock_);
1212 log::verbose("peer={} bta_handle=0x{:x}", peer_address, bta_handle);
1213
1214 BtifAvPeer* peer = FindPeer(peer_address);
1215 if (peer != nullptr) {
1216 return peer;
1217 }
1218
1219 // Find next availabie Peer ID to use
1220 uint8_t peer_id;
1221 for (peer_id = kPeerIdMin; peer_id < kPeerIdMax; peer_id++) {
1222 /* because the peer id may be in source cb and we cannot use it */
1223 if (btif_av_src_sink_coexist_enabled() && btif_av_both_enable()) {
1224 if (FindPeerByPeerId(peer_id) == nullptr &&
1225 btif_av_sink.FindPeerByPeerId(peer_id) == nullptr) {
1226 break;
1227 }
1228 } else {
1229 if (FindPeerByPeerId(peer_id) == nullptr) {
1230 break;
1231 }
1232 }
1233 }
1234 if (peer_id == kPeerIdMax) {
1235 log::error(
1236 "Cannot create peer for peer={} : cannot allocate unique Peer "
1237 "ID",
1238 peer_address);
1239 return nullptr;
1240 }
1241
1242 // Get the BTA Handle (if known)
1243 if (bta_handle == kBtaHandleUnknown) {
1244 auto it = peer_id2bta_handle_.find(peer_id);
1245 if (it == peer_id2bta_handle_.end() || it->second == kBtaHandleUnknown) {
1246 log::error(
1247 "Cannot create peer for peer={} : cannot convert Peer ID={} "
1248 "to unique BTA Handle",
1249 peer_address, peer_id);
1250 return nullptr;
1251 }
1252 bta_handle = it->second;
1253 }
1254
1255 log::info("Create peer: peer={} bta_handle=0x{:x} peer_id={}", peer_address, bta_handle, peer_id);
1256 peer = new BtifAvPeer(peer_address, AVDT_TSEP_SNK, bta_handle, peer_id);
1257 peers_.insert(std::make_pair(peer_address, peer));
1258 peer->Init();
1259 return peer;
1260 }
1261
AllowedToConnect(const RawAddress & peer_address) const1262 bool BtifAvSource::AllowedToConnect(const RawAddress& peer_address) const {
1263 std::lock_guard<std::recursive_mutex> lock(btifavsource_peers_lock_);
1264 int connected = 0;
1265
1266 // Count peers that are in the process of connecting or already connected
1267 for (auto it : peers_) {
1268 const BtifAvPeer* peer = it.second;
1269 switch (peer->StateMachine().StateId()) {
1270 case BtifAvStateMachine::kStateOpening:
1271 case BtifAvStateMachine::kStateOpened:
1272 case BtifAvStateMachine::kStateStarted:
1273 if (peer->PeerAddress() == peer_address) {
1274 return true; // Already connected or accounted for
1275 }
1276 connected++;
1277 break;
1278 default:
1279 break;
1280 }
1281 }
1282 const int sink_connected_peers_size = btif_av_sink.GetPeersCount();
1283 log::info("connected={}, max_connected_peers_={}, sink_connected_peers_size={}", connected,
1284 max_connected_peers_, btif_av_sink.GetPeersCount());
1285 return (connected + sink_connected_peers_size) < max_connected_peers_;
1286 }
1287
DumpPeersInfo(int fd)1288 void BtifAvSource::DumpPeersInfo(int fd) {
1289 std::lock_guard<std::recursive_mutex> lock(btifavsource_peers_lock_);
1290 for (auto it : peers_) {
1291 const BtifAvPeer* peer = it.second;
1292 if (peer != nullptr) {
1293 btif_debug_av_peer_dump(fd, *peer);
1294 }
1295 }
1296 }
1297
DispatchSuspendStreamEvent(btif_av_sm_event_t event)1298 void BtifAvSource::DispatchSuspendStreamEvent(btif_av_sm_event_t event) {
1299 std::lock_guard<std::recursive_mutex> lock(btifavsource_peers_lock_);
1300 if (event != BTIF_AV_SUSPEND_STREAM_REQ_EVT && event != BTIF_AV_STOP_STREAM_REQ_EVT) {
1301 log::error("Invalid event: {} id: {}", dump_av_sm_event_name(event), static_cast<int>(event));
1302 return;
1303 }
1304 bool av_stream_idle = true;
1305 for (auto it : peers_) {
1306 const BtifAvPeer* peer = it.second;
1307 if (peer->StateMachine().StateId() == BtifAvStateMachine::kStateStarted) {
1308 btif_av_source_dispatch_sm_event(peer->PeerAddress(), event);
1309 av_stream_idle = false;
1310 }
1311 }
1312
1313 if (av_stream_idle) {
1314 btif_a2dp_on_stopped(nullptr, A2dpType::kSource);
1315 }
1316 }
1317
DeleteIdlePeers()1318 void BtifAvSource::DeleteIdlePeers() {
1319 std::lock_guard<std::recursive_mutex> lock(btifavsource_peers_lock_);
1320 for (auto it = peers_.begin(); it != peers_.end();) {
1321 BtifAvPeer* peer = it->second;
1322 auto prev_it = it++;
1323 if (!peer->CanBeDeleted()) {
1324 continue;
1325 }
1326 log::info("peer={} bta_handle=0x{:x}", peer->PeerAddress(), peer->BtaHandle());
1327 peer->Cleanup();
1328 peers_.erase(prev_it);
1329 delete peer;
1330 }
1331 }
1332
CleanupAllPeers()1333 void BtifAvSource::CleanupAllPeers() {
1334 std::lock_guard<std::recursive_mutex> lock(btifavsource_peers_lock_);
1335 log::info("");
1336
1337 while (!peers_.empty()) {
1338 auto it = peers_.begin();
1339 BtifAvPeer* peer = it->second;
1340 peer->Cleanup();
1341 peers_.erase(it);
1342 delete peer;
1343 }
1344 }
1345
RegisterAllBtaHandles()1346 void BtifAvSource::RegisterAllBtaHandles() {
1347 for (int peer_id = kPeerIdMin; peer_id < kPeerIdMax; peer_id++) {
1348 BTA_AvRegister(BTA_AV_CHNL_AUDIO, kBtifAvSourceServiceName, peer_id, nullptr,
1349 UUID_SERVCLASS_AUDIO_SOURCE);
1350 }
1351 }
1352
DeregisterAllBtaHandles()1353 void BtifAvSource::DeregisterAllBtaHandles() {
1354 for (auto it : peer_id2bta_handle_) {
1355 tBTA_AV_HNDL bta_handle = it.second;
1356 BTA_AvDeregister(bta_handle);
1357 }
1358 peer_id2bta_handle_.clear();
1359 }
1360
BtaHandleRegistered(uint8_t peer_id,tBTA_AV_HNDL bta_handle)1361 void BtifAvSource::BtaHandleRegistered(uint8_t peer_id, tBTA_AV_HNDL bta_handle) {
1362 peer_id2bta_handle_.insert(std::make_pair(peer_id, bta_handle));
1363
1364 // Set the BTA Handle for the Peer (if exists)
1365 BtifAvPeer* peer = FindPeerByPeerId(peer_id);
1366 if (peer != nullptr && peer->BtaHandle() != bta_handle) {
1367 if (peer->BtaHandle() == kBtaHandleUnknown) {
1368 log::verbose("Assign peer: peer={} bta_handle=0x{:x} peer_id={}", peer->PeerAddress(),
1369 bta_handle, peer_id);
1370 } else {
1371 log::warn("Correct peer: peer={} bta_handle=0x{:x}->0x{:x} peer_id={}", peer->PeerAddress(),
1372 peer->BtaHandle(), bta_handle, peer_id);
1373 }
1374 peer->SetBtaHandle(bta_handle);
1375 }
1376 }
1377
popPeer(const RawAddress & peer_address)1378 BtifAvPeer* BtifAvSource::popPeer(const RawAddress& peer_address) {
1379 std::lock_guard<std::recursive_mutex> lock(btifavsource_peers_lock_);
1380 auto it = peers_.find(peer_address);
1381 if (it == peers_.end()) {
1382 return nullptr;
1383 }
1384 BtifAvPeer* peer = it->second;
1385 peers_.erase(it);
1386 log::info("peer={}, state={}", peer->PeerAddress(), peer->StateMachine().StateId());
1387 return peer;
1388 }
1389
AddPeer(BtifAvPeer * peer)1390 void BtifAvSource::AddPeer(BtifAvPeer* peer) {
1391 std::lock_guard<std::recursive_mutex> lock(btifavsource_peers_lock_);
1392 log::info("peer={}, state={}", peer->PeerAddress(), peer->StateMachine().StateId());
1393 peers_.insert(std::make_pair(peer->PeerAddress(), peer));
1394 }
~BtifAvSink()1395 BtifAvSink::~BtifAvSink() { CleanupAllPeers(); }
1396
Init(btav_sink_callbacks_t * callbacks,int max_connected_audio_devices,std::promise<bt_status_t> complete_promise)1397 void BtifAvSink::Init(btav_sink_callbacks_t* callbacks, int max_connected_audio_devices,
1398 std::promise<bt_status_t> complete_promise) {
1399 log::info("(max_connected_audio_devices={})", max_connected_audio_devices);
1400 Cleanup();
1401 CleanupAllPeers();
1402 max_connected_peers_ = max_connected_audio_devices;
1403 callbacks_ = callbacks;
1404
1405 /** source will have this configuration, but sink don't have, so don't
1406 * overwrite it. */
1407 if (!btif_av_source.Enabled()) {
1408 std::vector<btav_a2dp_codec_config_t> codec_priorities; // Default priorities
1409 std::vector<btav_a2dp_codec_info_t> supported_codecs;
1410 bta_av_co_init(codec_priorities, &supported_codecs);
1411 }
1412
1413 if (!btif_a2dp_sink_init()) {
1414 complete_promise.set_value(BT_STATUS_FAIL);
1415 return;
1416 }
1417 enabled_ = true;
1418 btif_enable_service(BTA_A2DP_SINK_SERVICE_ID);
1419 complete_promise.set_value(BT_STATUS_SUCCESS);
1420 }
1421
Cleanup()1422 void BtifAvSink::Cleanup() {
1423 log::info("");
1424 if (!enabled_) {
1425 return;
1426 }
1427 enabled_ = false;
1428
1429 btif_queue_cleanup(UUID_SERVCLASS_AUDIO_SINK);
1430
1431 std::promise<void> peer_ready_promise;
1432 btif_av_sink.SetActivePeer(RawAddress::kEmpty, std::move(peer_ready_promise));
1433 btif_a2dp_sink_cleanup();
1434
1435 btif_disable_service(BTA_A2DP_SINK_SERVICE_ID);
1436 CleanupAllPeers();
1437
1438 callbacks_ = nullptr;
1439 }
1440
FindPeer(const RawAddress & peer_address)1441 BtifAvPeer* BtifAvSink::FindPeer(const RawAddress& peer_address) {
1442 auto it = peers_.find(peer_address);
1443 if (it != peers_.end()) {
1444 return it->second;
1445 }
1446 return nullptr;
1447 }
1448
FindPeerByHandle(tBTA_AV_HNDL bta_handle)1449 BtifAvPeer* BtifAvSink::FindPeerByHandle(tBTA_AV_HNDL bta_handle) {
1450 std::lock_guard<std::recursive_mutex> lock(btifavsink_peers_lock_);
1451 for (auto it : peers_) {
1452 BtifAvPeer* peer = it.second;
1453 if (peer->BtaHandle() == bta_handle) {
1454 return peer;
1455 }
1456 }
1457 return nullptr;
1458 }
1459
FindPeerByPeerId(uint8_t peer_id)1460 BtifAvPeer* BtifAvSink::FindPeerByPeerId(uint8_t peer_id) {
1461 std::lock_guard<std::recursive_mutex> lock(btifavsink_peers_lock_);
1462 for (auto it : peers_) {
1463 BtifAvPeer* peer = it.second;
1464 if (peer->PeerId() == peer_id) {
1465 return peer;
1466 }
1467 }
1468 return nullptr;
1469 }
1470
FindOrCreatePeer(const RawAddress & peer_address,tBTA_AV_HNDL bta_handle)1471 BtifAvPeer* BtifAvSink::FindOrCreatePeer(const RawAddress& peer_address, tBTA_AV_HNDL bta_handle) {
1472 std::lock_guard<std::recursive_mutex> lock(btifavsink_peers_lock_);
1473 log::verbose("peer={} bta_handle=0x{:x}", peer_address, bta_handle);
1474
1475 BtifAvPeer* peer = FindPeer(peer_address);
1476 if (peer != nullptr) {
1477 return peer;
1478 }
1479
1480 // Find next availabie Peer ID to use
1481 uint8_t peer_id;
1482 for (peer_id = kPeerIdMin; peer_id < kPeerIdMax; peer_id++) {
1483 /* because the peer id may be in source cb and we cannot use it */
1484 if (btif_av_both_enable()) {
1485 if (FindPeerByPeerId(peer_id) == nullptr &&
1486 btif_av_source.FindPeerByPeerId(peer_id) == nullptr) {
1487 break;
1488 }
1489
1490 } else {
1491 if (FindPeerByPeerId(peer_id) == nullptr) {
1492 break;
1493 }
1494 }
1495 }
1496 if (peer_id == kPeerIdMax) {
1497 log::error(
1498 "Cannot create peer for peer={} : cannot allocate unique Peer "
1499 "ID",
1500 peer_address);
1501 return nullptr;
1502 }
1503
1504 // Get the BTA Handle (if known)
1505 if (bta_handle == kBtaHandleUnknown) {
1506 auto it = peer_id2bta_handle_.find(peer_id);
1507 if (it == peer_id2bta_handle_.end() || it->second == kBtaHandleUnknown) {
1508 log::error(
1509 "Cannot create peer for peer={} : cannot convert Peer ID={} "
1510 "to unique BTA Handle",
1511 peer_address, peer_id);
1512 return nullptr;
1513 }
1514 bta_handle = it->second;
1515 }
1516
1517 log::info("Create peer: peer={} bta_handle=0x{:x} peer_id={}", peer_address, bta_handle, peer_id);
1518 peer = new BtifAvPeer(peer_address, AVDT_TSEP_SRC, bta_handle, peer_id);
1519 peers_.insert(std::make_pair(peer_address, peer));
1520 peer->Init();
1521 return peer;
1522 }
1523
DumpPeersInfo(int fd)1524 void BtifAvSink::DumpPeersInfo(int fd) {
1525 std::lock_guard<std::recursive_mutex> lock(btifavsink_peers_lock_);
1526 for (auto it : peers_) {
1527 const BtifAvPeer* peer = it.second;
1528 if (peer != nullptr) {
1529 btif_debug_av_peer_dump(fd, *peer);
1530 }
1531 }
1532 }
1533
AllowedToConnect(const RawAddress & peer_address) const1534 bool BtifAvSink::AllowedToConnect(const RawAddress& peer_address) const {
1535 std::lock_guard<std::recursive_mutex> lock(btifavsink_peers_lock_);
1536 int connected = 0;
1537
1538 // Count peers that are in the process of connecting or already connected
1539 for (auto it : peers_) {
1540 const BtifAvPeer* peer = it.second;
1541 switch (peer->StateMachine().StateId()) {
1542 case BtifAvStateMachine::kStateOpening:
1543 case BtifAvStateMachine::kStateOpened:
1544 case BtifAvStateMachine::kStateStarted:
1545 if (peer->PeerAddress() == peer_address) {
1546 return true; // Already connected or accounted for
1547 }
1548 connected++;
1549 break;
1550 case BtifAvStateMachine::kStateClosing:
1551 case BtifAvStateMachine::kStateIdle:
1552 if ((btif_a2dp_sink_get_audio_track() != nullptr) &&
1553 (peer->PeerAddress() != peer_address)) {
1554 log::info("there is another peer with audio track({}), another={}, peer={}",
1555 std::format_ptr(btif_a2dp_sink_get_audio_track()), peer->PeerAddress(),
1556 peer_address);
1557 connected++;
1558 }
1559 break;
1560 default:
1561 break;
1562 }
1563 }
1564 const int source_connected_peers_size = btif_av_source.GetPeersCount();
1565 log::info("connected={}, max_connected_peers_={}, source_connected_peers_size={}", connected,
1566 max_connected_peers_, source_connected_peers_size);
1567 return (connected + source_connected_peers_size) < max_connected_peers_;
1568 }
1569
DeleteIdlePeers()1570 void BtifAvSink::DeleteIdlePeers() {
1571 std::lock_guard<std::recursive_mutex> lock(btifavsink_peers_lock_);
1572 for (auto it = peers_.begin(); it != peers_.end();) {
1573 BtifAvPeer* peer = it->second;
1574 auto prev_it = it++;
1575 if (!peer->CanBeDeleted()) {
1576 continue;
1577 }
1578 log::info("Deleting idle peer: {} bta_handle=0x{:x}", peer->PeerAddress(), peer->BtaHandle());
1579 peer->Cleanup();
1580 peers_.erase(prev_it);
1581 delete peer;
1582 }
1583 }
1584
CleanupAllPeers()1585 void BtifAvSink::CleanupAllPeers() {
1586 std::lock_guard<std::recursive_mutex> lock(btifavsink_peers_lock_);
1587 log::info("");
1588
1589 while (!peers_.empty()) {
1590 auto it = peers_.begin();
1591 BtifAvPeer* peer = it->second;
1592 peer->Cleanup();
1593 peers_.erase(it);
1594 delete peer;
1595 }
1596 }
1597
RegisterAllBtaHandles()1598 void BtifAvSink::RegisterAllBtaHandles() {
1599 for (int peer_id = kPeerIdMin; peer_id < kPeerIdMax; peer_id++) {
1600 BTA_AvRegister(BTA_AV_CHNL_AUDIO, kBtifAvSinkServiceName, peer_id, bta_av_sink_media_callback,
1601 UUID_SERVCLASS_AUDIO_SINK);
1602 }
1603 }
1604
DeregisterAllBtaHandles()1605 void BtifAvSink::DeregisterAllBtaHandles() {
1606 for (auto it : peer_id2bta_handle_) {
1607 tBTA_AV_HNDL bta_handle = it.second;
1608 BTA_AvDeregister(bta_handle);
1609 }
1610 peer_id2bta_handle_.clear();
1611 }
1612
BtaHandleRegistered(uint8_t peer_id,tBTA_AV_HNDL bta_handle)1613 void BtifAvSink::BtaHandleRegistered(uint8_t peer_id, tBTA_AV_HNDL bta_handle) {
1614 peer_id2bta_handle_.insert(std::make_pair(peer_id, bta_handle));
1615
1616 // Set the BTA Handle for the Peer (if exists)
1617 BtifAvPeer* peer = FindPeerByPeerId(peer_id);
1618 if (peer != nullptr && peer->BtaHandle() != bta_handle) {
1619 if (peer->BtaHandle() == kBtaHandleUnknown) {
1620 log::verbose("Assign peer: peer={} bta_handle=0x{:x} peer_id={}", peer->PeerAddress(),
1621 bta_handle, peer_id);
1622 } else {
1623 log::warn("Correct peer: peer={} bta_handle=0x{:x}->0x{:x} peer_id={}", peer->PeerAddress(),
1624 peer->BtaHandle(), bta_handle, peer_id);
1625 }
1626 peer->SetBtaHandle(bta_handle);
1627 }
1628 }
1629
popPeer(const RawAddress & peer_address)1630 BtifAvPeer* BtifAvSink::popPeer(const RawAddress& peer_address) {
1631 std::lock_guard<std::recursive_mutex> lock(btifavsink_peers_lock_);
1632 auto it = peers_.find(peer_address);
1633 if (it == peers_.end()) {
1634 return nullptr;
1635 }
1636 BtifAvPeer* peer = it->second;
1637 peers_.erase(it);
1638 log::info("peer={}, state={}", peer->PeerAddress(), peer->StateMachine().StateId());
1639 return peer;
1640 }
1641
AddPeer(BtifAvPeer * peer)1642 void BtifAvSink::AddPeer(BtifAvPeer* peer) {
1643 std::lock_guard<std::recursive_mutex> lock(btifavsink_peers_lock_);
1644 log::info("peer={}, state={}", peer->PeerAddress(), peer->StateMachine().StateId());
1645 peers_.insert(std::make_pair(peer->PeerAddress(), peer));
1646 }
1647
OnEnter()1648 void BtifAvStateMachine::StateIdle::OnEnter() {
1649 log::info("state=Idle peer={}", peer_.PeerAddress());
1650
1651 peer_.SetEdr(0);
1652 peer_.ClearAllFlags();
1653
1654 // Stop A2DP if this is the active peer
1655 if (peer_.IsActivePeer() || peer_.ActivePeerAddress().IsEmpty()) {
1656 btif_a2dp_on_idle(peer_.PeerAddress(), peer_.IsSource() ? A2dpType::kSink : A2dpType::kSource);
1657 }
1658
1659 // Reset the active peer if this was the active peer and
1660 // the Idle state was reentered
1661 if (peer_.IsActivePeer() && peer_.CanBeDeleted()) {
1662 std::promise<void> peer_ready_promise;
1663 if (peer_.IsSink()) {
1664 btif_av_source.SetActivePeer(RawAddress::kEmpty, std::move(peer_ready_promise));
1665 } else if (peer_.IsSource()) {
1666 btif_av_sink.SetActivePeer(RawAddress::kEmpty, std::move(peer_ready_promise));
1667 }
1668 }
1669
1670 // Delete peers that are re-entering the Idle state
1671 if (peer_.IsSink()) {
1672 do_in_main_thread(
1673 base::BindOnce(&BtifAvSource::DeleteIdlePeers, base::Unretained(&btif_av_source)));
1674 } else if (peer_.IsSource()) {
1675 do_in_main_thread(
1676 base::BindOnce(&BtifAvSink::DeleteIdlePeers, base::Unretained(&btif_av_sink)));
1677 }
1678 }
1679
OnExit()1680 void BtifAvStateMachine::StateIdle::OnExit() {
1681 log::info("state=Idle peer={}", peer_.PeerAddress());
1682 }
1683
ProcessEvent(uint32_t event,void * p_data)1684 bool BtifAvStateMachine::StateIdle::ProcessEvent(uint32_t event, void* p_data) {
1685 log::info("state=Idle peer={} event={} flags={} active_peer={}", peer_.PeerAddress(),
1686 BtifAvEvent::EventName(event), peer_.FlagsToString(), peer_.IsActivePeer());
1687
1688 switch (event) {
1689 case BTA_AV_ENABLE_EVT:
1690 break;
1691
1692 case BTIF_AV_STOP_STREAM_REQ_EVT:
1693 case BTIF_AV_SUSPEND_STREAM_REQ_EVT:
1694 case BTIF_AV_ACL_DISCONNECTED:
1695 // Ignore. Just re-enter Idle so the peer can be deleted
1696 peer_.StateMachine().TransitionTo(BtifAvStateMachine::kStateIdle);
1697 break;
1698
1699 case BTIF_AV_DISCONNECT_REQ_EVT:
1700 if (peer_.BtaHandle() != kBtaHandleUnknown) {
1701 BTA_AvClose(peer_.BtaHandle());
1702 if (peer_.IsSource()) {
1703 BTA_AvCloseRc(peer_.BtaHandle());
1704 }
1705 }
1706 // Re-enter Idle so the peer can be deleted
1707 peer_.StateMachine().TransitionTo(BtifAvStateMachine::kStateIdle);
1708 break;
1709
1710 case BTIF_AV_CONNECT_REQ_EVT:
1711 case BTA_AV_PENDING_EVT: {
1712 bool can_connect = true;
1713 peer_.SetSelfInitiatedConnection(event == BTIF_AV_CONNECT_REQ_EVT);
1714 // Check whether connection is allowed
1715 if (peer_.IsSink()) {
1716 can_connect = btif_av_source.AllowedToConnect(peer_.PeerAddress());
1717 if (!can_connect) {
1718 btif_av_source_disconnect(peer_.PeerAddress());
1719 }
1720 } else if (peer_.IsSource()) {
1721 can_connect = btif_av_sink.AllowedToConnect(peer_.PeerAddress());
1722 if (!can_connect) {
1723 btif_av_sink_disconnect(peer_.PeerAddress());
1724 }
1725 }
1726 if (!can_connect) {
1727 log::error("Cannot connect to peer {}: too many connected peers", peer_.PeerAddress());
1728 if (peer_.SelfInitiatedConnection()) {
1729 btif_queue_advance();
1730 }
1731 break;
1732 }
1733 btif_av_query_mandatory_codec_priority(peer_.PeerAddress());
1734 BTA_AvOpen(peer_.PeerAddress(), peer_.BtaHandle(), true, peer_.LocalUuidServiceClass());
1735 peer_.StateMachine().TransitionTo(BtifAvStateMachine::kStateOpening);
1736 if (event == BTIF_AV_CONNECT_REQ_EVT) {
1737 DEVICE_IOT_CONFIG_ADDR_SET_INT(
1738 peer_.PeerAddress(), IOT_CONF_KEY_A2DP_ROLE,
1739 (peer_.LocalUuidServiceClass() == UUID_SERVCLASS_AUDIO_SOURCE)
1740 ? IOT_CONF_VAL_A2DP_ROLE_SINK
1741 : IOT_CONF_VAL_A2DP_ROLE_SOURCE);
1742 DEVICE_IOT_CONFIG_ADDR_INT_ADD_ONE(peer_.PeerAddress(), IOT_CONF_KEY_A2DP_CONN_COUNT);
1743 } else if (event == BTA_AV_PENDING_EVT) {
1744 DEVICE_IOT_CONFIG_ADDR_INT_ADD_ONE(peer_.PeerAddress(), IOT_CONF_KEY_A2DP_CONN_COUNT);
1745 }
1746 } break;
1747 case BTIF_AV_AVRCP_OPEN_EVT:
1748 case BTA_AV_RC_OPEN_EVT: {
1749 // IOP_FIX: Jabra 620 only does AVRCP Open without AV Open whenever it
1750 // connects. So as per the AV WP, an AVRCP connection cannot exist
1751 // without an AV connection. Therefore, we initiate an AV connection
1752 // if an RC_OPEN_EVT is received when we are in AV_CLOSED state.
1753 // We initiate the AV connection after a small 3s timeout to avoid any
1754 // collisions from the headsets, as some headsets initiate the AVRCP
1755 // connection first and then immediately initiate the AV connection
1756 //
1757 // TODO: We may need to do this only on an AVRCP Play. FixMe
1758 log::warn("Peer {} : event={} received without AV", peer_.PeerAddress(),
1759 BtifAvEvent::EventName(event));
1760
1761 bool can_connect = true;
1762 // Check whether connection is allowed
1763 if (peer_.IsSink()) {
1764 can_connect = btif_av_source.AllowedToConnect(peer_.PeerAddress());
1765 if (!can_connect) {
1766 log::error("Source profile doesn't allow connection to peer:{}", peer_.PeerAddress());
1767 if (btif_av_src_sink_coexist_enabled()) {
1768 BTA_AvCloseRc((reinterpret_cast<tBTA_AV*>(p_data))->rc_open.rc_handle);
1769 } else {
1770 btif_av_source_disconnect(peer_.PeerAddress());
1771 }
1772 }
1773 } else if (peer_.IsSource()) {
1774 can_connect = btif_av_sink.AllowedToConnect(peer_.PeerAddress());
1775 if (!can_connect) {
1776 log::error("Sink profile doesn't allow connection to peer:{}", peer_.PeerAddress());
1777 if (btif_av_src_sink_coexist_enabled()) {
1778 BTA_AvCloseRc((reinterpret_cast<tBTA_AV*>(p_data))->rc_open.rc_handle);
1779 } else {
1780 btif_av_sink_disconnect(peer_.PeerAddress());
1781 }
1782 }
1783 }
1784 if (!can_connect) {
1785 log::error("Cannot connect to peer {}: too many connected peers", peer_.PeerAddress());
1786 break;
1787 }
1788 /* if peer is source, then start timer for sink connect to src */
1789 if (btif_av_src_sink_coexist_enabled()) {
1790 if (peer_.IsSource()) {
1791 alarm_set_on_mloop(peer_.AvOpenOnRcTimer(), BtifAvPeer::kTimeoutAvOpenOnRcMs,
1792 btif_av_sink_initiate_av_open_timer_timeout, &peer_);
1793 } else {
1794 alarm_set_on_mloop(peer_.AvOpenOnRcTimer(), BtifAvPeer::kTimeoutAvOpenOnRcMs,
1795 btif_av_source_initiate_av_open_timer_timeout, &peer_);
1796 }
1797 } else {
1798 if (btif_av_source.Enabled()) {
1799 alarm_set_on_mloop(peer_.AvOpenOnRcTimer(), BtifAvPeer::kTimeoutAvOpenOnRcMs,
1800 btif_av_source_initiate_av_open_timer_timeout, &peer_);
1801 } else if (btif_av_sink.Enabled()) {
1802 alarm_set_on_mloop(peer_.AvOpenOnRcTimer(), BtifAvPeer::kTimeoutAvOpenOnRcMs,
1803 btif_av_sink_initiate_av_open_timer_timeout, &peer_);
1804 }
1805 }
1806 if (event == BTA_AV_RC_OPEN_EVT) {
1807 btif_rc_handler(event, reinterpret_cast<tBTA_AV*>(p_data));
1808 }
1809 } break;
1810
1811 case BTA_AV_RC_BROWSE_OPEN_EVT:
1812 btif_rc_handler(event, reinterpret_cast<tBTA_AV*>(p_data));
1813 break;
1814
1815 // In case Signalling channel is not down and remote started Streaming
1816 // Procedure, we have to handle Config and Open event in Idle state.
1817 // We hit these scenarios while running PTS test case for AVRCP Controller.
1818 case BTIF_AV_SINK_CONFIG_REQ_EVT: {
1819 const btif_av_sink_config_req_t* p_config_req =
1820 static_cast<const btif_av_sink_config_req_t*>(p_data);
1821 btif_av_report_sink_audio_config_state(p_config_req->peer_address, p_config_req->sample_rate,
1822 p_config_req->channel_count);
1823 } break;
1824
1825 case BTA_AV_OPEN_EVT: {
1826 tBTA_AV* p_bta_data = reinterpret_cast<tBTA_AV*>(p_data);
1827 tBTA_AV_STATUS status = p_bta_data->open.status;
1828 bool can_connect = true;
1829
1830 log::info("Peer {} : event={} flags={} status={}({}) edr=0x{:x}", peer_.PeerAddress(),
1831 BtifAvEvent::EventName(event), peer_.FlagsToString(), status,
1832 (status == BTA_AV_SUCCESS) ? "SUCCESS" : "FAILED", p_bta_data->open.edr);
1833
1834 btif_report_connection_state(peer_.PeerAddress(), BTAV_CONNECTION_STATE_CONNECTING,
1835 bt_status_t::BT_STATUS_SUCCESS, BTA_AV_SUCCESS,
1836 peer_.IsSource() ? A2dpType::kSink : A2dpType::kSource);
1837
1838 if (p_bta_data->open.status == BTA_AV_SUCCESS) {
1839 peer_.SetEdr(p_bta_data->open.edr);
1840 if (btif_av_src_sink_coexist_enabled()) {
1841 log::verbose("Peer {} sep={}, open_sep={}", peer_.PeerAddress(), peer_.PeerSep(),
1842 p_bta_data->open.sep);
1843 /* if peer is wrong sep type, move it to BtifAvSxxx */
1844 if (peer_.PeerSep() != p_bta_data->open.sep) {
1845 BtifAvPeer* tmp_peer = nullptr;
1846 if (peer_.PeerSep() == AVDT_TSEP_SNK) {
1847 tmp_peer = btif_av_source.popPeer(peer_.PeerAddress());
1848
1849 if (peer_.PeerAddress() != tmp_peer->PeerAddress()) {
1850 log::error("error, not same peer");
1851 }
1852
1853 btif_av_sink.AddPeer(tmp_peer);
1854 } else {
1855 tmp_peer = btif_av_sink.popPeer(peer_.PeerAddress());
1856
1857 if (peer_.PeerAddress() != tmp_peer->PeerAddress()) {
1858 log::error("error, not same peer");
1859 }
1860
1861 btif_av_source.AddPeer(tmp_peer);
1862 }
1863 peer_.SetSep(p_bta_data->open.sep);
1864 }
1865 if (btif_rc_is_connected_peer(peer_.PeerAddress())) {
1866 log::verbose("AVRCP connected, update avrc sep");
1867 BTA_AvSetPeerSep(peer_.PeerAddress(), peer_.PeerSep());
1868 }
1869 btif_rc_check_pending_cmd(p_bta_data->open.bd_addr);
1870 }
1871 log::assert_that(peer_.PeerSep() == p_bta_data->open.sep,
1872 "assert failed: peer_.PeerSep() == p_bta_data->open.sep");
1873
1874 can_connect = peer_.IsSink() ? btif_av_source.AllowedToConnect(peer_.PeerAddress())
1875 : btif_av_sink.AllowedToConnect(peer_.PeerAddress());
1876
1877 if (!can_connect) {
1878 log::error("Cannot connect to peer {}: too many connected peers", peer_.PeerAddress());
1879
1880 if (peer_.IsSink()) {
1881 btif_av_source_disconnect(peer_.PeerAddress());
1882 } else if (peer_.IsSource()) {
1883 btif_av_sink_disconnect(peer_.PeerAddress());
1884 }
1885
1886 btif_report_connection_state(peer_.PeerAddress(), BTAV_CONNECTION_STATE_DISCONNECTED,
1887 bt_status_t::BT_STATUS_NOMEM, BTA_AV_FAIL_RESOURCES,
1888 peer_.IsSource() ? A2dpType::kSink : A2dpType::kSource);
1889 peer_.StateMachine().TransitionTo(BtifAvStateMachine::kStateIdle);
1890 } else {
1891 if (peer_.IsSource() && (p_bta_data->open.status == BTA_AV_SUCCESS)) {
1892 // Bring up AVRCP connection as well
1893 BTA_AvOpenRc(peer_.BtaHandle());
1894 }
1895 btif_report_connection_state(peer_.PeerAddress(), BTAV_CONNECTION_STATE_CONNECTED,
1896 bt_status_t::BT_STATUS_SUCCESS, BTA_AV_SUCCESS,
1897 peer_.IsSource() ? A2dpType::kSink : A2dpType::kSource);
1898 peer_.StateMachine().TransitionTo(BtifAvStateMachine::kStateOpened);
1899 }
1900 } else {
1901 btif_report_connection_state(peer_.PeerAddress(), BTAV_CONNECTION_STATE_DISCONNECTED,
1902 bt_status_t::BT_STATUS_FAIL, status,
1903 peer_.IsSource() ? A2dpType::kSink : A2dpType::kSource);
1904 peer_.StateMachine().TransitionTo(BtifAvStateMachine::kStateIdle);
1905 DEVICE_IOT_CONFIG_ADDR_INT_ADD_ONE(peer_.PeerAddress(), IOT_CONF_KEY_A2DP_CONN_FAIL_COUNT);
1906 }
1907 btif_queue_advance();
1908 } break;
1909
1910 case BTA_AV_REMOTE_CMD_EVT:
1911 case BTA_AV_VENDOR_CMD_EVT:
1912 case BTA_AV_META_MSG_EVT:
1913 case BTA_AV_RC_FEAT_EVT:
1914 case BTA_AV_RC_PSM_EVT:
1915 case BTA_AV_REMOTE_RSP_EVT:
1916 btif_rc_handler(event, reinterpret_cast<tBTA_AV*>(p_data));
1917 break;
1918
1919 case BTIF_AV_AVRCP_CLOSE_EVT:
1920 case BTA_AV_RC_CLOSE_EVT: {
1921 log::verbose("Peer {} : event={} : Stopping AV timer", peer_.PeerAddress(),
1922 BtifAvEvent::EventName(event));
1923 alarm_cancel(peer_.AvOpenOnRcTimer());
1924
1925 if (event == BTA_AV_RC_CLOSE_EVT) {
1926 btif_rc_handler(event, reinterpret_cast<tBTA_AV*>(p_data));
1927 }
1928 } break;
1929
1930 case BTIF_AV_OFFLOAD_START_REQ_EVT:
1931 log::error("Peer {} : event={}: stream is not Opened", peer_.PeerAddress(),
1932 BtifAvEvent::EventName(event));
1933 btif_a2dp_on_offload_started(peer_.PeerAddress(), BTA_AV_FAIL);
1934 break;
1935
1936 case BTIF_AV_RECONFIGURE_REQ_EVT: {
1937 // Unlock JNI thread only
1938 auto req_data = peer_.GetReconfigureStreamData();
1939 if (req_data) {
1940 req_data.value().reconf_ready_promise.set_value();
1941 }
1942 break;
1943 }
1944
1945 default:
1946 log::warn("Peer {} : Unhandled event={}", peer_.PeerAddress(), BtifAvEvent::EventName(event));
1947 return false;
1948 }
1949
1950 return true;
1951 }
1952
OnEnter()1953 void BtifAvStateMachine::StateOpening::OnEnter() {
1954 log::info("state=Opening peer={}", peer_.PeerAddress());
1955
1956 // Inform the application that we are entering connecting state
1957 if (btif_av_both_enable()) {
1958 /* if peer connect to us, don't know which role it is */
1959 if (!peer_.SelfInitiatedConnection()) {
1960 return;
1961 }
1962 }
1963 btif_report_connection_state(peer_.PeerAddress(), BTAV_CONNECTION_STATE_CONNECTING,
1964 bt_status_t::BT_STATUS_SUCCESS, BTA_AV_SUCCESS,
1965 peer_.IsSource() ? A2dpType::kSink : A2dpType::kSource);
1966 }
1967
OnExit()1968 void BtifAvStateMachine::StateOpening::OnExit() {
1969 log::info("state=Opening peer={}", peer_.PeerAddress());
1970 }
1971
ProcessEvent(uint32_t event,void * p_data)1972 bool BtifAvStateMachine::StateOpening::ProcessEvent(uint32_t event, void* p_data) {
1973 log::info("state=Opening peer={} event={} flags={} active_peer={}", peer_.PeerAddress(),
1974 BtifAvEvent::EventName(event), peer_.FlagsToString(), peer_.IsActivePeer());
1975
1976 switch (event) {
1977 case BTIF_AV_STOP_STREAM_REQ_EVT:
1978 case BTIF_AV_SUSPEND_STREAM_REQ_EVT:
1979 break; // Ignore
1980
1981 case BTIF_AV_ACL_DISCONNECTED:
1982 // ACL Disconnected needs to be handled only in Opening state, because
1983 // it is in an intermediate state. In other states we can handle
1984 // incoming/outgoing connect/disconnect requests.
1985 log::warn("Peer {} : event={}: transitioning to Idle due to ACL Disconnect",
1986 peer_.PeerAddress(), BtifAvEvent::EventName(event));
1987 bluetooth::shim::CountCounterMetrics(
1988 android::bluetooth::CodePathCounterKeyEnum::A2DP_CONNECTION_ACL_DISCONNECTED, 1);
1989 btif_report_connection_state(peer_.PeerAddress(), BTAV_CONNECTION_STATE_DISCONNECTED,
1990 bt_status_t::BT_STATUS_FAIL, BTA_AV_FAIL,
1991 peer_.IsSource() ? A2dpType::kSink : A2dpType::kSource);
1992 peer_.StateMachine().TransitionTo(BtifAvStateMachine::kStateIdle);
1993 if (peer_.SelfInitiatedConnection()) {
1994 btif_queue_advance();
1995 }
1996 break;
1997 case BTA_AV_REJECT_EVT:
1998 log::warn("Peer {} : event={} flags={}", peer_.PeerAddress(), BtifAvEvent::EventName(event),
1999 peer_.FlagsToString());
2000 bluetooth::shim::CountCounterMetrics(
2001 android::bluetooth::CodePathCounterKeyEnum::A2DP_CONNECTION_REJECT_EVT, 1);
2002 btif_report_connection_state(peer_.PeerAddress(), BTAV_CONNECTION_STATE_DISCONNECTED,
2003 bt_status_t::BT_STATUS_AUTH_REJECTED, BTA_AV_FAIL,
2004 peer_.IsSource() ? A2dpType::kSink : A2dpType::kSource);
2005 peer_.StateMachine().TransitionTo(BtifAvStateMachine::kStateIdle);
2006 if (peer_.SelfInitiatedConnection()) {
2007 btif_queue_advance();
2008 }
2009 break;
2010
2011 case BTA_AV_OPEN_EVT: {
2012 tBTA_AV* p_bta_data = reinterpret_cast<tBTA_AV*>(p_data);
2013 int av_state;
2014 tBTA_AV_STATUS status = p_bta_data->open.status;
2015
2016 log::info("Peer {} : event={} flags={} status={}({}) edr=0x{:x}", peer_.PeerAddress(),
2017 BtifAvEvent::EventName(event), peer_.FlagsToString(), status,
2018 (status == BTA_AV_SUCCESS) ? "SUCCESS" : "FAILED", p_bta_data->open.edr);
2019
2020 if (p_bta_data->open.status == BTA_AV_SUCCESS) {
2021 av_state = BtifAvStateMachine::kStateOpened;
2022 peer_.SetEdr(p_bta_data->open.edr);
2023 if (btif_av_src_sink_coexist_enabled()) {
2024 log::verbose("Peer {} sep={}, open_sep={}", peer_.PeerAddress(), peer_.PeerSep(),
2025 p_bta_data->open.sep);
2026 /* if peer is wrong sep type, move it to BtifAvSxxx */
2027 if (peer_.PeerSep() != p_bta_data->open.sep) {
2028 BtifAvPeer* tmp_peer = nullptr;
2029 if (peer_.PeerSep() == AVDT_TSEP_SNK) {
2030 tmp_peer = btif_av_source.popPeer(peer_.PeerAddress());
2031
2032 if (peer_.PeerAddress() != tmp_peer->PeerAddress()) {
2033 log::error("error, not same peer");
2034 }
2035
2036 btif_av_sink.AddPeer(tmp_peer);
2037 } else {
2038 tmp_peer = btif_av_sink.popPeer(peer_.PeerAddress());
2039
2040 if (peer_.PeerAddress() != tmp_peer->PeerAddress()) {
2041 log::error("error, not same peer");
2042 }
2043
2044 btif_av_source.AddPeer(tmp_peer);
2045 }
2046 peer_.SetSep(p_bta_data->open.sep);
2047 }
2048 if (btif_rc_is_connected_peer(peer_.PeerAddress())) {
2049 log::verbose("AVRCP connected, update avrc sep");
2050 BTA_AvSetPeerSep(peer_.PeerAddress(), peer_.PeerSep());
2051 }
2052 btif_rc_check_pending_cmd(p_bta_data->open.bd_addr);
2053 }
2054 log::assert_that(peer_.PeerSep() == p_bta_data->open.sep,
2055 "assert failed: peer_.PeerSep() == p_bta_data->open.sep");
2056 /** normally it can be checked in IDLE PENDING/CONNECT_REQ, in case:
2057 * 1 speacker connected to DUT and phone connect DUT, because
2058 * default
2059 * connect req is as SINK peer. only at here, we can know which
2060 * role
2061 * it is.@{ */
2062 if (btif_av_src_sink_coexist_enabled()) {
2063 bool can_connect = true;
2064 if (peer_.IsSink()) {
2065 can_connect = btif_av_source.AllowedToConnect(peer_.PeerAddress());
2066 if (!can_connect) {
2067 btif_av_source_disconnect(peer_.PeerAddress());
2068 }
2069 } else if (peer_.IsSource()) {
2070 can_connect = btif_av_sink.AllowedToConnect(peer_.PeerAddress());
2071 if (!can_connect) {
2072 btif_av_sink_disconnect(peer_.PeerAddress());
2073 }
2074 }
2075 }
2076 /** @} */
2077
2078 // Report the connection state to the application
2079 btif_report_connection_state(peer_.PeerAddress(), BTAV_CONNECTION_STATE_CONNECTED,
2080 bt_status_t::BT_STATUS_SUCCESS, BTA_AV_SUCCESS,
2081 peer_.IsSource() ? A2dpType::kSink : A2dpType::kSource);
2082 bluetooth::shim::CountCounterMetrics(
2083 android::bluetooth::CodePathCounterKeyEnum::A2DP_CONNECTION_SUCCESS, 1);
2084 } else {
2085 if (btif_rc_is_connected_peer(peer_.PeerAddress())) {
2086 // Disconnect the AVRCP connection, in case the A2DP connectiton
2087 // failed for any reason.
2088 log::warn("Peer {} : Disconnecting AVRCP", peer_.PeerAddress());
2089 uint8_t peer_handle = btif_rc_get_connected_peer_handle(peer_.PeerAddress());
2090 if (peer_handle != BTRC_HANDLE_NONE) {
2091 BTA_AvCloseRc(peer_handle);
2092 }
2093 DEVICE_IOT_CONFIG_ADDR_INT_ADD_ONE(peer_.PeerAddress(),
2094 IOT_CONF_KEY_A2DP_CONN_FAIL_COUNT);
2095 }
2096 av_state = BtifAvStateMachine::kStateIdle;
2097 // Report the connection state to the application
2098 btif_report_connection_state(peer_.PeerAddress(), BTAV_CONNECTION_STATE_DISCONNECTED,
2099 bt_status_t::BT_STATUS_FAIL, status,
2100 peer_.IsSource() ? A2dpType::kSink : A2dpType::kSource);
2101 bluetooth::shim::CountCounterMetrics(
2102 android::bluetooth::CodePathCounterKeyEnum::A2DP_CONNECTION_FAILURE, 1);
2103 }
2104
2105 // Change state to Open/Idle based on the status
2106 peer_.StateMachine().TransitionTo(av_state);
2107 if (peer_.IsSource() && (p_bta_data->open.status == BTA_AV_SUCCESS)) {
2108 // Bring up AVRCP connection as well
2109 if (btif_av_src_sink_coexist_enabled() &&
2110 btif_av_sink.AllowedToConnect(peer_.PeerAddress())) {
2111 BTA_AvOpenRc(peer_.BtaHandle());
2112 }
2113 }
2114 if (peer_.SelfInitiatedConnection()) {
2115 btif_queue_advance();
2116 }
2117 } break;
2118
2119 case BTIF_AV_SINK_CONFIG_REQ_EVT: {
2120 const btif_av_sink_config_req_t* p_config_req =
2121 static_cast<const btif_av_sink_config_req_t*>(p_data);
2122 /* before this point, we don't know it's role, actually peer is source */
2123 if (btif_av_both_enable()) {
2124 btif_av_report_sink_audio_config_state(
2125 p_config_req->peer_address, p_config_req->sample_rate, p_config_req->channel_count);
2126 break;
2127 }
2128 if (peer_.IsSource()) {
2129 btif_av_report_sink_audio_config_state(
2130 p_config_req->peer_address, p_config_req->sample_rate, p_config_req->channel_count);
2131 }
2132 } break;
2133
2134 case BTIF_AV_CONNECT_REQ_EVT: {
2135 // The device has moved already to Opening, hence don't report the
2136 // connection state.
2137 log::warn(
2138 "Peer {} : event={} : device is already connecting, ignore Connect "
2139 "request",
2140 peer_.PeerAddress(), BtifAvEvent::EventName(event));
2141 bluetooth::shim::CountCounterMetrics(
2142 android::bluetooth::CodePathCounterKeyEnum::A2DP_ALREADY_CONNECTING, 1);
2143 btif_queue_advance();
2144 } break;
2145
2146 case BTA_AV_PENDING_EVT: {
2147 // The device has moved already to Opening, hence don't report the
2148 // connection state.
2149 log::warn(
2150 "Peer {} : event={} : device is already connecting, ignore incoming "
2151 "request",
2152 peer_.PeerAddress(), BtifAvEvent::EventName(event));
2153 bluetooth::shim::CountCounterMetrics(
2154 android::bluetooth::CodePathCounterKeyEnum::A2DP_ALREADY_CONNECTING, 1);
2155 } break;
2156
2157 case BTIF_AV_OFFLOAD_START_REQ_EVT:
2158 log::error("Peer {} : event={}: stream is not Opened", peer_.PeerAddress(),
2159 BtifAvEvent::EventName(event));
2160 btif_a2dp_on_offload_started(peer_.PeerAddress(), BTA_AV_FAIL);
2161 bluetooth::shim::CountCounterMetrics(
2162 android::bluetooth::CodePathCounterKeyEnum::A2DP_OFFLOAD_START_REQ_FAILURE, 1);
2163 break;
2164
2165 case BTA_AV_CLOSE_EVT:
2166 btif_a2dp_on_stopped(nullptr, peer_.IsSource() ? A2dpType::kSink : A2dpType::kSource);
2167 btif_report_connection_state(peer_.PeerAddress(), BTAV_CONNECTION_STATE_DISCONNECTED,
2168 bt_status_t::BT_STATUS_FAIL, BTA_AV_FAIL,
2169 peer_.IsSource() ? A2dpType::kSink : A2dpType::kSource);
2170 peer_.StateMachine().TransitionTo(BtifAvStateMachine::kStateIdle);
2171 bluetooth::shim::CountCounterMetrics(
2172 android::bluetooth::CodePathCounterKeyEnum::A2DP_CONNECTION_CLOSE, 1);
2173 DEVICE_IOT_CONFIG_ADDR_INT_ADD_ONE(peer_.PeerAddress(), IOT_CONF_KEY_A2DP_CONN_FAIL_COUNT);
2174 if (peer_.SelfInitiatedConnection()) {
2175 btif_queue_advance();
2176 }
2177 break;
2178
2179 case BTIF_AV_DISCONNECT_REQ_EVT:
2180 BTA_AvClose(peer_.BtaHandle());
2181 btif_report_connection_state(peer_.PeerAddress(), BTAV_CONNECTION_STATE_DISCONNECTED,
2182 bt_status_t::BT_STATUS_FAIL, BTA_AV_FAIL,
2183 peer_.IsSource() ? A2dpType::kSink : A2dpType::kSource);
2184 peer_.StateMachine().TransitionTo(BtifAvStateMachine::kStateIdle);
2185 DEVICE_IOT_CONFIG_ADDR_INT_ADD_ONE(peer_.PeerAddress(), IOT_CONF_KEY_A2DP_CONN_FAIL_COUNT);
2186 bluetooth::shim::CountCounterMetrics(
2187 android::bluetooth::CodePathCounterKeyEnum::A2DP_CONNECTION_DISCONNECTED, 1);
2188 if (peer_.SelfInitiatedConnection()) {
2189 btif_queue_advance();
2190 }
2191 break;
2192
2193 case BTIF_AV_RECONFIGURE_REQ_EVT: {
2194 // Unlock JNI thread only
2195 auto req_data = peer_.GetReconfigureStreamData();
2196 if (req_data) {
2197 req_data.value().reconf_ready_promise.set_value();
2198 }
2199 break;
2200 }
2201
2202 CHECK_RC_EVENT(event, reinterpret_cast<tBTA_AV*>(p_data));
2203
2204 default:
2205 bluetooth::shim::CountCounterMetrics(
2206 android::bluetooth::CodePathCounterKeyEnum::A2DP_CONNECTION_UNKNOWN_EVENT, 1);
2207 log::warn("Peer {} : Unhandled event={}", peer_.PeerAddress(), BtifAvEvent::EventName(event));
2208 return false;
2209 }
2210 return true;
2211 }
2212
OnEnter()2213 void BtifAvStateMachine::StateOpened::OnEnter() {
2214 log::info("state=Opened peer={}", peer_.PeerAddress());
2215
2216 peer_.ClearFlags(BtifAvPeer::kFlagLocalSuspendPending | BtifAvPeer::kFlagPendingStart |
2217 BtifAvPeer::kFlagPendingStop);
2218
2219 // Set the active peer if the first connected device.
2220 // NOTE: This should be done only if we are A2DP Sink, because the A2DP Sink
2221 // implementation in Java doesn't support active devices (yet).
2222 // For A2DP Source, the setting of the Active device is done by the
2223 // ActiveDeviceManager in Java.
2224 if (peer_.IsSource() && btif_av_sink.ActivePeer().IsEmpty()) {
2225 std::promise<void> peer_ready_promise;
2226 if (!btif_av_sink.SetActivePeer(peer_.PeerAddress(), std::move(peer_ready_promise))) {
2227 log::error("Error setting {} as active Source peer", peer_.PeerAddress());
2228 }
2229 }
2230 }
2231
OnExit()2232 void BtifAvStateMachine::StateOpened::OnExit() {
2233 log::info("state=Opened peer={}", peer_.PeerAddress());
2234
2235 peer_.ClearFlags(BtifAvPeer::kFlagPendingStart);
2236 }
2237
ProcessEvent(uint32_t event,void * p_data)2238 bool BtifAvStateMachine::StateOpened::ProcessEvent(uint32_t event, void* p_data) {
2239 tBTA_AV* p_av = reinterpret_cast<tBTA_AV*>(p_data);
2240
2241 log::info("state=Opened peer={} event={} flags={} active_peer={}", peer_.PeerAddress(),
2242 BtifAvEvent::EventName(event), peer_.FlagsToString(), peer_.IsActivePeer());
2243
2244 if ((event == BTA_AV_REMOTE_CMD_EVT) && peer_.CheckFlags(BtifAvPeer::kFlagRemoteSuspend) &&
2245 (p_av->remote_cmd.rc_id == AVRC_ID_PLAY)) {
2246 log::verbose("Peer {} : Resetting remote suspend flag on RC PLAY", peer_.PeerAddress());
2247 peer_.ClearFlags(BtifAvPeer::kFlagRemoteSuspend);
2248 }
2249
2250 switch (event) {
2251 case BTIF_AV_STOP_STREAM_REQ_EVT:
2252 case BTIF_AV_SUSPEND_STREAM_REQ_EVT:
2253 case BTIF_AV_ACL_DISCONNECTED:
2254 break; // Ignore
2255
2256 // Event sent by the Bluetooth Audio HAL to a source A2DP stack
2257 // when a stream is ready to play. The stack shall send AVDTP Start to the
2258 // remote device to start the stream.
2259 case BTIF_AV_START_STREAM_REQ_EVT: {
2260 log::info("Peer {} : event={} flags={}", peer_.PeerAddress(), BtifAvEvent::EventName(event),
2261 peer_.FlagsToString());
2262 if (p_data) {
2263 const btif_av_start_stream_req_t* p_start_steam_req =
2264 static_cast<const btif_av_start_stream_req_t*>(p_data);
2265 log::info("Stream use_latency_mode={}", p_start_steam_req->use_latency_mode);
2266 peer_.SetUseLatencyMode(p_start_steam_req->use_latency_mode);
2267 }
2268
2269 BTA_AvStart(peer_.BtaHandle(), peer_.UseLatencyMode());
2270 peer_.SetFlags(BtifAvPeer::kFlagPendingStart);
2271 } break;
2272
2273 // Event sent by lower layer to indicate that the AVDTP stream is started.
2274 // May be initiated by the remote device to start a stream, in this case the
2275 // event is ignored by source A2DP, and the stack shall immediately suspend
2276 // the stream.
2277 case BTA_AV_START_EVT: {
2278 log::info("Peer {} : event={} status={} suspending={} initiator={} flags={}",
2279 peer_.PeerAddress(), BtifAvEvent::EventName(event), p_av->start.status,
2280 p_av->start.suspending, p_av->start.initiator, peer_.FlagsToString());
2281
2282 if ((p_av->start.status == BTA_SUCCESS) && p_av->start.suspending) {
2283 return true;
2284 }
2285
2286 // If remote tries to start A2DP when DUT is A2DP Source, then Suspend.
2287 // If A2DP is Sink and call is active, then disconnect the AVDTP
2288 // channel.
2289 bool should_suspend = false;
2290 if (peer_.IsSink()) {
2291 if (!peer_.CheckFlags(BtifAvPeer::kFlagPendingStart | BtifAvPeer::kFlagRemoteSuspend)) {
2292 log::warn("Peer {} : trigger Suspend as remote initiated", peer_.PeerAddress());
2293 should_suspend = true;
2294 } else if (!peer_.IsActivePeer()) {
2295 log::warn("Peer {} : trigger Suspend as non-active", peer_.PeerAddress());
2296 should_suspend = true;
2297 }
2298
2299 // Invoke the started handler only when initiator.
2300 if (!com::android::bluetooth::flags::a2dp_ignore_started_when_responder() ||
2301 peer_.CheckFlags(BtifAvPeer::kFlagPendingStart)) {
2302 if (btif_a2dp_on_started(peer_.PeerAddress(), &p_av->start, A2dpType::kSource)) {
2303 // Only clear pending flag after acknowledgement
2304 peer_.ClearFlags(BtifAvPeer::kFlagPendingStart);
2305 }
2306 }
2307 }
2308
2309 // Remain in Open state if status failed
2310 if (p_av->start.status != BTA_AV_SUCCESS) {
2311 return false;
2312 }
2313
2314 if (peer_.IsSource() && peer_.IsActivePeer()) {
2315 // Remove flush state, ready for streaming
2316 btif_a2dp_sink_set_rx_flush(false);
2317 btif_a2dp_sink_on_start();
2318 }
2319
2320 if (should_suspend) {
2321 btif_av_source_dispatch_sm_event(peer_.PeerAddress(), BTIF_AV_SUSPEND_STREAM_REQ_EVT);
2322 }
2323
2324 if (com::android::bluetooth::flags::av_stream_reconfigure_fix() &&
2325 peer_.CheckFlags(BtifAvPeer::kFlagPendingReconfigure)) {
2326 log::info(
2327 "Peer {} : Stream started but reconfiguration pending. "
2328 "Reconfiguring stream",
2329 peer_.PeerAddress());
2330 btif_av_source_dispatch_sm_event(peer_.PeerAddress(), BTIF_AV_RECONFIGURE_REQ_EVT);
2331 }
2332
2333 peer_.StateMachine().TransitionTo(BtifAvStateMachine::kStateStarted);
2334 break;
2335 }
2336
2337 case BTIF_AV_DISCONNECT_REQ_EVT:
2338 BTA_AvClose(peer_.BtaHandle());
2339 if (peer_.IsSource()) {
2340 BTA_AvCloseRc(peer_.BtaHandle());
2341 }
2342
2343 // Inform the application that we are disconnecting
2344 btif_report_connection_state(peer_.PeerAddress(), BTAV_CONNECTION_STATE_DISCONNECTING,
2345 bt_status_t::BT_STATUS_SUCCESS, BTA_AV_SUCCESS,
2346 peer_.IsSource() ? A2dpType::kSink : A2dpType::kSource);
2347
2348 // Wait in closing state until fully closed
2349 peer_.StateMachine().TransitionTo(BtifAvStateMachine::kStateClosing);
2350 break;
2351
2352 case BTA_AV_CLOSE_EVT:
2353 // AVDTP link is closed
2354 // Inform the application that we are disconnecting
2355 btif_report_connection_state(peer_.PeerAddress(), BTAV_CONNECTION_STATE_DISCONNECTING,
2356 bt_status_t::BT_STATUS_SUCCESS, BTA_AV_SUCCESS,
2357 peer_.IsSource() ? A2dpType::kSink : A2dpType::kSource);
2358 // Change state to Idle, send acknowledgement if start is pending
2359 if (peer_.CheckFlags(BtifAvPeer::kFlagPendingStart)) {
2360 log::warn("Peer {} : failed pending start request", peer_.PeerAddress());
2361 tBTA_AV_START av_start = {.chnl = p_av->close.chnl,
2362 .hndl = p_av->close.hndl,
2363 .status = BTA_AV_FAIL_STREAM,
2364 .initiator = true,
2365 .suspending = true};
2366 btif_a2dp_on_started(peer_.PeerAddress(), &av_start,
2367 peer_.IsSource() ? A2dpType::kSink : A2dpType::kSource);
2368 // Pending start flag will be cleared when exit current state
2369 } else if (peer_.IsActivePeer()) {
2370 btif_a2dp_on_stopped(nullptr, peer_.IsSource() ? A2dpType::kSink : A2dpType::kSource);
2371 }
2372
2373 // Inform the application that we are disconnected
2374 btif_report_connection_state(peer_.PeerAddress(), BTAV_CONNECTION_STATE_DISCONNECTED,
2375 bt_status_t::BT_STATUS_SUCCESS, BTA_AV_SUCCESS,
2376 peer_.IsSource() ? A2dpType::kSink : A2dpType::kSource);
2377 peer_.StateMachine().TransitionTo(BtifAvStateMachine::kStateIdle);
2378 break;
2379
2380 case BTA_AV_RECONFIG_EVT:
2381 if (p_av->reconfig.status != BTA_AV_SUCCESS) {
2382 log::warn("Peer {} : failed reconfiguration", peer_.PeerAddress());
2383 if (peer_.CheckFlags(BtifAvPeer::kFlagPendingStart)) {
2384 log::error("Peer {} : cannot proceed to do AvStart", peer_.PeerAddress());
2385 peer_.ClearFlags(BtifAvPeer::kFlagPendingStart);
2386 bluetooth::audio::a2dp::ack_stream_started(bluetooth::audio::a2dp::Status::FAILURE);
2387 }
2388 if (peer_.IsSink()) {
2389 btif_av_source_disconnect(peer_.PeerAddress());
2390 } else if (peer_.IsSource()) {
2391 btif_av_sink_disconnect(peer_.PeerAddress());
2392 }
2393 break;
2394 }
2395
2396 if (peer_.IsActivePeer()) {
2397 log::info("Peer {} : Reconfig done - calling startSession() to audio HAL",
2398 peer_.PeerAddress());
2399 std::promise<void> peer_ready_promise;
2400 std::future<void> peer_ready_future = peer_ready_promise.get_future();
2401
2402 // The stream may not be restarted without an explicit request from the
2403 // Bluetooth Audio HAL. Any start request that was pending before the
2404 // reconfiguration is invalidated when the session is ended.
2405 peer_.ClearFlags(BtifAvPeer::kFlagPendingStart);
2406
2407 btif_a2dp_source_start_session(peer_.PeerAddress(), std::move(peer_ready_promise));
2408 }
2409 if (peer_.CheckFlags(BtifAvPeer::kFlagPendingStart)) {
2410 log::info("Peer {} : Reconfig done - calling BTA_AvStart(0x{:x})", peer_.PeerAddress(),
2411 peer_.BtaHandle());
2412 BTA_AvStart(peer_.BtaHandle(), peer_.UseLatencyMode());
2413 }
2414 break;
2415
2416 case BTIF_AV_CONNECT_REQ_EVT: {
2417 log::warn("Peer {} : Ignore {} for same device", peer_.PeerAddress(),
2418 BtifAvEvent::EventName(event));
2419 btif_queue_advance();
2420 } break;
2421
2422 case BTIF_AV_OFFLOAD_START_REQ_EVT:
2423 log::error("Peer {} : event={}: stream is not Started", peer_.PeerAddress(),
2424 BtifAvEvent::EventName(event));
2425 btif_a2dp_on_offload_started(peer_.PeerAddress(), BTA_AV_FAIL);
2426 break;
2427
2428 case BTIF_AV_AVRCP_REMOTE_PLAY_EVT:
2429 if (peer_.CheckFlags(BtifAvPeer::kFlagRemoteSuspend)) {
2430 log::verbose("Peer {} : Resetting remote suspend flag on RC PLAY", peer_.PeerAddress());
2431 peer_.ClearFlags(BtifAvPeer::kFlagRemoteSuspend);
2432 }
2433 break;
2434
2435 CHECK_RC_EVENT(event, reinterpret_cast<tBTA_AV*>(p_data));
2436
2437 case BTIF_AV_SET_LATENCY_REQ_EVT: {
2438 const btif_av_set_latency_req_t* p_set_latency_req =
2439 static_cast<const btif_av_set_latency_req_t*>(p_data);
2440 log::info("Peer {} : event={} flags={} is_low_latency={}", peer_.PeerAddress(),
2441 BtifAvEvent::EventName(event), peer_.FlagsToString(),
2442 p_set_latency_req->is_low_latency);
2443
2444 BTA_AvSetLatency(peer_.BtaHandle(), p_set_latency_req->is_low_latency);
2445 } break;
2446
2447 case BTIF_AV_RECONFIGURE_REQ_EVT: {
2448 log::info("Peer {} : event={} flags={}", peer_.PeerAddress(), BtifAvEvent::EventName(event),
2449 peer_.FlagsToString());
2450 if (!peer_.IsSink()) {
2451 log::verbose("Peer {} is not sink", peer_.PeerAddress());
2452 break;
2453 }
2454
2455 if (peer_.CheckFlags(BtifAvPeer::kFlagPendingStart)) {
2456 // The start stream request was sent but we wait for response.
2457 // Enable the reconfigure pending flag to schedule reconfiguration
2458 // after start stream response.
2459 peer_.SetFlags(BtifAvPeer::kFlagPendingReconfigure);
2460 } else {
2461 // Reconfigure
2462 peer_.ClearFlags(BtifAvPeer::kFlagPendingReconfigure);
2463 if (btif_av_source.Enabled()) {
2464 auto req_data = peer_.GetReconfigureStreamData();
2465 if (req_data) {
2466 btif_av_source.UpdateCodecConfig(peer_.PeerAddress(),
2467 req_data.value().codec_preferences,
2468 std::move(req_data.value().reconf_ready_promise));
2469 }
2470 }
2471 }
2472 } break;
2473
2474 default:
2475 log::warn("Peer {} : Unhandled event={}", peer_.PeerAddress(), BtifAvEvent::EventName(event));
2476 return false;
2477 }
2478 return true;
2479 }
2480
OnEnter()2481 void BtifAvStateMachine::StateStarted::OnEnter() {
2482 log::info("state=Started peer={}", peer_.PeerAddress());
2483
2484 // We are again in started state, clear any remote suspend flags
2485 peer_.ClearFlags(BtifAvPeer::kFlagRemoteSuspend);
2486
2487 btif_a2dp_sink_set_rx_flush(false);
2488
2489 // Report that we have entered the Streaming stage. Usually, this should
2490 // be followed by focus grant. See set_audio_focus_state()
2491 btif_report_audio_state(peer_.PeerAddress(), BTAV_AUDIO_STATE_STARTED,
2492 peer_.IsSource() ? A2dpType::kSink : A2dpType::kSource);
2493 }
2494
OnExit()2495 void BtifAvStateMachine::StateStarted::OnExit() {
2496 log::info("state=Started peer={}", peer_.PeerAddress());
2497 }
2498
ProcessEvent(uint32_t event,void * p_data)2499 bool BtifAvStateMachine::StateStarted::ProcessEvent(uint32_t event, void* p_data) {
2500 tBTA_AV* p_av = reinterpret_cast<tBTA_AV*>(p_data);
2501
2502 log::info("state=Started peer={} event={} flags={} active_peer={}", peer_.PeerAddress(),
2503 BtifAvEvent::EventName(event), peer_.FlagsToString(), peer_.IsActivePeer());
2504
2505 switch (event) {
2506 case BTIF_AV_ACL_DISCONNECTED:
2507 break; // Ignore
2508
2509 case BTIF_AV_START_STREAM_REQ_EVT:
2510 log::info("Peer {} : event={} flags={}", peer_.PeerAddress(), BtifAvEvent::EventName(event),
2511 peer_.FlagsToString());
2512 // We were started remotely, just ACK back the local request
2513 if (peer_.IsSink()) {
2514 btif_a2dp_on_started(peer_.PeerAddress(), nullptr,
2515 peer_.IsSource() ? A2dpType::kSink : A2dpType::kSource);
2516 }
2517 break;
2518
2519 // FIXME -- use suspend = true always to work around issue with BTA AV
2520 case BTIF_AV_STOP_STREAM_REQ_EVT:
2521 case BTIF_AV_SUSPEND_STREAM_REQ_EVT:
2522 log::info("Peer {} : event={} flags={}", peer_.PeerAddress(), BtifAvEvent::EventName(event),
2523 peer_.FlagsToString());
2524
2525 // There is a pending LocalSuspend already, ignore.
2526 if (peer_.CheckFlags(BtifAvPeer::kFlagLocalSuspendPending)) {
2527 break;
2528 }
2529
2530 // Set pending flag to ensure the BTIF task is not trying to restart
2531 // the stream while suspend is in progress.
2532 peer_.SetFlags(BtifAvPeer::kFlagLocalSuspendPending);
2533
2534 // If we were remotely suspended but suspend locally, local suspend
2535 // always overrides.
2536 peer_.ClearFlags(BtifAvPeer::kFlagRemoteSuspend);
2537
2538 if (peer_.IsSink() &&
2539 (peer_.IsActivePeer() || !btif_av_stream_started_ready(A2dpType::kSource))) {
2540 // Immediately stop transmission of frames while suspend is pending
2541 if (event == BTIF_AV_STOP_STREAM_REQ_EVT) {
2542 btif_a2dp_on_stopped(nullptr, peer_.IsSource() ? A2dpType::kSink : A2dpType::kSource);
2543 } else {
2544 // ensure tx frames are immediately suspended
2545 btif_a2dp_source_set_tx_flush(true);
2546 }
2547 } else if (peer_.IsSource()) {
2548 btif_a2dp_on_stopped(nullptr, peer_.IsSource() ? A2dpType::kSink : A2dpType::kSource);
2549 }
2550 BTA_AvStop(peer_.BtaHandle(), true);
2551 break;
2552
2553 case BTIF_AV_DISCONNECT_REQ_EVT:
2554 log::info("Peer {} : event={} flags={}", peer_.PeerAddress(), BtifAvEvent::EventName(event),
2555 peer_.FlagsToString());
2556
2557 // Request AVDTP to close
2558 BTA_AvClose(peer_.BtaHandle());
2559 if (peer_.IsSource()) {
2560 BTA_AvCloseRc(peer_.BtaHandle());
2561 }
2562
2563 // Inform the application that we are disconnecting
2564 btif_report_connection_state(peer_.PeerAddress(), BTAV_CONNECTION_STATE_DISCONNECTING,
2565 bt_status_t::BT_STATUS_SUCCESS, BTA_AV_SUCCESS,
2566 peer_.IsSource() ? A2dpType::kSink : A2dpType::kSource);
2567
2568 // Wait in closing state until fully closed
2569 peer_.StateMachine().TransitionTo(BtifAvStateMachine::kStateClosing);
2570 break;
2571
2572 case BTA_AV_SUSPEND_EVT: {
2573 log::info("Peer {} : event={} status={} initiator={} flags={}", peer_.PeerAddress(),
2574 BtifAvEvent::EventName(event), p_av->suspend.status, p_av->suspend.initiator,
2575 peer_.FlagsToString());
2576
2577 // A2DP suspended, stop A2DP encoder / decoder until resumed
2578 if (peer_.IsActivePeer() ||
2579 !btif_av_stream_started_ready(peer_.IsSource() ? A2dpType::kSink : A2dpType::kSource)) {
2580 btif_a2dp_on_suspended(&p_av->suspend,
2581 peer_.IsSource() ? A2dpType::kSink : A2dpType::kSource);
2582 }
2583
2584 // If not successful, remain in current state
2585 if (p_av->suspend.status != BTA_AV_SUCCESS) {
2586 peer_.ClearFlags(BtifAvPeer::kFlagLocalSuspendPending);
2587
2588 if (peer_.IsSink() && peer_.IsActivePeer()) {
2589 // Suspend failed, reset back tx flush state
2590 btif_a2dp_source_set_tx_flush(false);
2591 }
2592 return false;
2593 }
2594
2595 btav_audio_state_t state = BTAV_AUDIO_STATE_REMOTE_SUSPEND;
2596 if (p_av->suspend.initiator != true) {
2597 // Remote suspend, notify HAL and await audioflinger to
2598 // suspend/stop stream.
2599 //
2600 // Set remote suspend flag to block media task from restarting
2601 // stream only if we did not already initiate a local suspend.
2602 if (!peer_.CheckFlags(BtifAvPeer::kFlagLocalSuspendPending)) {
2603 peer_.SetFlags(BtifAvPeer::kFlagRemoteSuspend);
2604 }
2605 } else {
2606 state = BTAV_AUDIO_STATE_STOPPED;
2607 }
2608
2609 btif_report_audio_state(peer_.PeerAddress(), state,
2610 peer_.IsSource() ? A2dpType::kSink : A2dpType::kSource);
2611 // Suspend completed, clear local pending flags while entering Opened
2612 peer_.StateMachine().TransitionTo(BtifAvStateMachine::kStateOpened);
2613 } break;
2614
2615 case BTA_AV_STOP_EVT:
2616 log::info("Peer {} : event={} flags={}", peer_.PeerAddress(), BtifAvEvent::EventName(event),
2617 peer_.FlagsToString());
2618
2619 peer_.SetFlags(BtifAvPeer::kFlagPendingStop);
2620 peer_.ClearFlags(BtifAvPeer::kFlagLocalSuspendPending);
2621
2622 // Don't change the encoder and audio provider state by a non-active
2623 // peer since they are shared between peers
2624 if (peer_.IsActivePeer() ||
2625 !btif_av_stream_started_ready(peer_.IsSource() ? A2dpType::kSink : A2dpType::kSource)) {
2626 btif_a2dp_on_stopped(&p_av->suspend,
2627 peer_.IsSource() ? A2dpType::kSink : A2dpType::kSource);
2628 }
2629
2630 btif_report_audio_state(peer_.PeerAddress(), BTAV_AUDIO_STATE_STOPPED,
2631 peer_.IsSource() ? A2dpType::kSink : A2dpType::kSource);
2632
2633 // If stop was successful, change state to Open
2634 if (p_av->suspend.status == BTA_AV_SUCCESS) {
2635 peer_.StateMachine().TransitionTo(BtifAvStateMachine::kStateOpened);
2636 }
2637
2638 break;
2639
2640 case BTA_AV_CLOSE_EVT:
2641 log::info("Peer {} : event={} flags={}", peer_.PeerAddress(), BtifAvEvent::EventName(event),
2642 peer_.FlagsToString());
2643 // Inform the application that we are disconnecting
2644 btif_report_connection_state(peer_.PeerAddress(), BTAV_CONNECTION_STATE_DISCONNECTING,
2645 bt_status_t::BT_STATUS_SUCCESS, BTA_AV_SUCCESS,
2646 peer_.IsSource() ? A2dpType::kSink : A2dpType::kSource);
2647
2648 peer_.SetFlags(BtifAvPeer::kFlagPendingStop);
2649
2650 // AVDTP link is closed
2651 if (peer_.IsActivePeer()) {
2652 btif_a2dp_on_stopped(nullptr, peer_.IsSource() ? A2dpType::kSink : A2dpType::kSource);
2653 }
2654
2655 // Inform the application that we are disconnected
2656 btif_report_connection_state(peer_.PeerAddress(), BTAV_CONNECTION_STATE_DISCONNECTED,
2657 bt_status_t::BT_STATUS_SUCCESS, BTA_AV_SUCCESS,
2658 peer_.IsSource() ? A2dpType::kSink : A2dpType::kSource);
2659
2660 peer_.StateMachine().TransitionTo(BtifAvStateMachine::kStateIdle);
2661 break;
2662
2663 case BTIF_AV_OFFLOAD_START_REQ_EVT:
2664 if (peer_.CheckFlags(BtifAvPeer::kFlagLocalSuspendPending | BtifAvPeer::kFlagRemoteSuspend |
2665 BtifAvPeer::kFlagPendingStop)) {
2666 log::warn("Peer {} : event={} flags={}: stream is Suspending", peer_.PeerAddress(),
2667 BtifAvEvent::EventName(event), peer_.FlagsToString());
2668 btif_a2dp_on_offload_started(peer_.PeerAddress(), BTA_AV_FAIL);
2669 break;
2670 }
2671 BTA_AvOffloadStart(peer_.BtaHandle());
2672 break;
2673
2674 case BTA_AV_OFFLOAD_START_RSP_EVT:
2675 btif_a2dp_on_offload_started(peer_.PeerAddress(), p_av->status);
2676 break;
2677
2678 case BTIF_AV_SET_LATENCY_REQ_EVT: {
2679 const btif_av_set_latency_req_t* p_set_latency_req =
2680 static_cast<const btif_av_set_latency_req_t*>(p_data);
2681 log::info("Peer {} : event={} flags={} is_low_latency={}", peer_.PeerAddress(),
2682 BtifAvEvent::EventName(event), peer_.FlagsToString(),
2683 p_set_latency_req->is_low_latency);
2684
2685 BTA_AvSetLatency(peer_.BtaHandle(), p_set_latency_req->is_low_latency);
2686 } break;
2687
2688 CHECK_RC_EVENT(event, reinterpret_cast<tBTA_AV*>(p_data));
2689
2690 case BTIF_AV_RECONFIGURE_REQ_EVT: {
2691 log::info("Peer {} : event={} flags={}", peer_.PeerAddress(), BtifAvEvent::EventName(event),
2692 peer_.FlagsToString());
2693 peer_.ClearFlags(BtifAvPeer::kFlagPendingReconfigure);
2694 if (btif_av_source.Enabled()) {
2695 auto req_data = peer_.GetReconfigureStreamData();
2696 if (req_data) {
2697 btif_av_source.UpdateCodecConfig(peer_.PeerAddress(), req_data.value().codec_preferences,
2698 std::move(req_data.value().reconf_ready_promise));
2699 }
2700 }
2701 } break;
2702
2703 default:
2704 log::warn("Peer {} : Unhandled event={}", peer_.PeerAddress(), BtifAvEvent::EventName(event));
2705 return false;
2706 }
2707
2708 return true;
2709 }
2710
OnEnter()2711 void BtifAvStateMachine::StateClosing::OnEnter() {
2712 log::info("state=Closing peer={}", peer_.PeerAddress());
2713
2714 if (peer_.IsActivePeer()) {
2715 if (peer_.IsSink()) {
2716 // Immediately stop transmission of frames
2717 btif_a2dp_source_set_tx_flush(true);
2718 // Wait for Audio Flinger to stop A2DP
2719 } else if (peer_.IsSource()) {
2720 btif_a2dp_sink_set_rx_flush(true);
2721 }
2722 }
2723 }
2724
OnExit()2725 void BtifAvStateMachine::StateClosing::OnExit() {
2726 log::info("state=Closing peer={}", peer_.PeerAddress());
2727 }
2728
ProcessEvent(uint32_t event,void * p_data)2729 bool BtifAvStateMachine::StateClosing::ProcessEvent(uint32_t event, void* p_data) {
2730 log::info("state=Closing peer={} event={} flags={} active_peer={}", peer_.PeerAddress(),
2731 BtifAvEvent::EventName(event), peer_.FlagsToString(), peer_.IsActivePeer());
2732
2733 switch (event) {
2734 case BTIF_AV_SUSPEND_STREAM_REQ_EVT:
2735 case BTIF_AV_ACL_DISCONNECTED:
2736 break; // Ignore
2737
2738 case BTA_AV_STOP_EVT:
2739 case BTIF_AV_STOP_STREAM_REQ_EVT:
2740 if (peer_.IsActivePeer()) {
2741 btif_a2dp_on_stopped(nullptr, peer_.IsSource() ? A2dpType::kSink : A2dpType::kSource);
2742 }
2743 break;
2744
2745 case BTA_AV_CLOSE_EVT:
2746 // Inform the application that we are disconnecting
2747 btif_report_connection_state(peer_.PeerAddress(), BTAV_CONNECTION_STATE_DISCONNECTED,
2748 bt_status_t::BT_STATUS_SUCCESS, BTA_AV_SUCCESS,
2749 peer_.IsSource() ? A2dpType::kSink : A2dpType::kSource);
2750
2751 peer_.StateMachine().TransitionTo(BtifAvStateMachine::kStateIdle);
2752 break;
2753
2754 // Handle the RC_CLOSE event for the cleanup
2755 case BTA_AV_RC_CLOSE_EVT:
2756 btif_rc_handler(event, reinterpret_cast<tBTA_AV*>(p_data));
2757 break;
2758
2759 // Handle the RC_BROWSE_CLOSE event for testing
2760 case BTA_AV_RC_BROWSE_CLOSE_EVT:
2761 btif_rc_handler(event, reinterpret_cast<tBTA_AV*>(p_data));
2762 break;
2763
2764 case BTIF_AV_OFFLOAD_START_REQ_EVT:
2765 log::error("Peer {} : event={}: stream is not Opened", peer_.PeerAddress(),
2766 BtifAvEvent::EventName(event));
2767 btif_a2dp_on_offload_started(peer_.PeerAddress(), BTA_AV_FAIL);
2768 break;
2769
2770 case BTIF_AV_CONNECT_REQ_EVT:
2771 log::warn("Peer {} : Ignore {} in StateClosing", peer_.PeerAddress(),
2772 BtifAvEvent::EventName(event));
2773 btif_queue_advance();
2774 peer_.StateMachine().TransitionTo(BtifAvStateMachine::kStateIdle);
2775 break;
2776
2777 case BTIF_AV_RECONFIGURE_REQ_EVT: {
2778 // Unlock JNI thread only
2779 auto req_data = peer_.GetReconfigureStreamData();
2780 if (req_data) {
2781 req_data.value().reconf_ready_promise.set_value();
2782 }
2783 break;
2784 }
2785
2786 default:
2787 log::warn("Peer {} : Unhandled event={}", peer_.PeerAddress(), BtifAvEvent::EventName(event));
2788 return false;
2789 }
2790 return true;
2791 }
2792
2793 /**
2794 * Timer to trigger AV Open on the Source if the remote Sink device
2795 * establishes AVRCP connection without AV connection. The timer is needed to
2796 * interoperate with headsets that do establish AV after AVRCP connection.
2797 */
btif_av_source_initiate_av_open_timer_timeout(void * data)2798 static void btif_av_source_initiate_av_open_timer_timeout(void* data) {
2799 BtifAvPeer* peer = reinterpret_cast<BtifAvPeer*>(data);
2800 bool device_connected = false;
2801
2802 if (is_new_avrcp_enabled()) {
2803 // check if device is connected
2804 if (bluetooth::avrcp::AvrcpService::Get() != nullptr) {
2805 device_connected =
2806 bluetooth::avrcp::AvrcpService::Get()->IsDeviceConnected(peer->PeerAddress());
2807 }
2808 } else {
2809 device_connected = btif_rc_is_connected_peer(peer->PeerAddress());
2810 }
2811
2812 log::verbose("Peer {}", peer->PeerAddress());
2813
2814 // Check if AVRCP is connected to the peer
2815 if (!device_connected) {
2816 log::error("AVRCP peer {} is not connected", peer->PeerAddress());
2817 return;
2818 }
2819
2820 // Connect to the AVRCP peer
2821 if (btif_av_source.Enabled() && btif_av_source.FindPeer(peer->PeerAddress()) == peer) {
2822 log::verbose("Connecting to AVRCP peer {}", peer->PeerAddress());
2823 btif_av_source_dispatch_sm_event(peer->PeerAddress(), BTIF_AV_CONNECT_REQ_EVT);
2824 }
2825 }
2826
2827 /**
2828 * Timer to trigger AV Open on the Sink if the remote Source device
2829 * establishes AVRCP connection without AV connection.
2830 */
btif_av_sink_initiate_av_open_timer_timeout(void * data)2831 static void btif_av_sink_initiate_av_open_timer_timeout(void* data) {
2832 BtifAvPeer* peer = reinterpret_cast<BtifAvPeer*>(data);
2833
2834 log::verbose("Peer {}", peer->PeerAddress());
2835
2836 // Check if AVRCP is connected to the peer
2837 if (!btif_rc_is_connected_peer(peer->PeerAddress())) {
2838 log::error("AVRCP peer {} is not connected", peer->PeerAddress());
2839 return;
2840 }
2841
2842 // Connect to the AVRCP peer
2843 if (btif_av_sink.Enabled() && btif_av_sink.FindPeer(peer->PeerAddress()) == peer) {
2844 log::verbose("Connecting to AVRCP peer {}", peer->PeerAddress());
2845 btif_av_sink_dispatch_sm_event(peer->PeerAddress(), BTIF_AV_CONNECT_REQ_EVT);
2846 }
2847 }
2848
2849 /**
2850 * Report the A2DP connection state
2851 *
2852 * @param peer_address the peer address
2853 * @param state the connection state
2854 */
btif_report_connection_state(const RawAddress & peer_address,btav_connection_state_t state,bt_status_t status,uint8_t error_code,const A2dpType local_a2dp_type)2855 static void btif_report_connection_state(const RawAddress& peer_address,
2856 btav_connection_state_t state, bt_status_t status,
2857 uint8_t error_code, const A2dpType local_a2dp_type) {
2858 log::info("peer={} state={}", peer_address, state);
2859 if (btif_av_src_sink_coexist_enabled() && btif_av_both_enable()) {
2860 BtifAvPeer* peer = btif_av_find_peer(peer_address, local_a2dp_type);
2861 if (peer == nullptr) {
2862 log::error("peer is null");
2863 return;
2864 }
2865
2866 if (peer->IsSink()) {
2867 do_in_jni_thread(base::BindOnce(btif_av_source.Callbacks()->connection_state_cb, peer_address,
2868 state, btav_error_t{}));
2869 } else if (peer->IsSource()) {
2870 do_in_jni_thread(base::BindOnce(btif_av_sink.Callbacks()->connection_state_cb, peer_address,
2871 state, btav_error_t{}));
2872 }
2873 return;
2874 }
2875
2876 if (btif_av_source.Enabled()) {
2877 do_in_jni_thread(base::BindOnce(btif_av_source.Callbacks()->connection_state_cb, peer_address,
2878 state,
2879 btav_error_t{.status = status, .error_code = error_code}));
2880 } else if (btif_av_sink.Enabled()) {
2881 do_in_jni_thread(base::BindOnce(btif_av_sink.Callbacks()->connection_state_cb, peer_address,
2882 state,
2883 btav_error_t{.status = status, .error_code = error_code}));
2884 }
2885 }
2886
2887 /**
2888 * Report the audio state of the A2DP connection.
2889 * The state is updated when either the remote ends starts streaming
2890 * (Started state) or whenever it transitions out of Started state
2891 * (to Opened or Streaming state).
2892 *
2893 * @param peer_address the peer address
2894 * @param state the audio state
2895 */
btif_report_audio_state(const RawAddress & peer_address,btav_audio_state_t state,const A2dpType local_a2dp_type)2896 static void btif_report_audio_state(const RawAddress& peer_address, btav_audio_state_t state,
2897 const A2dpType local_a2dp_type) {
2898 log::info("peer={} state={}", peer_address, state);
2899
2900 if (btif_av_both_enable()) {
2901 BtifAvPeer* peer = btif_av_find_peer(peer_address, local_a2dp_type);
2902 if (peer->IsSink()) {
2903 do_in_jni_thread(
2904 base::BindOnce(btif_av_source.Callbacks()->audio_state_cb, peer_address, state));
2905 } else if (peer->IsSource()) {
2906 do_in_jni_thread(
2907 base::BindOnce(btif_av_sink.Callbacks()->audio_state_cb, peer_address, state));
2908 }
2909 return;
2910 }
2911 if (btif_av_source.Enabled()) {
2912 do_in_jni_thread(
2913 base::BindOnce(btif_av_source.Callbacks()->audio_state_cb, peer_address, state));
2914 } else if (btif_av_sink.Enabled()) {
2915 do_in_jni_thread(base::BindOnce(btif_av_sink.Callbacks()->audio_state_cb, peer_address, state));
2916 }
2917
2918 using android::bluetooth::a2dp::AudioCodingModeEnum;
2919 using android::bluetooth::a2dp::PlaybackStateEnum;
2920 PlaybackStateEnum playback_state = PlaybackStateEnum::PLAYBACK_STATE_UNKNOWN;
2921 switch (state) {
2922 case BTAV_AUDIO_STATE_STARTED:
2923 playback_state = PlaybackStateEnum::PLAYBACK_STATE_PLAYING;
2924 break;
2925 case BTAV_AUDIO_STATE_STOPPED:
2926 playback_state = PlaybackStateEnum::PLAYBACK_STATE_NOT_PLAYING;
2927 break;
2928 default:
2929 break;
2930 }
2931 AudioCodingModeEnum audio_coding_mode = btif_av_is_a2dp_offload_running()
2932 ? AudioCodingModeEnum::AUDIO_CODING_MODE_HARDWARE
2933 : AudioCodingModeEnum::AUDIO_CODING_MODE_SOFTWARE;
2934
2935 bluetooth::shim::LogMetricA2dpPlaybackEvent(peer_address, playback_state, audio_coding_mode);
2936 }
2937
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)2938 void btif_av_report_source_codec_state(
2939 const RawAddress& peer_address, const btav_a2dp_codec_config_t& codec_config,
2940 const std::vector<btav_a2dp_codec_config_t>& codecs_local_capabilities,
2941 const std::vector<btav_a2dp_codec_config_t>& codecs_selectable_capabilities) {
2942 log::verbose("peer={}", peer_address);
2943 if (btif_av_source.Enabled()) {
2944 do_in_jni_thread(base::BindOnce(btif_av_source.Callbacks()->audio_config_cb, peer_address,
2945 codec_config, codecs_local_capabilities,
2946 codecs_selectable_capabilities));
2947 }
2948 }
2949
2950 /**
2951 * Report the audio config state of the A2DP Sink connection.
2952 *
2953 * @param peer_address the peer address
2954 * @param sample_rate the sample rate (in samples per second)
2955 * @param channel_count the channel count (1 for Mono, 2 for Stereo)
2956 */
btif_av_report_sink_audio_config_state(const RawAddress & peer_address,int sample_rate,int channel_count)2957 static void btif_av_report_sink_audio_config_state(const RawAddress& peer_address, int sample_rate,
2958 int channel_count) {
2959 log::info("peer={} sample_rate={} channel_count={}", peer_address, sample_rate, channel_count);
2960 if (btif_av_sink.Enabled()) {
2961 do_in_jni_thread(base::BindOnce(btif_av_sink.Callbacks()->audio_config_cb, peer_address,
2962 sample_rate, channel_count));
2963 }
2964 }
2965
2966 /**
2967 * Call out to JNI / JAVA layers to retrieve whether the mandatory codec is
2968 * more preferred than others.
2969 *
2970 * @param peer_address the peer address
2971 */
btif_av_query_mandatory_codec_priority(const RawAddress & peer_address)2972 static void btif_av_query_mandatory_codec_priority(const RawAddress& peer_address) {
2973 auto query_priority = [](const RawAddress& peer_address) {
2974 if (!btif_av_source.Enabled()) {
2975 log::warn("BTIF AV Source is not enabled");
2976 return;
2977 }
2978 btav_source_callbacks_t* callbacks = btif_av_source.Callbacks();
2979 bool preferred = callbacks != nullptr && callbacks->mandatory_codec_preferred_cb(peer_address);
2980 if (preferred) {
2981 auto apply_priority = [](const RawAddress& peer_address, bool preferred) {
2982 BtifAvPeer* peer = btif_av_find_peer(peer_address, A2dpType::kSource);
2983 if (peer == nullptr) {
2984 log::warn("btif_av_query_mandatory_codec_priority: peer is null");
2985 return;
2986 }
2987 peer->SetMandatoryCodecPreferred(preferred);
2988 };
2989 do_in_main_thread(base::BindOnce(apply_priority, peer_address, preferred));
2990 }
2991 };
2992 if (btif_av_source.Enabled()) {
2993 do_in_jni_thread(base::BindOnce(query_priority, peer_address));
2994 }
2995 }
2996
btif_av_handle_both_peer(uint8_t peer_sep,const RawAddress & peer_address,tBTA_AV_HNDL bta_handle)2997 static BtifAvPeer* btif_av_handle_both_peer(uint8_t peer_sep, const RawAddress& peer_address,
2998 tBTA_AV_HNDL bta_handle) {
2999 BtifAvPeer* peer = nullptr;
3000
3001 if (peer_address != RawAddress::kEmpty) {
3002 if (btif_av_both_enable()) {
3003 peer = btif_av_find_peer(peer_address, A2dpType::kUnknown);
3004 /* if no this peer, default it's sink device */
3005 if (peer == nullptr) {
3006 if (peer_sep == AVDT_TSEP_SRC) {
3007 log::verbose("peer_sep({}), create a new source peer", peer_sep);
3008 peer = btif_av_sink.FindOrCreatePeer(peer_address, bta_handle);
3009 } else if (peer_sep == AVDT_TSEP_SNK) {
3010 log::verbose("peer_sep({}), create a new sink peer", peer_sep);
3011 peer = btif_av_source.FindOrCreatePeer(peer_address, bta_handle);
3012 } else {
3013 if (btif_av_source.GetPeersCount() != 0) {
3014 log::verbose(
3015 "peer_sep invalid, and already has sink peer, so try create a "
3016 "new sink peer");
3017 peer = btif_av_source.FindOrCreatePeer(peer_address, bta_handle);
3018 } else if (btif_av_sink.GetPeersCount() != 0) {
3019 log::verbose(
3020 "peer_sep invalid, and already has source peer, so try create "
3021 "a new source peer");
3022 peer = btif_av_sink.FindOrCreatePeer(peer_address, bta_handle);
3023 } else {
3024 log::verbose(
3025 "peer_sep invalid, and no active peer, so try create a new "
3026 "sink peer");
3027 peer = btif_av_source.FindOrCreatePeer(peer_address, bta_handle);
3028 }
3029 }
3030 }
3031 } else {
3032 if (peer_sep == AVDT_TSEP_SNK) {
3033 log::verbose("peer_sep({}), only init src create a new source peer", peer_sep);
3034 peer = btif_av_source.FindOrCreatePeer(peer_address, bta_handle);
3035 } else if (peer_sep == AVDT_TSEP_SRC) {
3036 log::verbose("peer_sep({}), only init sink create a new source peer", peer_sep);
3037 peer = btif_av_sink.FindOrCreatePeer(peer_address, bta_handle);
3038 }
3039 }
3040 if (peer == NULL && bta_handle != 0) {
3041 if (peer_sep == AVDT_TSEP_SNK) {
3042 peer = btif_av_source.FindPeerByHandle(bta_handle);
3043 } else if (peer_sep == AVDT_TSEP_SRC) {
3044 peer = btif_av_sink.FindPeerByHandle(bta_handle);
3045 }
3046 log::verbose("peer is check 3");
3047 }
3048 } else if (bta_handle != 0) {
3049 if (peer_sep == AVDT_TSEP_INVALID) {
3050 peer = btif_av_source.FindPeerByHandle(bta_handle);
3051 /* if no this peer, default it's sink device */
3052 if (peer == nullptr) {
3053 peer = btif_av_sink.FindPeerByHandle(bta_handle);
3054 }
3055 } else if (peer_sep == AVDT_TSEP_SNK) {
3056 peer = btif_av_source.FindPeerByHandle(bta_handle);
3057 } else if (peer_sep == AVDT_TSEP_SRC) {
3058 peer = btif_av_sink.FindPeerByHandle(bta_handle);
3059 }
3060 }
3061 return peer;
3062 }
3063
3064 /**
3065 * Process BTIF or BTA AV or BTA AVRCP events. The processing is done on the
3066 * JNI thread.
3067 *
3068 * @param peer_sep the corresponding peer's SEP: AVDT_TSEP_SRC if the peer
3069 * is A2DP Source, or AVDT_TSEP_SNK if the peer is A2DP Sink.
3070 * @param peer_address the peer address if known, otherwise RawAddress::kEmpty
3071 * @param bta_handle the BTA handle for the peer if known, otherwise
3072 * kBtaHandleUnknown
3073 * @param btif_av_event the corresponding event
3074 */
btif_av_handle_event(uint8_t peer_sep,const RawAddress & peer_address,tBTA_AV_HNDL bta_handle,const BtifAvEvent & btif_av_event)3075 static void btif_av_handle_event(uint8_t peer_sep, const RawAddress& peer_address,
3076 tBTA_AV_HNDL bta_handle, const BtifAvEvent& btif_av_event) {
3077 log::info("peer={} handle=0x{:x} event={}", peer_address, bta_handle, btif_av_event.ToString());
3078
3079 BtifAvPeer* peer = nullptr;
3080
3081 // Find the peer
3082 if (btif_av_src_sink_coexist_enabled()) {
3083 peer = btif_av_handle_both_peer(peer_sep, peer_address, bta_handle);
3084 } else {
3085 if (peer_address != RawAddress::kEmpty) {
3086 if (peer_sep == AVDT_TSEP_SNK) {
3087 peer = btif_av_source.FindOrCreatePeer(peer_address, bta_handle);
3088 } else if (peer_sep == AVDT_TSEP_SRC) {
3089 peer = btif_av_sink.FindOrCreatePeer(peer_address, bta_handle);
3090 }
3091 } else if (bta_handle != kBtaHandleUnknown) {
3092 if (peer_sep == AVDT_TSEP_SNK) {
3093 peer = btif_av_source.FindPeerByHandle(bta_handle);
3094 } else if (peer_sep == AVDT_TSEP_SRC) {
3095 peer = btif_av_sink.FindPeerByHandle(bta_handle);
3096 }
3097 }
3098 }
3099 if (peer == nullptr) {
3100 log::error(
3101 "Cannot find or create {} peer for peer={} "
3102 "bta_handle=0x{:x} : event dropped: {}",
3103 peer_stream_endpoint_text(peer_sep), peer_address, bta_handle,
3104 btif_av_event.ToString());
3105 return;
3106 }
3107
3108 peer->StateMachine().ProcessEvent(btif_av_event.Event(), btif_av_event.Data());
3109 }
3110
3111 /**
3112 * Process BTA AV or BTA AVRCP events. The processing is done on the JNI
3113 * thread.
3114 *
3115 * @param peer_sep the corresponding peer's SEP: AVDT_TSEP_SRC if the peer
3116 * is A2DP Source, or AVDT_TSEP_SNK if the peer is A2DP Sink.
3117 * @param btif_av_event the corresponding event
3118 */
btif_av_handle_bta_av_event(uint8_t peer_sep,const BtifAvEvent & btif_av_event)3119 static void btif_av_handle_bta_av_event(uint8_t peer_sep, const BtifAvEvent& btif_av_event) {
3120 RawAddress peer_address = RawAddress::kEmpty;
3121 tBTA_AV_HNDL bta_handle = kBtaHandleUnknown;
3122 tBTA_AV_EVT event = btif_av_event.Event();
3123 tBTA_AV* p_data = reinterpret_cast<tBTA_AV*>(btif_av_event.Data());
3124 std::string msg;
3125
3126 log::verbose("peer_sep={} event={}", peer_stream_endpoint_text(peer_sep),
3127 btif_av_event.ToString());
3128
3129 switch (event) {
3130 case BTA_AV_ENABLE_EVT: {
3131 const tBTA_AV_ENABLE& enable = p_data->enable;
3132 log::verbose("Enable features=0x{:x}", enable.features);
3133 return; // Nothing to do
3134 }
3135 case BTA_AV_REGISTER_EVT: {
3136 const tBTA_AV_REGISTER& reg = p_data->reg;
3137 bta_handle = reg.hndl;
3138 uint8_t peer_id = reg.app_id; // The PeerId is used as AppId
3139 log::verbose("Register bta_handle=0x{:x} app_id={}", bta_handle, reg.app_id);
3140 if (btif_av_src_sink_coexist_enabled()) {
3141 if (peer_sep == AVDT_TSEP_INVALID) {
3142 if (reg.peer_sep == AVDT_TSEP_SNK) {
3143 peer_sep = AVDT_TSEP_SNK;
3144 } else {
3145 peer_sep = AVDT_TSEP_SRC;
3146 }
3147 }
3148 }
3149 if (peer_sep == AVDT_TSEP_SNK) {
3150 btif_av_source.BtaHandleRegistered(peer_id, bta_handle);
3151 } else if (peer_sep == AVDT_TSEP_SRC) {
3152 btif_av_sink.BtaHandleRegistered(peer_id, bta_handle);
3153 }
3154 return; // Nothing else to do
3155 }
3156 case BTA_AV_OPEN_EVT: {
3157 const tBTA_AV_OPEN& open = p_data->open;
3158 peer_address = open.bd_addr;
3159 bta_handle = open.hndl;
3160 msg = "Stream opened";
3161 break;
3162 }
3163 case BTA_AV_CLOSE_EVT: {
3164 const tBTA_AV_CLOSE& close = p_data->close;
3165 bta_handle = close.hndl;
3166 msg = "Stream closed";
3167 break;
3168 }
3169 case BTA_AV_START_EVT: {
3170 const tBTA_AV_START& start = p_data->start;
3171 bta_handle = start.hndl;
3172 msg = "Stream started";
3173 break;
3174 }
3175 case BTA_AV_SUSPEND_EVT:
3176 case BTA_AV_STOP_EVT: {
3177 const tBTA_AV_SUSPEND& suspend = p_data->suspend;
3178 bta_handle = suspend.hndl;
3179 msg = "Stream stopped";
3180 break;
3181 }
3182 case BTA_AV_PROTECT_REQ_EVT: {
3183 const tBTA_AV_PROTECT_REQ& protect_req = p_data->protect_req;
3184 bta_handle = protect_req.hndl;
3185 break;
3186 }
3187 case BTA_AV_PROTECT_RSP_EVT: {
3188 const tBTA_AV_PROTECT_RSP& protect_rsp = p_data->protect_rsp;
3189 bta_handle = protect_rsp.hndl;
3190 break;
3191 }
3192 case BTA_AV_RC_OPEN_EVT: {
3193 const tBTA_AV_RC_OPEN& rc_open = p_data->rc_open;
3194 peer_address = rc_open.peer_addr;
3195 break;
3196 }
3197 case BTA_AV_RC_CLOSE_EVT: {
3198 const tBTA_AV_RC_CLOSE& rc_close = p_data->rc_close;
3199 peer_address = rc_close.peer_addr;
3200 break;
3201 }
3202 case BTA_AV_RC_BROWSE_OPEN_EVT: {
3203 const tBTA_AV_RC_BROWSE_OPEN& rc_browse_open = p_data->rc_browse_open;
3204 peer_address = rc_browse_open.peer_addr;
3205 break;
3206 }
3207 case BTA_AV_RC_BROWSE_CLOSE_EVT: {
3208 const tBTA_AV_RC_BROWSE_CLOSE& rc_browse_close = p_data->rc_browse_close;
3209 peer_address = rc_browse_close.peer_addr;
3210 break;
3211 }
3212 case BTA_AV_REMOTE_CMD_EVT:
3213 case BTA_AV_REMOTE_RSP_EVT:
3214 case BTA_AV_VENDOR_CMD_EVT:
3215 case BTA_AV_VENDOR_RSP_EVT:
3216 case BTA_AV_META_MSG_EVT: {
3217 if (btif_av_src_sink_coexist_enabled()) {
3218 if (peer_sep == AVDT_TSEP_INVALID) {
3219 const tBTA_AV_REMOTE_CMD& rc_rmt_cmd = p_data->remote_cmd;
3220 btif_rc_get_addr_by_handle(rc_rmt_cmd.rc_handle, peer_address);
3221 if (peer_address == RawAddress::kEmpty) {
3222 peer_address = btif_av_source.ActivePeer();
3223 if (peer_address == RawAddress::kEmpty) {
3224 peer_address = btif_av_sink.ActivePeer();
3225 }
3226 }
3227 } else if (peer_sep == AVDT_TSEP_SNK) {
3228 peer_address = btif_av_source.ActivePeer();
3229 } else if (peer_sep == AVDT_TSEP_SRC) {
3230 peer_address = btif_av_sink.ActivePeer();
3231 }
3232 break;
3233 } else {
3234 [[fallthrough]];
3235 }
3236 }
3237 case BTA_AV_OFFLOAD_START_RSP_EVT: {
3238 // TODO: Might be wrong - this code will be removed once those
3239 // events are received from the AVRCP module.
3240 if (peer_sep == AVDT_TSEP_SNK) {
3241 peer_address = btif_av_source.ActivePeer();
3242 msg = "Stream sink offloaded";
3243 } else if (peer_sep == AVDT_TSEP_SRC) {
3244 peer_address = btif_av_sink.ActivePeer();
3245 msg = "Stream source offloaded";
3246 }
3247 break;
3248 }
3249 case BTA_AV_RECONFIG_EVT: {
3250 const tBTA_AV_RECONFIG& reconfig = p_data->reconfig;
3251 bta_handle = reconfig.hndl;
3252 break;
3253 }
3254 case BTA_AV_PENDING_EVT: {
3255 const tBTA_AV_PEND& pend = p_data->pend;
3256 peer_address = pend.bd_addr;
3257 break;
3258 }
3259 case BTA_AV_REJECT_EVT: {
3260 const tBTA_AV_REJECT& reject = p_data->reject;
3261 peer_address = reject.bd_addr;
3262 bta_handle = reject.hndl;
3263 break;
3264 }
3265 case BTA_AV_RC_FEAT_EVT: {
3266 const tBTA_AV_RC_FEAT& rc_feat = p_data->rc_feat;
3267 peer_address = rc_feat.peer_addr;
3268 break;
3269 }
3270 case BTA_AV_RC_PSM_EVT: {
3271 const tBTA_AV_RC_PSM& rc_psm = p_data->rc_cover_art_psm;
3272 peer_address = rc_psm.peer_addr;
3273 break;
3274 }
3275 }
3276
3277 if (!msg.empty()) {
3278 BTM_LogHistory(kBtmLogHistoryTag, peer_address, msg, btif_av_event.ToString());
3279 }
3280 btif_av_handle_event(peer_sep, peer_address, bta_handle, btif_av_event);
3281 }
3282
btif_av_both_enable(void)3283 bool btif_av_both_enable(void) { return btif_av_sink.Enabled() && btif_av_source.Enabled(); }
3284
is_a2dp_source_property_enabled(void)3285 static bool is_a2dp_source_property_enabled(void) {
3286 #ifdef __ANDROID__
3287 return android::sysprop::BluetoothProperties::isProfileA2dpSourceEnabled().value_or(false);
3288 #else
3289 return false;
3290 #endif
3291 }
3292
is_a2dp_sink_property_enabled(void)3293 static bool is_a2dp_sink_property_enabled(void) {
3294 #ifdef __ANDROID__
3295 return android::sysprop::BluetoothProperties::isProfileA2dpSinkEnabled().value_or(false);
3296 #else
3297 return false;
3298 #endif
3299 }
btif_av_src_sink_coexist_enabled(void)3300 bool btif_av_src_sink_coexist_enabled(void) {
3301 return is_a2dp_sink_property_enabled() && is_a2dp_source_property_enabled();
3302 }
3303
bta_av_source_callback(tBTA_AV_EVT event,tBTA_AV * p_data)3304 static void bta_av_source_callback(tBTA_AV_EVT event, tBTA_AV* p_data) {
3305 BtifAvEvent btif_av_event(event, p_data, sizeof(tBTA_AV));
3306 log::verbose("event={}", btif_av_event.ToString());
3307
3308 do_in_main_thread(base::BindOnce(&btif_av_handle_bta_av_event, AVDT_TSEP_SNK /* peer_sep */,
3309 btif_av_event));
3310 }
3311
bta_av_sink_callback(tBTA_AV_EVT event,tBTA_AV * p_data)3312 static void bta_av_sink_callback(tBTA_AV_EVT event, tBTA_AV* p_data) {
3313 BtifAvEvent btif_av_event(event, p_data, sizeof(tBTA_AV));
3314 do_in_main_thread(base::BindOnce(&btif_av_handle_bta_av_event, AVDT_TSEP_SRC /* peer_sep */,
3315 btif_av_event));
3316 }
3317
bta_av_event_callback(tBTA_AV_EVT event,tBTA_AV * p_data)3318 static void bta_av_event_callback(tBTA_AV_EVT event, tBTA_AV* p_data) {
3319 if (btif_av_both_enable()) {
3320 BtifAvEvent btif_av_event(event, p_data, sizeof(tBTA_AV));
3321 do_in_main_thread(base::BindOnce(&btif_av_handle_bta_av_event, AVDT_TSEP_INVALID /* peer_sep */,
3322 btif_av_event));
3323 return;
3324 }
3325
3326 if (btif_av_is_sink_enabled()) {
3327 return bta_av_sink_callback(event, p_data);
3328 }
3329
3330 return bta_av_source_callback(event, p_data);
3331 }
3332
3333 // 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)3334 static void bta_av_sink_media_callback(const RawAddress& peer_address, tBTA_AV_EVT event,
3335 tBTA_AV_MEDIA* p_data) {
3336 log::verbose("event={} peer {}", event, peer_address);
3337
3338 switch (event) {
3339 case BTA_AV_SINK_MEDIA_DATA_EVT: {
3340 BtifAvPeer* peer = btif_av_sink_find_peer(peer_address);
3341 if (peer != nullptr && peer->IsActivePeer()) {
3342 int state = peer->StateMachine().StateId();
3343 if ((state == BtifAvStateMachine::kStateStarted) ||
3344 (state == BtifAvStateMachine::kStateOpened)) {
3345 uint8_t queue_len = btif_a2dp_sink_enqueue_buf(reinterpret_cast<BT_HDR*>(p_data));
3346 log::verbose("Packets in Sink queue {}", queue_len);
3347 }
3348 }
3349 break;
3350 }
3351 case BTA_AV_SINK_MEDIA_CFG_EVT: {
3352 btif_av_sink_config_req_t config_req;
3353
3354 log::verbose("address={}", p_data->avk_config.bd_addr);
3355
3356 // Update the codec info of the A2DP Sink decoder
3357 btif_a2dp_sink_update_decoder(p_data->avk_config.bd_addr,
3358 reinterpret_cast<uint8_t*>(p_data->avk_config.codec_info));
3359
3360 config_req.sample_rate = A2DP_GetTrackSampleRate(p_data->avk_config.codec_info);
3361 if (config_req.sample_rate == -1) {
3362 log::error("Cannot get the track frequency");
3363 break;
3364 }
3365 config_req.channel_count = A2DP_GetTrackChannelCount(p_data->avk_config.codec_info);
3366 if (config_req.channel_count == -1) {
3367 log::error("Cannot get the channel count");
3368 break;
3369 }
3370 config_req.peer_address = p_data->avk_config.bd_addr;
3371 BtifAvEvent btif_av_event(BTIF_AV_SINK_CONFIG_REQ_EVT, &config_req, sizeof(config_req));
3372 do_in_main_thread(base::BindOnce(&btif_av_handle_event,
3373 AVDT_TSEP_SRC, // peer_sep
3374 config_req.peer_address, kBtaHandleUnknown, btif_av_event));
3375 break;
3376 }
3377 default:
3378 break;
3379 }
3380 }
3381
3382 // Initializes the AV interface for source mode
btif_av_source_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,std::vector<btav_a2dp_codec_info_t> * supported_codecs)3383 bt_status_t btif_av_source_init(btav_source_callbacks_t* callbacks, int max_connected_audio_devices,
3384 const std::vector<btav_a2dp_codec_config_t>& codec_priorities,
3385 const std::vector<btav_a2dp_codec_config_t>& offloading_preference,
3386 std::vector<btav_a2dp_codec_info_t>* supported_codecs) {
3387 log::info("");
3388 std::promise<bt_status_t> init_complete_promise;
3389 std::future<bt_status_t> init_complete_promise_future = init_complete_promise.get_future();
3390 const auto& status = do_in_main_thread(
3391 base::BindOnce(&BtifAvSource::Init, base::Unretained(&btif_av_source), callbacks,
3392 max_connected_audio_devices, codec_priorities, offloading_preference,
3393 supported_codecs, std::move(init_complete_promise)));
3394 if (status == BT_STATUS_SUCCESS) {
3395 init_complete_promise_future.wait();
3396 return init_complete_promise_future.get();
3397 } else {
3398 log::warn("Failed to init source profile");
3399 return status;
3400 }
3401 }
3402
3403 // Initializes the AV interface for sink mode
btif_av_sink_init(btav_sink_callbacks_t * callbacks,int max_connected_audio_devices)3404 bt_status_t btif_av_sink_init(btav_sink_callbacks_t* callbacks, int max_connected_audio_devices) {
3405 log::info("");
3406
3407 std::promise<bt_status_t> init_complete_promise;
3408 std::future<bt_status_t> init_complete_promise_future = init_complete_promise.get_future();
3409 const auto status = do_in_main_thread(
3410 base::BindOnce(&BtifAvSink::Init, base::Unretained(&btif_av_sink), callbacks,
3411 max_connected_audio_devices, std::move(init_complete_promise)));
3412 if (status == BT_STATUS_SUCCESS) {
3413 init_complete_promise_future.wait();
3414 return init_complete_promise_future.get();
3415 } else {
3416 log::warn("Failed to init sink");
3417 return status;
3418 }
3419 }
3420
3421 // Updates the final focus state reported by components calling this module
btif_av_sink_set_audio_focus_state(int state)3422 void btif_av_sink_set_audio_focus_state(int state) {
3423 log::info("state={}", state);
3424 btif_a2dp_sink_set_focus_state_req((btif_a2dp_sink_focus_state_t)state);
3425 }
3426
3427 // Updates the track gain (used for ducking).
btif_av_sink_set_audio_track_gain(float gain)3428 void btif_av_sink_set_audio_track_gain(float gain) {
3429 log::info("gain={:f}", gain);
3430 btif_a2dp_sink_set_audio_track_gain(gain);
3431 }
3432
3433 // Establishes the AV signalling channel with the remote headset
connect_int(RawAddress * peer_address,uint16_t uuid)3434 static bt_status_t connect_int(RawAddress* peer_address, uint16_t uuid) {
3435 log::info("peer={} uuid=0x{:x}", *peer_address, uuid);
3436
3437 if (btif_av_both_enable()) {
3438 const RawAddress tmp = *peer_address;
3439 if (uuid == UUID_SERVCLASS_AUDIO_SOURCE) {
3440 btif_av_source_dispatch_sm_event(tmp, BTIF_AV_CONNECT_REQ_EVT);
3441 } else if (uuid == UUID_SERVCLASS_AUDIO_SINK) {
3442 btif_av_sink_dispatch_sm_event(tmp, BTIF_AV_CONNECT_REQ_EVT);
3443 }
3444 return BT_STATUS_SUCCESS;
3445 }
3446
3447 auto connection_task = [](RawAddress* peer_address, uint16_t uuid) {
3448 BtifAvPeer* peer = nullptr;
3449 if (uuid == UUID_SERVCLASS_AUDIO_SOURCE) {
3450 peer = btif_av_source.FindOrCreatePeer(*peer_address, kBtaHandleUnknown);
3451 } else if (uuid == UUID_SERVCLASS_AUDIO_SINK) {
3452 peer = btif_av_sink.FindOrCreatePeer(*peer_address, kBtaHandleUnknown);
3453 }
3454 if (peer == nullptr) {
3455 btif_queue_advance();
3456 return;
3457 }
3458 peer->StateMachine().ProcessEvent(BTIF_AV_CONNECT_REQ_EVT, nullptr);
3459 };
3460 bt_status_t status = do_in_main_thread(base::BindOnce(connection_task, peer_address, uuid));
3461 if (status != BT_STATUS_SUCCESS) {
3462 log::error("can't post connection task to main_thread");
3463 }
3464 return status;
3465 }
3466
set_source_silence_peer_int(const RawAddress & peer_address,bool silence)3467 static void set_source_silence_peer_int(const RawAddress& peer_address, bool silence) {
3468 log::info("peer={} silence={}", peer_address, silence);
3469
3470 if (!btif_av_source.SetSilencePeer(peer_address, silence)) {
3471 log::error("Error setting silence state to {}", peer_address);
3472 }
3473 }
3474
3475 // Set the active peer
set_active_peer_int(uint8_t peer_sep,const RawAddress & peer_address,std::promise<void> peer_ready_promise)3476 static void set_active_peer_int(uint8_t peer_sep, const RawAddress& peer_address,
3477 std::promise<void> peer_ready_promise) {
3478 log::info("peer_sep={} peer={}", peer_sep == AVDT_TSEP_SRC ? "Source" : "Sink", peer_address);
3479
3480 BtifAvPeer* peer = nullptr;
3481 if (peer_sep == AVDT_TSEP_SNK) {
3482 if (!btif_av_src_sink_coexist_enabled() ||
3483 (btif_av_src_sink_coexist_enabled() && btif_av_both_enable() &&
3484 (btif_av_sink.FindPeer(peer_address) == nullptr))) {
3485 if (!btif_av_source.SetActivePeer(peer_address, std::move(peer_ready_promise))) {
3486 log::error("Error setting {} as active Sink peer", peer_address);
3487 }
3488 }
3489 return;
3490 }
3491 if (peer_sep == AVDT_TSEP_SRC) {
3492 if (!btif_av_src_sink_coexist_enabled() ||
3493 (btif_av_src_sink_coexist_enabled() && btif_av_both_enable() &&
3494 (btif_av_source.FindPeer(peer_address) == nullptr))) {
3495 if (!btif_av_sink.SetActivePeer(peer_address, std::move(peer_ready_promise))) {
3496 log::error("Error setting {} as active Source peer", peer_address);
3497 }
3498 }
3499 return;
3500 }
3501 // If reached here, we could not set the active peer
3502 log::error("Cannot set active {} peer to {}: peer not {}",
3503 (peer_sep == AVDT_TSEP_SRC) ? "Source" : "Sink", peer_address,
3504 (peer == nullptr) ? "found" : "connected");
3505 peer_ready_promise.set_value();
3506 }
3507
btif_av_source_connect(const RawAddress & peer_address)3508 bt_status_t btif_av_source_connect(const RawAddress& peer_address) {
3509 log::info("peer={}", peer_address);
3510
3511 if (!btif_av_source.Enabled()) {
3512 log::warn("BTIF AV Source is not enabled");
3513 return BT_STATUS_NOT_READY;
3514 }
3515
3516 RawAddress peer_address_copy(peer_address);
3517 return btif_queue_connect(UUID_SERVCLASS_AUDIO_SOURCE, &peer_address_copy, connect_int);
3518 }
3519
btif_av_sink_connect(const RawAddress & peer_address)3520 bt_status_t btif_av_sink_connect(const RawAddress& peer_address) {
3521 log::info("peer={}", peer_address);
3522
3523 if (!btif_av_sink.Enabled()) {
3524 log::warn("BTIF AV Sink is not enabled");
3525 return BT_STATUS_NOT_READY;
3526 }
3527
3528 RawAddress peer_address_copy(peer_address);
3529 return btif_queue_connect(UUID_SERVCLASS_AUDIO_SINK, &peer_address_copy, connect_int);
3530 }
3531
btif_av_source_disconnect(const RawAddress & peer_address)3532 bt_status_t btif_av_source_disconnect(const RawAddress& peer_address) {
3533 log::info("peer={}", peer_address);
3534
3535 if (!btif_av_source.Enabled()) {
3536 log::warn("BTIF AV Source is not enabled");
3537 return BT_STATUS_NOT_READY;
3538 }
3539
3540 BtifAvEvent btif_av_event(BTIF_AV_DISCONNECT_REQ_EVT, &peer_address, sizeof(peer_address));
3541 return do_in_main_thread(base::BindOnce(&btif_av_handle_event,
3542 AVDT_TSEP_SNK, // peer_sep
3543 peer_address, kBtaHandleUnknown, btif_av_event));
3544 }
3545
btif_av_sink_disconnect(const RawAddress & peer_address)3546 bt_status_t btif_av_sink_disconnect(const RawAddress& peer_address) {
3547 log::info("peer={}", peer_address);
3548
3549 if (!btif_av_sink.Enabled()) {
3550 log::warn("BTIF AV Sink is not enabled");
3551 return BT_STATUS_NOT_READY;
3552 }
3553
3554 BtifAvEvent btif_av_event(BTIF_AV_DISCONNECT_REQ_EVT, &peer_address, sizeof(peer_address));
3555 return do_in_main_thread(base::BindOnce(&btif_av_handle_event,
3556 AVDT_TSEP_SRC, // peer_sep
3557 peer_address, kBtaHandleUnknown, btif_av_event));
3558 }
3559
btif_av_sink_set_active_device(const RawAddress & peer_address)3560 bt_status_t btif_av_sink_set_active_device(const RawAddress& peer_address) {
3561 log::info("peer={}", peer_address);
3562
3563 if (!btif_av_sink.Enabled()) {
3564 log::warn("BTIF AV Source is not enabled");
3565 return BT_STATUS_NOT_READY;
3566 }
3567
3568 std::promise<void> peer_ready_promise;
3569 std::future<void> peer_ready_future = peer_ready_promise.get_future();
3570 bt_status_t status =
3571 do_in_main_thread(base::BindOnce(&set_active_peer_int,
3572 AVDT_TSEP_SRC, // peer_sep
3573 peer_address, std::move(peer_ready_promise)));
3574 if (status == BT_STATUS_SUCCESS) {
3575 peer_ready_future.wait();
3576 } else {
3577 log::warn("BTIF AV Sink fails to change peer");
3578 }
3579 return status;
3580 }
3581
btif_av_source_set_silence_device(const RawAddress & peer_address,bool silence)3582 bt_status_t btif_av_source_set_silence_device(const RawAddress& peer_address, bool silence) {
3583 log::info("peer={} silence={}", peer_address, silence);
3584
3585 if (!btif_av_source.Enabled()) {
3586 log::warn("BTIF AV Source is not enabled");
3587 return BT_STATUS_NOT_READY;
3588 }
3589
3590 return do_in_main_thread(base::BindOnce(&set_source_silence_peer_int, peer_address, silence));
3591 }
3592
btif_av_source_set_active_device(const RawAddress & peer_address)3593 bt_status_t btif_av_source_set_active_device(const RawAddress& peer_address) {
3594 log::info("peer={}", peer_address);
3595
3596 if (!btif_av_source.Enabled()) {
3597 log::warn("BTIF AV Source is not enabled");
3598 return BT_STATUS_NOT_READY;
3599 }
3600
3601 std::promise<void> peer_ready_promise;
3602 std::future<void> peer_ready_future = peer_ready_promise.get_future();
3603 bt_status_t status =
3604 do_in_main_thread(base::BindOnce(&set_active_peer_int,
3605 AVDT_TSEP_SNK, // peer_sep
3606 peer_address, std::move(peer_ready_promise)));
3607 if (status == BT_STATUS_SUCCESS) {
3608 peer_ready_future.wait();
3609 } else {
3610 log::warn("BTIF AV Source fails to change peer");
3611 }
3612 return status;
3613 }
3614
btif_av_source_set_codec_config_preference(const RawAddress & peer_address,std::vector<btav_a2dp_codec_config_t> codec_preferences)3615 bt_status_t btif_av_source_set_codec_config_preference(
3616 const RawAddress& peer_address, std::vector<btav_a2dp_codec_config_t> codec_preferences) {
3617 log::info("peer={} codec_preferences=[{}]", peer_address, codec_preferences.size());
3618
3619 if (!btif_av_source.Enabled()) {
3620 log::warn("BTIF AV Source is not enabled");
3621 return BT_STATUS_NOT_READY;
3622 }
3623
3624 if (peer_address.IsEmpty()) {
3625 log::warn("BTIF AV Source needs peer to config");
3626 return BT_STATUS_PARM_INVALID;
3627 }
3628
3629 std::promise<void> peer_ready_promise;
3630 std::future<void> peer_ready_future = peer_ready_promise.get_future();
3631 bt_status_t status = BT_STATUS_FAIL;
3632
3633 if (com::android::bluetooth::flags::av_stream_reconfigure_fix()) {
3634 status = btif_av_source.SetPeerReconfigureStreamData(peer_address, codec_preferences,
3635 std::move(peer_ready_promise));
3636 if (status != BT_STATUS_SUCCESS) {
3637 log::error("SetPeerReconfigureStreamData failed, status: {}", status);
3638 return status;
3639 }
3640
3641 BtifAvEvent btif_av_event(BTIF_AV_RECONFIGURE_REQ_EVT, nullptr, 0);
3642 status = do_in_main_thread(base::BindOnce(&btif_av_handle_event,
3643 AVDT_TSEP_SNK, // peer_sep
3644 peer_address, kBtaHandleUnknown, btif_av_event));
3645 } else {
3646 status = do_in_main_thread(base::BindOnce(&BtifAvSource::UpdateCodecConfig,
3647 base::Unretained(&btif_av_source), peer_address,
3648 codec_preferences, std::move(peer_ready_promise)));
3649 }
3650
3651 if (status != BT_STATUS_SUCCESS) {
3652 log::error("do_in_main_thread failed, status: {}", status);
3653 return status;
3654 }
3655
3656 if (peer_ready_future.wait_for(std::chrono::seconds(10)) != std::future_status::ready) {
3657 log::error("BTIF AV Source fails to config codec");
3658 return BT_STATUS_FAIL;
3659 }
3660
3661 return status;
3662 }
3663
btif_av_source_cleanup(void)3664 void btif_av_source_cleanup(void) {
3665 log::info("");
3666 do_in_main_thread(base::BindOnce(&BtifAvSource::Cleanup, base::Unretained(&btif_av_source)));
3667 }
3668
btif_av_sink_cleanup(void)3669 void btif_av_sink_cleanup(void) {
3670 log::info("");
3671 do_in_main_thread(base::BindOnce(&BtifAvSink::Cleanup, base::Unretained(&btif_av_sink)));
3672 }
3673
btif_av_source_active_peer(void)3674 RawAddress btif_av_source_active_peer(void) { return btif_av_source.ActivePeer(); }
btif_av_sink_active_peer(void)3675 RawAddress btif_av_sink_active_peer(void) { return btif_av_sink.ActivePeer(); }
3676
btif_av_is_sink_enabled(void)3677 bool btif_av_is_sink_enabled(void) { return btif_av_sink.Enabled(); }
3678
btif_av_is_source_enabled(void)3679 bool btif_av_is_source_enabled(void) { return btif_av_source.Enabled(); }
3680
btif_av_stream_start(const A2dpType)3681 void btif_av_stream_start(const A2dpType /*local_a2dp_type*/) {
3682 log::info("");
3683
3684 btif_av_source_dispatch_sm_event(btif_av_source_active_peer(), BTIF_AV_START_STREAM_REQ_EVT);
3685 }
3686
btif_av_stream_start_with_latency(bool use_latency_mode)3687 void btif_av_stream_start_with_latency(bool use_latency_mode) {
3688 log::info("peer={} use_latency_mode={}", btif_av_source_active_peer(), use_latency_mode);
3689
3690 btif_av_start_stream_req_t start_stream_req;
3691 start_stream_req.use_latency_mode = use_latency_mode;
3692 BtifAvEvent btif_av_event(BTIF_AV_START_STREAM_REQ_EVT, &start_stream_req,
3693 sizeof(start_stream_req));
3694
3695 do_in_main_thread(base::BindOnce(&btif_av_handle_event,
3696 AVDT_TSEP_SNK, // peer_sep
3697 btif_av_source_active_peer(), kBtaHandleUnknown, btif_av_event));
3698 }
3699
btif_av_stream_stop(const RawAddress & peer_address)3700 void btif_av_stream_stop(const RawAddress& peer_address) {
3701 log::info("peer={}", peer_address);
3702
3703 if (!peer_address.IsEmpty()) {
3704 btif_av_source_dispatch_sm_event(peer_address, BTIF_AV_STOP_STREAM_REQ_EVT);
3705 return;
3706 }
3707
3708 // The active peer might have changed and we might be in the process
3709 // of reconfiguring the stream. We need to stop the appropriate peer(s).
3710 btif_av_source.DispatchSuspendStreamEvent(BTIF_AV_STOP_STREAM_REQ_EVT);
3711 }
3712
btif_av_stream_suspend(void)3713 void btif_av_stream_suspend(void) {
3714 log::info("");
3715
3716 // The active peer might have changed and we might be in the process
3717 // of reconfiguring the stream. We need to suspend the appropriate peer(s).
3718 btif_av_source.DispatchSuspendStreamEvent(BTIF_AV_SUSPEND_STREAM_REQ_EVT);
3719 }
3720
btif_av_stream_start_offload(void)3721 void btif_av_stream_start_offload(void) {
3722 log::info("");
3723
3724 btif_av_source_dispatch_sm_event(btif_av_source_active_peer(), BTIF_AV_OFFLOAD_START_REQ_EVT);
3725 }
3726
btif_av_stream_ready(const A2dpType local_a2dp_type)3727 bool btif_av_stream_ready(const A2dpType local_a2dp_type) {
3728 // Make sure the main adapter is enabled
3729 if (btif_is_enabled() == 0) {
3730 log::verbose("Main adapter is not enabled");
3731 return false;
3732 }
3733
3734 BtifAvPeer* peer = btif_av_find_active_peer(local_a2dp_type);
3735 if (peer == nullptr) {
3736 log::warn("No active peer found");
3737 return false;
3738 }
3739
3740 int state = peer->StateMachine().StateId();
3741 log::info("active_peer={} state={} flags={}", peer->PeerAddress(), state, peer->FlagsToString());
3742
3743 // check if we are remotely suspended or stop is pending
3744 if (peer->CheckFlags(BtifAvPeer::kFlagRemoteSuspend | BtifAvPeer::kFlagPendingStop)) {
3745 return false;
3746 }
3747
3748 return state == BtifAvStateMachine::kStateOpened;
3749 }
3750
btif_av_stream_started_ready(const A2dpType local_a2dp_type)3751 bool btif_av_stream_started_ready(const A2dpType local_a2dp_type) {
3752 BtifAvPeer* peer = btif_av_find_active_peer(local_a2dp_type);
3753 if (peer == nullptr) {
3754 log::warn("No active peer found");
3755 return false;
3756 }
3757
3758 int state = peer->StateMachine().StateId();
3759 bool ready = false;
3760 if (peer->CheckFlags(BtifAvPeer::kFlagLocalSuspendPending | BtifAvPeer::kFlagRemoteSuspend |
3761 BtifAvPeer::kFlagPendingStop)) {
3762 // Disallow media task to start if we have pending actions
3763 ready = false;
3764 } else {
3765 ready = (state == BtifAvStateMachine::kStateStarted);
3766 }
3767
3768 log::info("active_peer={} state={} flags={} ready={}", peer->PeerAddress(), state,
3769 peer->FlagsToString(), ready);
3770
3771 return ready;
3772 }
3773
btif_av_source_dispatch_sm_event(const RawAddress & peer_address,btif_av_sm_event_t event)3774 static void btif_av_source_dispatch_sm_event(const RawAddress& peer_address,
3775 btif_av_sm_event_t event) {
3776 BtifAvEvent btif_av_event(event, nullptr, 0);
3777 log::verbose("peer={} event={}", peer_address, btif_av_event.ToString());
3778
3779 do_in_main_thread(base::BindOnce(&btif_av_handle_event,
3780 AVDT_TSEP_SNK, // peer_sep
3781 peer_address, kBtaHandleUnknown, btif_av_event));
3782 }
3783
btif_av_sink_dispatch_sm_event(const RawAddress & peer_address,btif_av_sm_event_t event)3784 static void btif_av_sink_dispatch_sm_event(const RawAddress& peer_address,
3785 btif_av_sm_event_t event) {
3786 BtifAvEvent btif_av_event(event, nullptr, 0);
3787 log::verbose("peer={} event={}", peer_address, btif_av_event.ToString());
3788
3789 do_in_main_thread(base::BindOnce(&btif_av_handle_event,
3790 AVDT_TSEP_SRC, // peer_sep
3791 peer_address, kBtaHandleUnknown, btif_av_event));
3792 }
3793
btif_av_source_execute_service(bool enable)3794 bt_status_t btif_av_source_execute_service(bool enable) {
3795 log::info("enable={}", enable);
3796
3797 if (enable) {
3798 // Added BTA_AV_FEAT_NO_SCO_SSPD - this ensures that the BTA does not
3799 // auto-suspend av streaming on AG events(SCO or Call). The suspend shall
3800 // be initiated by the app/audioflinger layers.
3801 // Support for browsing for SDP record should work only if we enable
3802 // BROWSE while registering.
3803 tBTA_AV_FEAT features =
3804 BTA_AV_FEAT_RCTG | BTA_AV_FEAT_METADATA | BTA_AV_FEAT_VENDOR | BTA_AV_FEAT_NO_SCO_SSPD;
3805
3806 if (delay_reporting_enabled()) {
3807 features |= BTA_AV_FEAT_DELAY_RPT;
3808 }
3809
3810 if (avrcp_absolute_volume_is_enabled()) {
3811 features |= BTA_AV_FEAT_RCCT | BTA_AV_FEAT_ADV_CTRL | BTA_AV_FEAT_BROWSE;
3812 }
3813
3814 if (btif_av_src_sink_coexist_enabled()) {
3815 features |= BTA_AV_FEAT_SRC;
3816 BTA_AvEnable(features, bta_av_event_callback);
3817 } else {
3818 BTA_AvEnable(features, bta_av_source_callback);
3819 }
3820 btif_av_source.RegisterAllBtaHandles();
3821 return BT_STATUS_SUCCESS;
3822 }
3823
3824 // Disable the service
3825 btif_av_source.DeregisterAllBtaHandles();
3826 BTA_AvDisable();
3827 return BT_STATUS_SUCCESS;
3828 }
3829
btif_av_sink_execute_service(bool enable)3830 bt_status_t btif_av_sink_execute_service(bool enable) {
3831 log::info("enable={}", enable);
3832
3833 if (enable) {
3834 // Added BTA_AV_FEAT_NO_SCO_SSPD - this ensures that the BTA does not
3835 // auto-suspend AV streaming on AG events (SCO or Call). The suspend shall
3836 // be initiated by the app/audioflinger layers.
3837 tBTA_AV_FEAT features = BTA_AV_FEAT_NO_SCO_SSPD | BTA_AV_FEAT_RCCT | BTA_AV_FEAT_METADATA |
3838 BTA_AV_FEAT_VENDOR | BTA_AV_FEAT_ADV_CTRL | BTA_AV_FEAT_RCTG |
3839 BTA_AV_FEAT_BROWSE | BTA_AV_FEAT_COVER_ARTWORK;
3840
3841 if (delay_reporting_enabled()) {
3842 features |= BTA_AV_FEAT_DELAY_RPT;
3843 }
3844
3845 if (btif_av_src_sink_coexist_enabled()) {
3846 BTA_AvEnable(features, bta_av_event_callback);
3847 } else {
3848 BTA_AvEnable(features, bta_av_sink_callback);
3849 }
3850 btif_av_sink.RegisterAllBtaHandles();
3851 return BT_STATUS_SUCCESS;
3852 }
3853
3854 // Disable the service
3855 btif_av_sink.DeregisterAllBtaHandles();
3856 BTA_AvDisable();
3857 return BT_STATUS_SUCCESS;
3858 }
3859
btif_av_is_connected(const A2dpType local_a2dp_type)3860 bool btif_av_is_connected(const A2dpType local_a2dp_type) {
3861 BtifAvPeer* peer = btif_av_find_active_peer(local_a2dp_type);
3862 if (peer == nullptr) {
3863 log::warn("No active peer found");
3864 return false;
3865 }
3866
3867 bool connected = peer->IsConnected();
3868 log::verbose("active_peer={} connected={}", peer->PeerAddress(), connected);
3869 return peer->IsConnected();
3870 }
3871
btif_av_get_peer_sep(const A2dpType local_a2dp_type)3872 uint8_t btif_av_get_peer_sep(const A2dpType local_a2dp_type) {
3873 BtifAvPeer* peer = btif_av_find_active_peer(local_a2dp_type);
3874 if (peer == nullptr) {
3875 log::warn("No active peer found");
3876 return AVDT_TSEP_INVALID;
3877 }
3878
3879 uint8_t peer_sep = peer->PeerSep();
3880 log::verbose("active_peer={} sep={}", peer->PeerAddress(),
3881 peer_sep == AVDT_TSEP_SRC ? "Source" : "Sink");
3882 return peer_sep;
3883 }
3884
btif_av_clear_remote_suspend_flag(const A2dpType local_a2dp_type)3885 void btif_av_clear_remote_suspend_flag(const A2dpType local_a2dp_type) {
3886 auto clear_remote_suspend_flag = [](const A2dpType local_a2dp_type) {
3887 BtifAvPeer* peer = btif_av_find_active_peer(local_a2dp_type);
3888 if (peer == nullptr) {
3889 log::warn("No active peer found");
3890 return;
3891 }
3892 log::verbose("active_peer={} flags={}", peer->PeerAddress(), peer->FlagsToString());
3893 peer->ClearFlags(BtifAvPeer::kFlagRemoteSuspend);
3894 };
3895 // switch to main thread to prevent a race condition of accessing peers
3896 do_in_main_thread(base::BindOnce(clear_remote_suspend_flag, local_a2dp_type));
3897 }
3898
btif_av_is_peer_edr(const RawAddress & peer_address,const A2dpType local_a2dp_type)3899 bool btif_av_is_peer_edr(const RawAddress& peer_address, const A2dpType local_a2dp_type) {
3900 BtifAvPeer* peer = btif_av_find_peer(peer_address, local_a2dp_type);
3901 if (peer == nullptr) {
3902 log::warn("peer={} not found", peer_address);
3903 return false;
3904 }
3905 if (!peer->IsConnected()) {
3906 log::warn("peer={} not connected", peer_address);
3907 return false;
3908 }
3909
3910 bool is_edr = peer->IsEdr();
3911 log::verbose("peer={} is_edr={}", peer_address, is_edr);
3912 return is_edr;
3913 }
3914
btif_av_peer_supports_3mbps(const RawAddress & peer_address,const A2dpType local_a2dp_type)3915 bool btif_av_peer_supports_3mbps(const RawAddress& peer_address, const A2dpType local_a2dp_type) {
3916 BtifAvPeer* peer = btif_av_find_peer(peer_address, local_a2dp_type);
3917 if (peer == nullptr) {
3918 log::warn("peer={} not found", peer_address);
3919 return false;
3920 }
3921
3922 bool is_3mbps = peer->Is3Mbps();
3923 bool is_connected = peer->IsConnected();
3924 log::verbose("peer={} connected={}, edr_3mbps={}", peer_address, is_connected, is_3mbps);
3925 return is_connected && is_3mbps;
3926 }
3927
btif_av_peer_prefers_mandatory_codec(const RawAddress & peer_address,const A2dpType local_a2dp_type)3928 bool btif_av_peer_prefers_mandatory_codec(const RawAddress& peer_address,
3929 const A2dpType local_a2dp_type) {
3930 BtifAvPeer* peer = btif_av_find_peer(peer_address, local_a2dp_type);
3931 if (peer == nullptr) {
3932 log::warn("peer={} not found", peer_address);
3933 return false;
3934 }
3935 return peer->IsMandatoryCodecPreferred();
3936 }
3937
btif_av_acl_disconnected(const RawAddress & peer_address,const A2dpType local_a2dp_type)3938 void btif_av_acl_disconnected(const RawAddress& peer_address, const A2dpType local_a2dp_type) {
3939 log::info("peer={}", peer_address);
3940
3941 // Inform the application that ACL is disconnected and move to idle state
3942 if (btif_av_both_enable()) {
3943 BtifAvPeer* peer = btif_av_find_peer(peer_address, local_a2dp_type);
3944 if (peer != nullptr) {
3945 if (peer->IsSource()) {
3946 btif_av_sink_dispatch_sm_event(peer_address, BTIF_AV_ACL_DISCONNECTED);
3947 } else {
3948 btif_av_source_dispatch_sm_event(peer_address, BTIF_AV_ACL_DISCONNECTED);
3949 }
3950 }
3951 return;
3952 }
3953
3954 if (btif_av_source.Enabled()) {
3955 btif_av_source_dispatch_sm_event(peer_address, BTIF_AV_ACL_DISCONNECTED);
3956 } else if (btif_av_sink.Enabled()) {
3957 btif_av_sink_dispatch_sm_event(peer_address, BTIF_AV_ACL_DISCONNECTED);
3958 }
3959 }
3960
btif_debug_av_peer_dump(int fd,const BtifAvPeer & peer)3961 static void btif_debug_av_peer_dump(int fd, const BtifAvPeer& peer) {
3962 std::string state_str;
3963 int state = peer.StateMachine().StateId();
3964 switch (state) {
3965 case BtifAvStateMachine::kStateIdle:
3966 state_str = "Idle";
3967 break;
3968 case BtifAvStateMachine::kStateOpening:
3969 state_str = "Opening";
3970 break;
3971 case BtifAvStateMachine::kStateOpened:
3972 state_str = "Opened";
3973 break;
3974 case BtifAvStateMachine::kStateStarted:
3975 state_str = "Started";
3976 break;
3977 case BtifAvStateMachine::kStateClosing:
3978 state_str = "Closing";
3979 break;
3980 default:
3981 state_str = "Unknown(" + std::to_string(state) + ")";
3982 break;
3983 }
3984
3985 dprintf(fd, " Peer: %s\n", peer.PeerAddress().ToRedactedStringForLogging().c_str());
3986 dprintf(fd, " Connected: %s\n", peer.IsConnected() ? "true" : "false");
3987 dprintf(fd, " Streaming: %s\n", peer.IsStreaming() ? "true" : "false");
3988 dprintf(fd, " SEP: %d(%s)\n", peer.PeerSep(), (peer.IsSource()) ? "Source" : "Sink");
3989 dprintf(fd, " State Machine: %s\n", state_str.c_str());
3990 dprintf(fd, " Flags: %s\n", peer.FlagsToString().c_str());
3991 dprintf(fd, " OpenOnRcTimer: %s\n",
3992 alarm_is_scheduled(peer.AvOpenOnRcTimer()) ? "Scheduled" : "Not scheduled");
3993 dprintf(fd, " BTA Handle: 0x%x\n", peer.BtaHandle());
3994 dprintf(fd, " Peer ID: %d\n", peer.PeerId());
3995 dprintf(fd, " EDR: %s\n", peer.IsEdr() ? "true" : "false");
3996 dprintf(fd, " Support 3Mbps: %s\n", peer.Is3Mbps() ? "true" : "false");
3997 dprintf(fd, " Self Initiated Connection: %s\n",
3998 peer.SelfInitiatedConnection() ? "true" : "false");
3999 dprintf(fd, " Delay Reporting: %u (in 1/10 milliseconds) \n", peer.GetDelayReport());
4000 dprintf(fd, " Codec Preferred: %s\n",
4001 peer.IsMandatoryCodecPreferred() ? "Mandatory" : "Optional");
4002 }
4003
btif_debug_av_source_dump(int fd)4004 static void btif_debug_av_source_dump(int fd) {
4005 bool enabled = btif_av_source.Enabled();
4006
4007 dprintf(fd, "\nA2DP Source State: %s\n", (enabled) ? "Enabled" : "Disabled");
4008 if (!enabled) {
4009 return;
4010 }
4011 dprintf(fd, " Active peer: %s\n",
4012 btif_av_source.ActivePeer().ToRedactedStringForLogging().c_str());
4013 dprintf(fd, " Peers:\n");
4014 btif_av_source.DumpPeersInfo(fd);
4015 }
4016
btif_debug_av_sink_dump(int fd)4017 static void btif_debug_av_sink_dump(int fd) {
4018 bool enabled = btif_av_sink.Enabled();
4019
4020 dprintf(fd, "\nA2DP Sink State: %s\n", (enabled) ? "Enabled" : "Disabled");
4021 if (!enabled) {
4022 return;
4023 }
4024 dprintf(fd, " Active peer: %s\n",
4025 btif_av_sink.ActivePeer().ToRedactedStringForLogging().c_str());
4026 dprintf(fd, " Peers:\n");
4027 btif_av_sink.DumpPeersInfo(fd);
4028 }
4029
btif_debug_av_dump(int fd)4030 void btif_debug_av_dump(int fd) {
4031 btif_debug_av_source_dump(fd);
4032 btif_debug_av_sink_dump(fd);
4033 }
4034
btif_av_set_audio_delay(const RawAddress & peer_address,uint16_t delay,const A2dpType local_a2dp_type)4035 void btif_av_set_audio_delay(const RawAddress& peer_address, uint16_t delay,
4036 const A2dpType local_a2dp_type) {
4037 log::info("peer={} delay={}", peer_address, delay);
4038
4039 BtifAvPeer* peer = btif_av_find_peer(peer_address, local_a2dp_type);
4040 if (peer != nullptr && peer->IsSink()) {
4041 peer->SetDelayReport(delay);
4042 if (peer->IsActivePeer()) {
4043 bluetooth::audio::a2dp::set_remote_delay(peer->GetDelayReport());
4044 }
4045 }
4046 }
4047
btif_av_get_audio_delay(const A2dpType local_a2dp_type)4048 uint16_t btif_av_get_audio_delay(const A2dpType local_a2dp_type) {
4049 BtifAvPeer* peer = btif_av_find_active_peer(local_a2dp_type);
4050 if (peer != nullptr && peer->IsSink()) {
4051 return peer->GetDelayReport();
4052 }
4053 return 0;
4054 }
4055
btif_av_is_a2dp_offload_enabled()4056 bool btif_av_is_a2dp_offload_enabled() { return btif_av_source.A2dpOffloadEnabled(); }
4057
btif_av_is_a2dp_offload_running()4058 bool btif_av_is_a2dp_offload_running() {
4059 if (!btif_av_is_a2dp_offload_enabled()) {
4060 return false;
4061 }
4062 if (!bluetooth::audio::a2dp::is_hal_enabled()) {
4063 return false;
4064 }
4065 return bluetooth::audio::a2dp::is_hal_offloading();
4066 }
4067
btif_av_is_peer_silenced(const RawAddress & peer_address)4068 bool btif_av_is_peer_silenced(const RawAddress& peer_address) {
4069 return btif_av_source.IsPeerSilenced(peer_address);
4070 }
4071
btif_av_set_dynamic_audio_buffer_size(uint8_t dynamic_audio_buffer_size)4072 void btif_av_set_dynamic_audio_buffer_size(uint8_t dynamic_audio_buffer_size) {
4073 btif_a2dp_source_set_dynamic_audio_buffer_size(dynamic_audio_buffer_size);
4074 }
4075
btif_av_set_low_latency(bool is_low_latency)4076 void btif_av_set_low_latency(bool is_low_latency) {
4077 log::info("active_peer={} is_low_latency={}", btif_av_source_active_peer(), is_low_latency);
4078
4079 btif_av_set_latency_req_t set_latency_req;
4080 set_latency_req.is_low_latency = is_low_latency;
4081 BtifAvEvent btif_av_event(BTIF_AV_SET_LATENCY_REQ_EVT, &set_latency_req, sizeof(set_latency_req));
4082
4083 do_in_main_thread(base::BindOnce(&btif_av_handle_event,
4084 AVDT_TSEP_SNK, // peer_sep
4085 btif_av_source_active_peer(), kBtaHandleUnknown, btif_av_event));
4086 }
4087
btif_av_is_connected_addr(const RawAddress & peer_address,const A2dpType local_a2dp_type)4088 bool btif_av_is_connected_addr(const RawAddress& peer_address, const A2dpType local_a2dp_type) {
4089 BtifAvPeer* peer = btif_av_find_peer(peer_address, local_a2dp_type);
4090 if (peer == nullptr) {
4091 log::warn("No active peer found");
4092 return false;
4093 }
4094
4095 bool connected = peer->IsConnected();
4096 log::verbose("active_peer={} connected={}", peer->PeerAddress(), connected);
4097 return connected;
4098 }
4099
btif_av_peer_is_connected_sink(const RawAddress & peer_address)4100 bool btif_av_peer_is_connected_sink(const RawAddress& peer_address) {
4101 BtifAvPeer* peer = btif_av_source_find_peer(peer_address);
4102 if (peer == nullptr) {
4103 log::warn("No active peer found");
4104 return false;
4105 }
4106
4107 bool connected = peer->IsConnected();
4108 log::verbose("active_peer={} connected={}", peer->PeerAddress(), connected);
4109 return connected;
4110 }
4111
btif_av_peer_is_connected_source(const RawAddress & peer_address)4112 bool btif_av_peer_is_connected_source(const RawAddress& peer_address) {
4113 BtifAvPeer* peer = btif_av_sink_find_peer(peer_address);
4114 if (peer == nullptr) {
4115 log::warn("No active peer found");
4116 return false;
4117 }
4118
4119 bool connected = peer->IsConnected();
4120 log::verbose("active_peer={} connected={}", peer->PeerAddress(), connected);
4121 return connected;
4122 }
4123
btif_av_peer_is_sink(const RawAddress & peer_address)4124 bool btif_av_peer_is_sink(const RawAddress& peer_address) {
4125 BtifAvPeer* peer = btif_av_source_find_peer(peer_address);
4126 if (peer == nullptr) {
4127 log::warn("No active peer found");
4128 return false;
4129 }
4130
4131 return true;
4132 }
4133
btif_av_peer_is_source(const RawAddress & peer_address)4134 bool btif_av_peer_is_source(const RawAddress& peer_address) {
4135 BtifAvPeer* peer = btif_av_sink_find_peer(peer_address);
4136 if (peer == nullptr) {
4137 log::warn("No active peer found");
4138 return false;
4139 }
4140
4141 return true;
4142 }
4143
btif_av_connect_sink_delayed(uint8_t handle,const RawAddress & peer_address)4144 void btif_av_connect_sink_delayed(uint8_t handle, const RawAddress& peer_address) {
4145 log::info("peer={} handle=0x{:x}", peer_address, handle);
4146
4147 if (btif_av_source.Enabled()) {
4148 btif_av_source_dispatch_sm_event(peer_address, BTIF_AV_AVRCP_OPEN_EVT);
4149 }
4150 }
4151