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