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