/******************************************************************************
|
*
|
* Copyright 2009-2016 Broadcom Corporation
|
*
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
* you may not use this file except in compliance with the License.
|
* You may obtain a copy of the License at:
|
*
|
* http://www.apache.org/licenses/LICENSE-2.0
|
*
|
* Unless required by applicable law or agreed to in writing, software
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
* See the License for the specific language governing permissions and
|
* limitations under the License.
|
*
|
******************************************************************************/
|
|
#define LOG_TAG "btif_av"
|
|
#include "btif_av.h"
|
|
#include <base/bind.h>
|
#include <base/logging.h>
|
#include <base/strings/stringprintf.h>
|
#include <string.h>
|
#include <map>
|
|
#include <hardware/bluetooth.h>
|
#include <hardware/bt_av.h>
|
#include <hardware/bt_rc.h>
|
|
#include "audio_a2dp_hw/include/audio_a2dp_hw.h"
|
#include "audio_hal_interface/a2dp_encoding.h"
|
#include "bt_common.h"
|
#include "bt_utils.h"
|
#include "bta/include/bta_api.h"
|
#include "btif/include/btif_a2dp_source.h"
|
#include "btif_a2dp.h"
|
#include "btif_a2dp_audio_interface.h"
|
#include "btif_a2dp_control.h"
|
#include "btif_a2dp_sink.h"
|
#include "btif_av_co.h"
|
#include "btif_profile_queue.h"
|
#include "btif_rc.h"
|
#include "btif_util.h"
|
#include "btu.h"
|
#include "common/state_machine.h"
|
#include "osi/include/allocator.h"
|
#include "osi/include/osi.h"
|
#include "osi/include/properties.h"
|
|
/*****************************************************************************
|
* Constants & Macros
|
*****************************************************************************/
|
static const std::string kBtifAvSourceServiceName = "Advanced Audio Source";
|
static const std::string kBtifAvSinkServiceName = "Advanced Audio Sink";
|
static constexpr int kDefaultMaxConnectedAudioDevices = 1;
|
static constexpr tBTA_AV_HNDL kBtaHandleUnknown = 0;
|
|
/*****************************************************************************
|
* Local type definitions
|
*****************************************************************************/
|
|
typedef struct {
|
int sample_rate;
|
int channel_count;
|
RawAddress peer_address;
|
} btif_av_sink_config_req_t;
|
|
/**
|
* BTIF AV events
|
*/
|
typedef enum {
|
/* Reuse BTA_AV_XXX_EVT - No need to redefine them here */
|
BTIF_AV_CONNECT_REQ_EVT = BTA_AV_MAX_EVT,
|
BTIF_AV_DISCONNECT_REQ_EVT,
|
BTIF_AV_START_STREAM_REQ_EVT,
|
BTIF_AV_STOP_STREAM_REQ_EVT,
|
BTIF_AV_SUSPEND_STREAM_REQ_EVT,
|
BTIF_AV_SINK_CONFIG_REQ_EVT,
|
BTIF_AV_ACL_DISCONNECTED,
|
BTIF_AV_OFFLOAD_START_REQ_EVT,
|
BTIF_AV_AVRCP_OPEN_EVT,
|
BTIF_AV_AVRCP_CLOSE_EVT,
|
BTIF_AV_AVRCP_REMOTE_PLAY_EVT,
|
} btif_av_sm_event_t;
|
|
class BtifAvEvent {
|
public:
|
BtifAvEvent(uint32_t event, const void* p_data, size_t data_length);
|
BtifAvEvent(const BtifAvEvent& other);
|
BtifAvEvent() = delete;
|
~BtifAvEvent();
|
BtifAvEvent& operator=(const BtifAvEvent& other);
|
|
uint32_t Event() const { return event_; }
|
void* Data() const { return data_; }
|
size_t DataLength() const { return data_length_; }
|
std::string ToString() const;
|
static std::string EventName(uint32_t event);
|
|
private:
|
void DeepCopy(uint32_t event, const void* p_data, size_t data_length);
|
void DeepFree();
|
|
uint32_t event_;
|
void* data_;
|
size_t data_length_;
|
};
|
|
class BtifAvPeer;
|
|
// Should not need dedicated Suspend state as actual actions are no
|
// different than Open state. Suspend flags are needed however to prevent
|
// media task from trying to restart stream during remote Suspend or while
|
// we are in the process of a local Suspend.
|
class BtifAvStateMachine : public bluetooth::common::StateMachine {
|
public:
|
enum {
|
kStateIdle, // AVDTP disconnected
|
kStateOpening, // Opening AVDTP connection
|
kStateOpened, // AVDTP is in OPEN state
|
kStateStarted, // A2DP stream started
|
kStateClosing, // Closing AVDTP connection
|
};
|
|
class StateIdle : public State {
|
public:
|
StateIdle(BtifAvStateMachine& sm)
|
: State(sm, kStateIdle), peer_(sm.Peer()) {}
|
void OnEnter() override;
|
void OnExit() override;
|
bool ProcessEvent(uint32_t event, void* p_data) override;
|
|
private:
|
BtifAvPeer& peer_;
|
};
|
|
class StateOpening : public State {
|
public:
|
StateOpening(BtifAvStateMachine& sm)
|
: State(sm, kStateOpening), peer_(sm.Peer()) {}
|
void OnEnter() override;
|
void OnExit() override;
|
bool ProcessEvent(uint32_t event, void* p_data) override;
|
|
private:
|
BtifAvPeer& peer_;
|
};
|
|
class StateOpened : public State {
|
public:
|
StateOpened(BtifAvStateMachine& sm)
|
: State(sm, kStateOpened), peer_(sm.Peer()) {}
|
void OnEnter() override;
|
void OnExit() override;
|
bool ProcessEvent(uint32_t event, void* p_data) override;
|
|
private:
|
BtifAvPeer& peer_;
|
};
|
|
class StateStarted : public State {
|
public:
|
StateStarted(BtifAvStateMachine& sm)
|
: State(sm, kStateStarted), peer_(sm.Peer()) {}
|
void OnEnter() override;
|
void OnExit() override;
|
bool ProcessEvent(uint32_t event, void* p_data) override;
|
|
private:
|
BtifAvPeer& peer_;
|
};
|
|
class StateClosing : public State {
|
public:
|
StateClosing(BtifAvStateMachine& sm)
|
: State(sm, kStateClosing), peer_(sm.Peer()) {}
|
void OnEnter() override;
|
void OnExit() override;
|
bool ProcessEvent(uint32_t event, void* p_data) override;
|
|
private:
|
BtifAvPeer& peer_;
|
};
|
|
BtifAvStateMachine(BtifAvPeer& btif_av_peer) : peer_(btif_av_peer) {
|
state_idle_ = new StateIdle(*this);
|
state_opening_ = new StateOpening(*this);
|
state_opened_ = new StateOpened(*this);
|
state_started_ = new StateStarted(*this);
|
state_closing_ = new StateClosing(*this);
|
|
AddState(state_idle_);
|
AddState(state_opening_);
|
AddState(state_opened_);
|
AddState(state_started_);
|
AddState(state_closing_);
|
SetInitialState(state_idle_);
|
}
|
|
BtifAvPeer& Peer() { return peer_; }
|
|
private:
|
BtifAvPeer& peer_;
|
StateIdle* state_idle_;
|
StateOpening* state_opening_;
|
StateOpened* state_opened_;
|
StateStarted* state_started_;
|
StateClosing* state_closing_;
|
};
|
|
class BtifAvPeer {
|
public:
|
enum {
|
kFlagLocalSuspendPending = 0x1,
|
kFlagRemoteSuspend = 0x2,
|
kFlagPendingStart = 0x4,
|
kFlagPendingStop = 0x8,
|
};
|
static constexpr uint64_t kTimeoutAvOpenOnRcMs = 2 * 1000; // 2s
|
|
BtifAvPeer(const RawAddress& peer_address, uint8_t peer_sep,
|
tBTA_AV_HNDL bta_handle, uint8_t peer_id);
|
~BtifAvPeer();
|
|
bt_status_t Init();
|
void Cleanup();
|
|
/**
|
* Check whether the peer can be deleted.
|
*
|
* @return true if the pair can be deleted, otherwise false
|
*/
|
bool CanBeDeleted() const;
|
|
/**
|
* Check whether the peer is the active one.
|
*
|
* @return true if this peer is the active one
|
*/
|
bool IsActivePeer() const { return (PeerAddress() == ActivePeerAddress()); }
|
|
/**
|
* Get the address of the active peer.
|
*
|
* @return the address of the active peer
|
*/
|
const RawAddress& ActivePeerAddress() const;
|
|
const RawAddress& PeerAddress() const { return peer_address_; }
|
bool IsSource() const { return (peer_sep_ == AVDT_TSEP_SRC); }
|
bool IsSink() const { return (peer_sep_ == AVDT_TSEP_SNK); }
|
uint8_t PeerSep() const { return peer_sep_; }
|
/**
|
* Get the local device's Service Class UUID
|
*
|
* @return the local device's Service Class UUID: UUID_SERVCLASS_AUDIO_SOURCE
|
* or UUID_SERVCLASS_AUDIO_SINK
|
*/
|
uint16_t LocalUuidServiceClass() const {
|
return (IsSink() ? UUID_SERVCLASS_AUDIO_SOURCE : UUID_SERVCLASS_AUDIO_SINK);
|
}
|
tBTA_AV_HNDL BtaHandle() const { return bta_handle_; }
|
void SetBtaHandle(tBTA_AV_HNDL bta_handle) { bta_handle_ = bta_handle; }
|
uint8_t PeerId() const { return peer_id_; }
|
|
BtifAvStateMachine& StateMachine() { return state_machine_; }
|
const BtifAvStateMachine& StateMachine() const { return state_machine_; }
|
alarm_t* AvOpenOnRcTimer() { return av_open_on_rc_timer_; }
|
const alarm_t* AvOpenOnRcTimer() const { return av_open_on_rc_timer_; }
|
|
void SetEdr(tBTA_AV_EDR edr) { edr_ = edr; }
|
bool IsEdr() const { return (edr_ != 0); }
|
bool Is3Mbps() const { return ((edr_ & BTA_AV_EDR_3MBPS) != 0); }
|
|
bool IsConnected() const;
|
bool IsStreaming() const;
|
bool IsInSilenceMode() const { return is_silenced_; };
|
|
void SetSilence(bool silence) { is_silenced_ = silence; };
|
|
/**
|
* Check whether any of the flags specified by the bitlags mask is set.
|
*
|
* @param bitflags_mask the bitflags to check
|
* @return true if any of the flags to check is set, otherwise false.
|
*/
|
bool CheckFlags(uint8_t bitflags_mask) const {
|
return ((flags_ & bitflags_mask) != 0);
|
}
|
|
/**
|
* Set only the flags as specified by the bitflags mask.
|
*
|
* @param bitflags_mask the bitflags to set
|
*/
|
void SetFlags(uint8_t bitflags_mask) { flags_ |= bitflags_mask; }
|
|
/**
|
* Clear only the flags as specified by the bitflags mask.
|
*
|
* @param bitflags_mask the bitflags to clear
|
*/
|
void ClearFlags(uint8_t bitflags_mask) { flags_ &= ~bitflags_mask; }
|
|
/**
|
* Clear all flags.
|
*/
|
void ClearAllFlags() { flags_ = 0; }
|
|
/**
|
* Get a string representation of the flags that are set.
|
*/
|
std::string FlagsToString() const;
|
|
bool SelfInitiatedConnection() const { return self_initiated_connection_; }
|
void SetSelfInitiatedConnection(bool v) { self_initiated_connection_ = v; }
|
|
private:
|
const RawAddress peer_address_;
|
const uint8_t peer_sep_; // SEP type of peer device
|
tBTA_AV_HNDL bta_handle_;
|
const uint8_t peer_id_;
|
BtifAvStateMachine state_machine_;
|
alarm_t* av_open_on_rc_timer_;
|
tBTA_AV_EDR edr_;
|
uint8_t flags_;
|
bool self_initiated_connection_;
|
bool is_silenced_;
|
};
|
|
class BtifAvSource {
|
public:
|
// The PeerId is used as AppId for BTA_AvRegister() purpose
|
static constexpr uint8_t kPeerIdMin = 0;
|
static constexpr uint8_t kPeerIdMax = BTA_AV_NUM_STRS;
|
|
BtifAvSource()
|
: callbacks_(nullptr),
|
enabled_(false),
|
a2dp_offload_enabled_(false),
|
max_connected_peers_(kDefaultMaxConnectedAudioDevices) {}
|
~BtifAvSource();
|
|
bt_status_t Init(
|
btav_source_callbacks_t* callbacks, int max_connected_audio_devices,
|
const std::vector<btav_a2dp_codec_config_t>& codec_priorities);
|
void Cleanup();
|
|
btav_source_callbacks_t* Callbacks() { return callbacks_; }
|
bool Enabled() const { return enabled_; }
|
bool A2dpOffloadEnabled() const { return a2dp_offload_enabled_; }
|
|
BtifAvPeer* FindPeer(const RawAddress& peer_address);
|
BtifAvPeer* FindPeerByHandle(tBTA_AV_HNDL bta_handle);
|
BtifAvPeer* FindPeerByPeerId(uint8_t peer_id);
|
BtifAvPeer* FindOrCreatePeer(const RawAddress& peer_address,
|
tBTA_AV_HNDL bta_handle);
|
|
/**
|
* Check whether a connection to a peer is allowed.
|
* The check considers the maximum number of connected peers.
|
*
|
* @param peer_address the peer address to connect to
|
* @return true if connection is allowed, otherwise false
|
*/
|
bool AllowedToConnect(const RawAddress& peer_address) const;
|
|
/**
|
* Delete a peer.
|
*
|
* @param peer_address the peer to delete
|
* @return true on success, otherwise false
|
*/
|
bool DeletePeer(const RawAddress& peer_address);
|
|
/**
|
* Delete all peers that have transitioned to Idle state and can be deleted.
|
* If a peer was just created/initialized, then it cannot be deleted yet.
|
*/
|
void DeleteIdlePeers();
|
|
/**
|
* Get the active peer.
|
*
|
* @return the active peer
|
*/
|
const RawAddress& ActivePeer() const { return active_peer_; }
|
|
/**
|
* Check whether peer is silenced
|
*
|
* @param peer_address the peer to check
|
* @return true on silence mode enabled, otherwise false
|
*/
|
bool IsPeerSilenced(const RawAddress& peer_address) {
|
if (peer_address.IsEmpty()) {
|
return false;
|
}
|
BtifAvPeer* peer = FindPeer(peer_address);
|
if (peer == nullptr) {
|
BTIF_TRACE_WARNING("%s: peer is null", __func__);
|
return false;
|
}
|
if (!peer->IsConnected()) {
|
BTIF_TRACE_WARNING("%s: peer is not connected", __func__);
|
return false;
|
}
|
return peer->IsInSilenceMode();
|
}
|
|
/**
|
* Set peer silence mode
|
*
|
* @param peer_address the peer to set
|
* @param silence true on enable silence mode, false on disable
|
* @return true on success, otherwise false
|
*/
|
bool SetSilencePeer(const RawAddress& peer_address, const bool silence) {
|
if (peer_address.IsEmpty()) {
|
return false;
|
}
|
LOG_INFO(LOG_TAG, "%s: peer: %s", __PRETTY_FUNCTION__,
|
peer_address.ToString().c_str());
|
BtifAvPeer* peer = FindPeer(peer_address);
|
if (peer == nullptr) {
|
BTIF_TRACE_WARNING("%s: peer is null", __func__);
|
return false;
|
}
|
if (!peer->IsConnected()) {
|
BTIF_TRACE_WARNING("%s: peer is not connected", __func__);
|
return false;
|
}
|
peer->SetSilence(silence);
|
return true;
|
}
|
|
/**
|
* Set the active peer.
|
*
|
* @param peer_address the active peer address or RawAddress::kEmpty to
|
* reset the active peer
|
* @return true on success, otherwise false
|
*/
|
bool SetActivePeer(const RawAddress& peer_address,
|
std::promise<void> peer_ready_promise) {
|
LOG(INFO) << __PRETTY_FUNCTION__ << ": peer: " << peer_address;
|
|
if (active_peer_ == peer_address) {
|
peer_ready_promise.set_value();
|
return true; // Nothing has changed
|
}
|
if (peer_address.IsEmpty()) {
|
BTIF_TRACE_EVENT("%s: peer address is empty, shutdown the Audio source",
|
__func__);
|
if (!bta_av_co_set_active_peer(peer_address)) {
|
LOG(WARNING) << __func__
|
<< ": unable to set active peer to empty in BtaAvCo";
|
}
|
btif_a2dp_source_end_session(active_peer_);
|
btif_a2dp_source_shutdown();
|
active_peer_ = peer_address;
|
peer_ready_promise.set_value();
|
return true;
|
}
|
|
BtifAvPeer* peer = FindPeer(peer_address);
|
if (peer != nullptr && !peer->IsConnected()) {
|
LOG(ERROR) << __func__ << ": Error setting " << peer->PeerAddress()
|
<< " as active Source peer";
|
peer_ready_promise.set_value();
|
return false;
|
}
|
|
if (!btif_a2dp_source_restart_session(active_peer_, peer_address,
|
std::move(peer_ready_promise))) {
|
// cannot set promise but need to be handled within restart_session
|
return false;
|
}
|
active_peer_ = peer_address;
|
return true;
|
}
|
|
/**
|
* Update source codec configuration for a peer.
|
*
|
* @param peer_address the address of the peer to update
|
* @param codec_preferences the updated codec preferences
|
*/
|
void UpdateCodecConfig(
|
const RawAddress& peer_address,
|
const std::vector<btav_a2dp_codec_config_t>& codec_preferences,
|
std::promise<void> peer_ready_promise) {
|
// Restart the session if the codec for the active peer is updated
|
bool restart_session =
|
((active_peer_ == peer_address) && !active_peer_.IsEmpty());
|
if (restart_session) {
|
btif_a2dp_source_end_session(active_peer_);
|
}
|
|
for (auto cp : codec_preferences) {
|
BTIF_TRACE_DEBUG("%s: codec_preference=%s", __func__,
|
cp.ToString().c_str());
|
btif_a2dp_source_encoder_user_config_update_req(peer_address, cp);
|
}
|
if (restart_session) {
|
btif_a2dp_source_start_session(active_peer_,
|
std::move(peer_ready_promise));
|
} else {
|
peer_ready_promise.set_value();
|
}
|
}
|
|
const std::map<RawAddress, BtifAvPeer*>& Peers() const { return peers_; }
|
|
void RegisterAllBtaHandles();
|
void DeregisterAllBtaHandles();
|
void BtaHandleRegistered(uint8_t peer_id, tBTA_AV_HNDL bta_handle);
|
|
private:
|
void CleanupAllPeers();
|
|
btav_source_callbacks_t* callbacks_;
|
bool enabled_;
|
bool a2dp_offload_enabled_;
|
int max_connected_peers_;
|
std::map<RawAddress, BtifAvPeer*> peers_;
|
std::set<RawAddress> silenced_peers_;
|
RawAddress active_peer_;
|
std::map<uint8_t, tBTA_AV_HNDL> peer_id2bta_handle_;
|
};
|
|
class BtifAvSink {
|
public:
|
// The PeerId is used as AppId for BTA_AvRegister() purpose
|
static constexpr uint8_t kPeerIdMin = 0;
|
static constexpr uint8_t kPeerIdMax = BTA_AV_NUM_STRS;
|
|
BtifAvSink()
|
: callbacks_(nullptr),
|
enabled_(false),
|
max_connected_peers_(kDefaultMaxConnectedAudioDevices) {}
|
~BtifAvSink();
|
|
bt_status_t Init(btav_sink_callbacks_t* callbacks);
|
void Cleanup();
|
|
btav_sink_callbacks_t* Callbacks() { return callbacks_; }
|
bool Enabled() const { return enabled_; }
|
|
BtifAvPeer* FindPeer(const RawAddress& peer_address);
|
BtifAvPeer* FindPeerByHandle(tBTA_AV_HNDL bta_handle);
|
BtifAvPeer* FindPeerByPeerId(uint8_t peer_id);
|
BtifAvPeer* FindOrCreatePeer(const RawAddress& peer_address,
|
tBTA_AV_HNDL bta_handle);
|
|
/**
|
* Check whether a connection to a peer is allowed.
|
* The check considers the maximum number of connected peers.
|
*
|
* @param peer_address the peer address to connect to
|
* @return true if connection is allowed, otherwise false
|
*/
|
bool AllowedToConnect(const RawAddress& peer_address) const;
|
|
/**
|
* Delete a peer.
|
*
|
* @param peer_address the peer to delete
|
* @return true on success, otherwise false
|
*/
|
bool DeletePeer(const RawAddress& peer_address);
|
|
/**
|
* Delete all peers that have transitioned to Idle state and can be deleted.
|
* If a peer was just created/initialized, then it cannot be deleted yet.
|
*/
|
void DeleteIdlePeers();
|
|
/**
|
* Get the active peer.
|
*
|
* @return the active peer
|
*/
|
const RawAddress& ActivePeer() const { return active_peer_; }
|
|
/**
|
* Set the active peer.
|
*
|
* @param peer_address the active peer address or RawAddress::kEmpty to
|
* reset the active peer
|
* @return true on success, otherwise false
|
*/
|
bool SetActivePeer(const RawAddress& peer_address,
|
std::promise<void> peer_ready_promise) {
|
LOG(INFO) << __PRETTY_FUNCTION__ << ": peer: " << peer_address;
|
|
if (active_peer_ == peer_address) {
|
peer_ready_promise.set_value();
|
return true; // Nothing has changed
|
}
|
if (peer_address.IsEmpty()) {
|
BTIF_TRACE_EVENT("%s: peer address is empty, shutdown the Audio sink",
|
__func__);
|
if (!bta_av_co_set_active_peer(peer_address)) {
|
LOG(WARNING) << __func__
|
<< ": unable to set active peer to empty in BtaAvCo";
|
}
|
btif_a2dp_sink_end_session(active_peer_);
|
btif_a2dp_sink_shutdown();
|
active_peer_ = peer_address;
|
peer_ready_promise.set_value();
|
return true;
|
}
|
|
BtifAvPeer* peer = FindPeer(peer_address);
|
if (peer != nullptr && !peer->IsConnected()) {
|
LOG(ERROR) << __func__ << ": Error setting " << peer->PeerAddress()
|
<< " as active Sink peer";
|
peer_ready_promise.set_value();
|
return false;
|
}
|
|
if (!btif_a2dp_sink_restart_session(active_peer_, peer_address,
|
std::move(peer_ready_promise))) {
|
// cannot set promise but need to be handled within restart_session
|
return false;
|
}
|
active_peer_ = peer_address;
|
return true;
|
}
|
|
const std::map<RawAddress, BtifAvPeer*>& Peers() const { return peers_; }
|
|
void RegisterAllBtaHandles();
|
void DeregisterAllBtaHandles();
|
void BtaHandleRegistered(uint8_t peer_id, tBTA_AV_HNDL bta_handle);
|
|
private:
|
void CleanupAllPeers();
|
|
btav_sink_callbacks_t* callbacks_;
|
bool enabled_;
|
int max_connected_peers_;
|
std::map<RawAddress, BtifAvPeer*> peers_;
|
RawAddress active_peer_;
|
std::map<uint8_t, tBTA_AV_HNDL> peer_id2bta_handle_;
|
};
|
|
/*****************************************************************************
|
* Static variables
|
*****************************************************************************/
|
static BtifAvSource btif_av_source;
|
static BtifAvSink btif_av_sink;
|
|
/* Helper macro to avoid code duplication in the state machine handlers */
|
#define CHECK_RC_EVENT(e, d) \
|
case BTA_AV_RC_OPEN_EVT: \
|
case BTA_AV_RC_BROWSE_OPEN_EVT: \
|
case BTA_AV_RC_CLOSE_EVT: \
|
case BTA_AV_RC_BROWSE_CLOSE_EVT: \
|
case BTA_AV_REMOTE_CMD_EVT: \
|
case BTA_AV_VENDOR_CMD_EVT: \
|
case BTA_AV_META_MSG_EVT: \
|
case BTA_AV_RC_FEAT_EVT: \
|
case BTA_AV_REMOTE_RSP_EVT: { \
|
btif_rc_handler(e, d); \
|
} break;
|
|
static bt_status_t src_disconnect_sink(const RawAddress& peer_address);
|
static bt_status_t sink_disconnect_src(const RawAddress& peer_address);
|
static void btif_av_source_dispatch_sm_event(const RawAddress& peer_address,
|
btif_av_sm_event_t event);
|
static void btif_av_sink_dispatch_sm_event(const RawAddress& peer_address,
|
btif_av_sm_event_t event);
|
static void btif_av_handle_event(uint8_t peer_sep,
|
const RawAddress& peer_address,
|
tBTA_AV_HNDL bta_handle,
|
const BtifAvEvent& btif_av_event);
|
static void btif_report_connection_state(const RawAddress& peer_address,
|
btav_connection_state_t state);
|
static void btif_report_audio_state(const RawAddress& peer_address,
|
btav_audio_state_t state);
|
static void btif_av_report_sink_audio_config_state(
|
const RawAddress& peer_address, int sample_rate, int channel_count);
|
static void btif_av_source_initiate_av_open_timer_timeout(void* data);
|
static void btif_av_sink_initiate_av_open_timer_timeout(void* data);
|
static void bta_av_sink_media_callback(tBTA_AV_EVT event,
|
tBTA_AV_MEDIA* p_data);
|
|
static BtifAvPeer* btif_av_source_find_peer(const RawAddress& peer_address) {
|
return btif_av_source.FindPeer(peer_address);
|
}
|
static BtifAvPeer* btif_av_sink_find_peer(const RawAddress& peer_address) {
|
return btif_av_sink.FindPeer(peer_address);
|
}
|
static BtifAvPeer* btif_av_find_peer(const RawAddress& peer_address) {
|
if (btif_av_source.Enabled()) return btif_av_source_find_peer(peer_address);
|
if (btif_av_sink.Enabled()) return btif_av_sink_find_peer(peer_address);
|
return nullptr;
|
}
|
static BtifAvPeer* btif_av_find_active_peer() {
|
if (btif_av_source.Enabled())
|
return btif_av_source_find_peer(btif_av_source.ActivePeer());
|
if (btif_av_sink.Enabled())
|
return btif_av_sink_find_peer(btif_av_sink.ActivePeer());
|
return nullptr;
|
}
|
|
/*****************************************************************************
|
* Local helper functions
|
*****************************************************************************/
|
|
const char* dump_av_sm_event_name(btif_av_sm_event_t event) {
|
switch ((int)event) {
|
CASE_RETURN_STR(BTA_AV_ENABLE_EVT)
|
CASE_RETURN_STR(BTA_AV_REGISTER_EVT)
|
CASE_RETURN_STR(BTA_AV_OPEN_EVT)
|
CASE_RETURN_STR(BTA_AV_CLOSE_EVT)
|
CASE_RETURN_STR(BTA_AV_START_EVT)
|
CASE_RETURN_STR(BTA_AV_STOP_EVT)
|
CASE_RETURN_STR(BTA_AV_PROTECT_REQ_EVT)
|
CASE_RETURN_STR(BTA_AV_PROTECT_RSP_EVT)
|
CASE_RETURN_STR(BTA_AV_RC_OPEN_EVT)
|
CASE_RETURN_STR(BTA_AV_RC_CLOSE_EVT)
|
CASE_RETURN_STR(BTA_AV_RC_BROWSE_OPEN_EVT)
|
CASE_RETURN_STR(BTA_AV_RC_BROWSE_CLOSE_EVT)
|
CASE_RETURN_STR(BTA_AV_REMOTE_CMD_EVT)
|
CASE_RETURN_STR(BTA_AV_REMOTE_RSP_EVT)
|
CASE_RETURN_STR(BTA_AV_VENDOR_CMD_EVT)
|
CASE_RETURN_STR(BTA_AV_VENDOR_RSP_EVT)
|
CASE_RETURN_STR(BTA_AV_RECONFIG_EVT)
|
CASE_RETURN_STR(BTA_AV_SUSPEND_EVT)
|
CASE_RETURN_STR(BTA_AV_PENDING_EVT)
|
CASE_RETURN_STR(BTA_AV_META_MSG_EVT)
|
CASE_RETURN_STR(BTA_AV_REJECT_EVT)
|
CASE_RETURN_STR(BTA_AV_RC_FEAT_EVT)
|
CASE_RETURN_STR(BTA_AV_OFFLOAD_START_RSP_EVT)
|
CASE_RETURN_STR(BTIF_AV_CONNECT_REQ_EVT)
|
CASE_RETURN_STR(BTIF_AV_DISCONNECT_REQ_EVT)
|
CASE_RETURN_STR(BTIF_AV_START_STREAM_REQ_EVT)
|
CASE_RETURN_STR(BTIF_AV_STOP_STREAM_REQ_EVT)
|
CASE_RETURN_STR(BTIF_AV_SUSPEND_STREAM_REQ_EVT)
|
CASE_RETURN_STR(BTIF_AV_SINK_CONFIG_REQ_EVT)
|
CASE_RETURN_STR(BTIF_AV_ACL_DISCONNECTED)
|
CASE_RETURN_STR(BTIF_AV_OFFLOAD_START_REQ_EVT)
|
CASE_RETURN_STR(BTIF_AV_AVRCP_OPEN_EVT)
|
CASE_RETURN_STR(BTIF_AV_AVRCP_CLOSE_EVT)
|
CASE_RETURN_STR(BTIF_AV_AVRCP_REMOTE_PLAY_EVT)
|
default:
|
return "UNKNOWN_EVENT";
|
}
|
}
|
|
BtifAvEvent::BtifAvEvent(uint32_t event, const void* p_data, size_t data_length)
|
: event_(event), data_(nullptr), data_length_(0) {
|
DeepCopy(event, p_data, data_length);
|
}
|
|
BtifAvEvent::BtifAvEvent(const BtifAvEvent& other)
|
: event_(0), data_(nullptr), data_length_(0) {
|
*this = other;
|
}
|
|
BtifAvEvent& BtifAvEvent::operator=(const BtifAvEvent& other) {
|
DeepFree();
|
DeepCopy(other.Event(), other.Data(), other.DataLength());
|
return *this;
|
}
|
|
BtifAvEvent::~BtifAvEvent() { DeepFree(); }
|
|
std::string BtifAvEvent::ToString() const {
|
return BtifAvEvent::EventName(event_);
|
}
|
|
std::string BtifAvEvent::EventName(uint32_t event) {
|
std::string name = dump_av_sm_event_name((btif_av_sm_event_t)event);
|
std::stringstream ss_value;
|
ss_value << "(0x" << std::hex << event << ")";
|
return name + ss_value.str();
|
}
|
|
void BtifAvEvent::DeepCopy(uint32_t event, const void* p_data,
|
size_t data_length) {
|
event_ = event;
|
data_length_ = data_length;
|
if (data_length == 0) {
|
data_ = nullptr;
|
} else {
|
data_ = osi_malloc(data_length_);
|
memcpy(data_, p_data, data_length);
|
}
|
|
switch (event) {
|
case BTA_AV_META_MSG_EVT: {
|
CHECK(data_length >= sizeof(tBTA_AV));
|
const tBTA_AV* av_src = (const tBTA_AV*)p_data;
|
tBTA_AV* av_dest = (tBTA_AV*)data_;
|
if (av_src->meta_msg.p_data && av_src->meta_msg.len) {
|
av_dest->meta_msg.p_data = (uint8_t*)osi_calloc(av_src->meta_msg.len);
|
memcpy(av_dest->meta_msg.p_data, av_src->meta_msg.p_data,
|
av_src->meta_msg.len);
|
}
|
|
if (av_src->meta_msg.p_msg) {
|
av_dest->meta_msg.p_msg = (tAVRC_MSG*)osi_calloc(sizeof(tAVRC_MSG));
|
memcpy(av_dest->meta_msg.p_msg, av_src->meta_msg.p_msg,
|
sizeof(tAVRC_MSG));
|
|
tAVRC_MSG* p_msg_src = av_src->meta_msg.p_msg;
|
tAVRC_MSG* p_msg_dest = av_dest->meta_msg.p_msg;
|
|
if ((p_msg_src->hdr.opcode == AVRC_OP_VENDOR) &&
|
(p_msg_src->vendor.p_vendor_data && p_msg_src->vendor.vendor_len)) {
|
p_msg_dest->vendor.p_vendor_data =
|
(uint8_t*)osi_calloc(p_msg_src->vendor.vendor_len);
|
memcpy(p_msg_dest->vendor.p_vendor_data,
|
p_msg_src->vendor.p_vendor_data, p_msg_src->vendor.vendor_len);
|
}
|
if ((p_msg_src->hdr.opcode == AVRC_OP_BROWSE) &&
|
p_msg_src->browse.p_browse_data && p_msg_src->browse.browse_len) {
|
p_msg_dest->browse.p_browse_data =
|
(uint8_t*)osi_calloc(p_msg_src->browse.browse_len);
|
memcpy(p_msg_dest->browse.p_browse_data,
|
p_msg_src->browse.p_browse_data, p_msg_src->browse.browse_len);
|
}
|
}
|
} break;
|
|
default:
|
break;
|
}
|
}
|
|
void BtifAvEvent::DeepFree() {
|
switch (event_) {
|
case BTA_AV_META_MSG_EVT: {
|
tBTA_AV* av = (tBTA_AV*)data_;
|
osi_free_and_reset((void**)&av->meta_msg.p_data);
|
|
if (av->meta_msg.p_msg) {
|
if (av->meta_msg.p_msg->hdr.opcode == AVRC_OP_VENDOR) {
|
osi_free(av->meta_msg.p_msg->vendor.p_vendor_data);
|
}
|
if (av->meta_msg.p_msg->hdr.opcode == AVRC_OP_BROWSE) {
|
osi_free(av->meta_msg.p_msg->browse.p_browse_data);
|
}
|
osi_free_and_reset((void**)&av->meta_msg.p_msg);
|
}
|
} break;
|
|
default:
|
break;
|
}
|
|
osi_free_and_reset((void**)&data_);
|
data_length_ = 0;
|
}
|
|
BtifAvPeer::BtifAvPeer(const RawAddress& peer_address, uint8_t peer_sep,
|
tBTA_AV_HNDL bta_handle, uint8_t peer_id)
|
: peer_address_(peer_address),
|
peer_sep_(peer_sep),
|
bta_handle_(bta_handle),
|
peer_id_(peer_id),
|
state_machine_(*this),
|
av_open_on_rc_timer_(nullptr),
|
edr_(0),
|
flags_(0),
|
self_initiated_connection_(false) {}
|
|
BtifAvPeer::~BtifAvPeer() { alarm_free(av_open_on_rc_timer_); }
|
|
std::string BtifAvPeer::FlagsToString() const {
|
std::string result;
|
|
if (flags_ & BtifAvPeer::kFlagLocalSuspendPending) {
|
if (!result.empty()) result += "|";
|
result += "LOCAL_SUSPEND_PENDING";
|
}
|
if (flags_ & BtifAvPeer::kFlagRemoteSuspend) {
|
if (!result.empty()) result += "|";
|
result += "REMOTE_SUSPEND";
|
}
|
if (flags_ & BtifAvPeer::kFlagPendingStart) {
|
if (!result.empty()) result += "|";
|
result += "PENDING_START";
|
}
|
if (flags_ & BtifAvPeer::kFlagPendingStop) {
|
if (!result.empty()) result += "|";
|
result += "PENDING_STOP";
|
}
|
if (result.empty()) result = "None";
|
|
return base::StringPrintf("0x%x(%s)", flags_, result.c_str());
|
}
|
|
bt_status_t BtifAvPeer::Init() {
|
alarm_free(av_open_on_rc_timer_);
|
av_open_on_rc_timer_ = alarm_new("btif_av_peer.av_open_on_rc_timer");
|
is_silenced_ = false;
|
|
state_machine_.Start();
|
return BT_STATUS_SUCCESS;
|
}
|
|
void BtifAvPeer::Cleanup() {
|
state_machine_.Quit();
|
alarm_free(av_open_on_rc_timer_);
|
av_open_on_rc_timer_ = nullptr;
|
}
|
|
bool BtifAvPeer::CanBeDeleted() const {
|
return (
|
(state_machine_.StateId() == BtifAvStateMachine::kStateIdle) &&
|
(state_machine_.PreviousStateId() != BtifAvStateMachine::kStateInvalid));
|
}
|
|
const RawAddress& BtifAvPeer::ActivePeerAddress() const {
|
if (IsSource()) {
|
return btif_av_sink.ActivePeer();
|
}
|
if (IsSink()) {
|
return btif_av_source.ActivePeer();
|
}
|
LOG(FATAL) << __PRETTY_FUNCTION__ << ": A2DP peer " << PeerAddress()
|
<< " is neither Source nor Sink";
|
return RawAddress::kEmpty;
|
}
|
|
bool BtifAvPeer::IsConnected() const {
|
int state = state_machine_.StateId();
|
return ((state == BtifAvStateMachine::kStateOpened) ||
|
(state == BtifAvStateMachine::kStateStarted));
|
}
|
|
bool BtifAvPeer::IsStreaming() const {
|
int state = state_machine_.StateId();
|
return (state == BtifAvStateMachine::kStateStarted);
|
}
|
|
BtifAvSource::~BtifAvSource() { CleanupAllPeers(); }
|
|
bt_status_t BtifAvSource::Init(
|
btav_source_callbacks_t* callbacks, int max_connected_audio_devices,
|
const std::vector<btav_a2dp_codec_config_t>& codec_priorities) {
|
LOG_INFO(LOG_TAG, "%s: max_connected_audio_devices=%d", __PRETTY_FUNCTION__,
|
max_connected_audio_devices);
|
if (enabled_) return BT_STATUS_SUCCESS;
|
CleanupAllPeers();
|
max_connected_peers_ = max_connected_audio_devices;
|
|
/* A2DP OFFLOAD */
|
char value_sup[PROPERTY_VALUE_MAX] = {'\0'};
|
char value_dis[PROPERTY_VALUE_MAX] = {'\0'};
|
osi_property_get("ro.bluetooth.a2dp_offload.supported", value_sup, "false");
|
osi_property_get("persist.bluetooth.a2dp_offload.disabled", value_dis,
|
"false");
|
a2dp_offload_enabled_ =
|
(strcmp(value_sup, "true") == 0) && (strcmp(value_dis, "false") == 0);
|
BTIF_TRACE_DEBUG("a2dp_offload.enable = %d", a2dp_offload_enabled_);
|
|
callbacks_ = callbacks;
|
bta_av_co_init(codec_priorities);
|
|
if (!btif_a2dp_source_init()) {
|
return BT_STATUS_FAIL;
|
}
|
btif_enable_service(BTA_A2DP_SOURCE_SERVICE_ID);
|
enabled_ = true;
|
return BT_STATUS_SUCCESS;
|
}
|
|
void BtifAvSource::Cleanup() {
|
LOG_INFO(LOG_TAG, "%s", __PRETTY_FUNCTION__);
|
if (!enabled_) return;
|
|
btif_queue_cleanup(UUID_SERVCLASS_AUDIO_SOURCE);
|
|
std::promise<void> peer_ready_promise;
|
do_in_main_thread(
|
FROM_HERE,
|
base::BindOnce(base::IgnoreResult(&BtifAvSource::SetActivePeer),
|
base::Unretained(&btif_av_source), RawAddress::kEmpty,
|
std::move(peer_ready_promise)));
|
do_in_main_thread(FROM_HERE, base::Bind(&btif_a2dp_source_cleanup));
|
|
btif_disable_service(BTA_A2DP_SOURCE_SERVICE_ID);
|
CleanupAllPeers();
|
|
callbacks_ = nullptr;
|
enabled_ = false;
|
}
|
|
BtifAvPeer* BtifAvSource::FindPeer(const RawAddress& peer_address) {
|
auto it = peers_.find(peer_address);
|
if (it != peers_.end()) return it->second;
|
return nullptr;
|
}
|
|
BtifAvPeer* BtifAvSource::FindPeerByHandle(tBTA_AV_HNDL bta_handle) {
|
for (auto it : peers_) {
|
BtifAvPeer* peer = it.second;
|
if (peer->BtaHandle() == bta_handle) {
|
return peer;
|
}
|
}
|
return nullptr;
|
}
|
|
BtifAvPeer* BtifAvSource::FindPeerByPeerId(uint8_t peer_id) {
|
for (auto it : peers_) {
|
BtifAvPeer* peer = it.second;
|
if (peer->PeerId() == peer_id) {
|
return peer;
|
}
|
}
|
return nullptr;
|
}
|
|
BtifAvPeer* BtifAvSource::FindOrCreatePeer(const RawAddress& peer_address,
|
tBTA_AV_HNDL bta_handle) {
|
BTIF_TRACE_DEBUG("%s: peer_address=%s bta_handle=0x%x", __PRETTY_FUNCTION__,
|
peer_address.ToString().c_str(), bta_handle);
|
|
BtifAvPeer* peer = FindPeer(peer_address);
|
if (peer != nullptr) return peer;
|
|
// Find next availabie Peer ID to use
|
uint8_t peer_id;
|
for (peer_id = kPeerIdMin; peer_id < kPeerIdMax; peer_id++) {
|
if (FindPeerByPeerId(peer_id) == nullptr) break;
|
}
|
if (peer_id == kPeerIdMax) {
|
BTIF_TRACE_ERROR(
|
"%s: Cannot create peer for peer_address=%s : "
|
"cannot allocate unique Peer ID",
|
__PRETTY_FUNCTION__, peer_address.ToString().c_str());
|
return nullptr;
|
}
|
// Get the BTA Handle (if known)
|
if (bta_handle == kBtaHandleUnknown) {
|
auto it = peer_id2bta_handle_.find(peer_id);
|
if (it != peer_id2bta_handle_.end()) {
|
bta_handle = it->second;
|
}
|
}
|
|
LOG_INFO(LOG_TAG,
|
"%s: Create peer: peer_address=%s bta_handle=0x%x peer_id=%d",
|
__PRETTY_FUNCTION__, peer_address.ToString().c_str(), bta_handle,
|
peer_id);
|
peer = new BtifAvPeer(peer_address, AVDT_TSEP_SNK, bta_handle, peer_id);
|
peers_.insert(std::make_pair(peer_address, peer));
|
peer->Init();
|
return peer;
|
}
|
|
bool BtifAvSource::AllowedToConnect(const RawAddress& peer_address) const {
|
int connected = 0;
|
|
// Count peers that are in the process of connecting or already connected
|
for (auto it : peers_) {
|
const BtifAvPeer* peer = it.second;
|
switch (peer->StateMachine().StateId()) {
|
case BtifAvStateMachine::kStateOpening:
|
case BtifAvStateMachine::kStateOpened:
|
case BtifAvStateMachine::kStateStarted:
|
if (peer->PeerAddress() == peer_address) {
|
return true; // Already connected or accounted for
|
}
|
connected++;
|
break;
|
default:
|
break;
|
}
|
}
|
return (connected < max_connected_peers_);
|
}
|
|
bool BtifAvSource::DeletePeer(const RawAddress& peer_address) {
|
auto it = peers_.find(peer_address);
|
if (it == peers_.end()) return false;
|
BtifAvPeer* peer = it->second;
|
peer->Cleanup();
|
peers_.erase(it);
|
delete peer;
|
return true;
|
}
|
|
void BtifAvSource::DeleteIdlePeers() {
|
for (auto it = peers_.begin(); it != peers_.end();) {
|
BtifAvPeer* peer = it->second;
|
auto prev_it = it++;
|
if (!peer->CanBeDeleted()) continue;
|
LOG_INFO(LOG_TAG, "%s: Deleting idle peer: %s bta_handle=0x%x", __func__,
|
peer->PeerAddress().ToString().c_str(), peer->BtaHandle());
|
peer->Cleanup();
|
peers_.erase(prev_it);
|
delete peer;
|
}
|
}
|
|
void BtifAvSource::CleanupAllPeers() {
|
while (!peers_.empty()) {
|
auto it = peers_.begin();
|
BtifAvPeer* peer = it->second;
|
peer->Cleanup();
|
peers_.erase(it);
|
delete peer;
|
}
|
}
|
|
void BtifAvSource::RegisterAllBtaHandles() {
|
for (int peer_id = kPeerIdMin; peer_id < kPeerIdMax; peer_id++) {
|
BTA_AvRegister(BTA_AV_CHNL_AUDIO, kBtifAvSourceServiceName.c_str(), peer_id,
|
nullptr, UUID_SERVCLASS_AUDIO_SOURCE);
|
}
|
}
|
|
void BtifAvSource::DeregisterAllBtaHandles() {
|
for (auto it : peer_id2bta_handle_) {
|
tBTA_AV_HNDL bta_handle = it.second;
|
BTA_AvDeregister(bta_handle);
|
}
|
peer_id2bta_handle_.clear();
|
}
|
|
void BtifAvSource::BtaHandleRegistered(uint8_t peer_id,
|
tBTA_AV_HNDL bta_handle) {
|
peer_id2bta_handle_.insert(std::make_pair(peer_id, bta_handle));
|
|
// Set the BTA Handle for the Peer (if exists)
|
BtifAvPeer* peer = FindPeerByPeerId(peer_id);
|
if (peer != nullptr) {
|
peer->SetBtaHandle(bta_handle);
|
}
|
}
|
|
BtifAvSink::~BtifAvSink() { CleanupAllPeers(); }
|
|
bt_status_t BtifAvSink::Init(btav_sink_callbacks_t* callbacks) {
|
LOG_INFO(LOG_TAG, "%s", __PRETTY_FUNCTION__);
|
if (enabled_) return BT_STATUS_SUCCESS;
|
|
CleanupAllPeers();
|
max_connected_peers_ = kDefaultMaxConnectedAudioDevices;
|
callbacks_ = callbacks;
|
|
std::vector<btav_a2dp_codec_config_t> codec_priorities; // Default priorities
|
bta_av_co_init(codec_priorities);
|
|
if (!btif_a2dp_sink_init()) {
|
return BT_STATUS_FAIL;
|
}
|
btif_enable_service(BTA_A2DP_SINK_SERVICE_ID);
|
enabled_ = true;
|
return BT_STATUS_SUCCESS;
|
}
|
|
void BtifAvSink::Cleanup() {
|
LOG_INFO(LOG_TAG, "%s", __PRETTY_FUNCTION__);
|
if (!enabled_) return;
|
|
btif_queue_cleanup(UUID_SERVCLASS_AUDIO_SINK);
|
|
std::promise<void> peer_ready_promise;
|
do_in_main_thread(
|
FROM_HERE,
|
base::BindOnce(base::IgnoreResult(&BtifAvSink::SetActivePeer),
|
base::Unretained(&btif_av_sink), RawAddress::kEmpty,
|
std::move(peer_ready_promise)));
|
do_in_main_thread(FROM_HERE, base::Bind(&btif_a2dp_sink_cleanup));
|
|
btif_disable_service(BTA_A2DP_SINK_SERVICE_ID);
|
CleanupAllPeers();
|
|
callbacks_ = nullptr;
|
enabled_ = false;
|
}
|
|
BtifAvPeer* BtifAvSink::FindPeer(const RawAddress& peer_address) {
|
auto it = peers_.find(peer_address);
|
if (it != peers_.end()) return it->second;
|
return nullptr;
|
}
|
|
BtifAvPeer* BtifAvSink::FindPeerByHandle(tBTA_AV_HNDL bta_handle) {
|
for (auto it : peers_) {
|
BtifAvPeer* peer = it.second;
|
if (peer->BtaHandle() == bta_handle) {
|
return peer;
|
}
|
}
|
return nullptr;
|
}
|
|
BtifAvPeer* BtifAvSink::FindPeerByPeerId(uint8_t peer_id) {
|
for (auto it : peers_) {
|
BtifAvPeer* peer = it.second;
|
if (peer->PeerId() == peer_id) {
|
return peer;
|
}
|
}
|
return nullptr;
|
}
|
|
BtifAvPeer* BtifAvSink::FindOrCreatePeer(const RawAddress& peer_address,
|
tBTA_AV_HNDL bta_handle) {
|
BTIF_TRACE_DEBUG("%s: peer_address=%s bta_handle=0x%x", __PRETTY_FUNCTION__,
|
peer_address.ToString().c_str(), bta_handle);
|
|
BtifAvPeer* peer = FindPeer(peer_address);
|
if (peer != nullptr) return peer;
|
|
// Find next availabie Peer ID to use
|
uint8_t peer_id;
|
for (peer_id = kPeerIdMin; peer_id < kPeerIdMax; peer_id++) {
|
if (FindPeerByPeerId(peer_id) == nullptr) break;
|
}
|
if (peer_id == kPeerIdMax) {
|
BTIF_TRACE_ERROR(
|
"%s: Cannot create peer for peer_address=%s : "
|
"cannot allocate unique Peer ID",
|
__PRETTY_FUNCTION__, peer_address.ToString().c_str());
|
return nullptr;
|
}
|
|
// Get the BTA Handle (if known)
|
if (bta_handle == kBtaHandleUnknown) {
|
auto it = peer_id2bta_handle_.find(peer_id);
|
if (it != peer_id2bta_handle_.end()) {
|
bta_handle = it->second;
|
}
|
}
|
|
LOG_INFO(LOG_TAG,
|
"%s: Create peer: peer_address=%s bta_handle=0x%x peer_id=%d",
|
__PRETTY_FUNCTION__, peer_address.ToString().c_str(), bta_handle,
|
peer_id);
|
peer = new BtifAvPeer(peer_address, AVDT_TSEP_SRC, bta_handle, peer_id);
|
peers_.insert(std::make_pair(peer_address, peer));
|
peer->Init();
|
if (active_peer_.IsEmpty()) {
|
active_peer_ = peer_address;
|
}
|
return peer;
|
}
|
|
bool BtifAvSink::AllowedToConnect(const RawAddress& peer_address) const {
|
int connected = 0;
|
|
// Count peers that are in the process of connecting or already connected
|
for (auto it : peers_) {
|
const BtifAvPeer* peer = it.second;
|
switch (peer->StateMachine().StateId()) {
|
case BtifAvStateMachine::kStateOpening:
|
case BtifAvStateMachine::kStateOpened:
|
case BtifAvStateMachine::kStateStarted:
|
if (peer->PeerAddress() == peer_address) {
|
return true; // Already connected or accounted for
|
}
|
connected++;
|
break;
|
default:
|
break;
|
}
|
}
|
return (connected < max_connected_peers_);
|
}
|
|
bool BtifAvSink::DeletePeer(const RawAddress& peer_address) {
|
auto it = peers_.find(peer_address);
|
if (it == peers_.end()) return false;
|
BtifAvPeer* peer = it->second;
|
peer->Cleanup();
|
peers_.erase(it);
|
delete peer;
|
return true;
|
}
|
|
void BtifAvSink::DeleteIdlePeers() {
|
for (auto it = peers_.begin(); it != peers_.end();) {
|
BtifAvPeer* peer = it->second;
|
auto prev_it = it++;
|
if (!peer->CanBeDeleted()) continue;
|
LOG_INFO(LOG_TAG, "%s: Deleting idle peer: %s bta_handle=0x%x", __func__,
|
peer->PeerAddress().ToString().c_str(), peer->BtaHandle());
|
peer->Cleanup();
|
peers_.erase(prev_it);
|
delete peer;
|
}
|
}
|
|
void BtifAvSink::CleanupAllPeers() {
|
while (!peers_.empty()) {
|
auto it = peers_.begin();
|
BtifAvPeer* peer = it->second;
|
peer->Cleanup();
|
peers_.erase(it);
|
delete peer;
|
}
|
}
|
|
void BtifAvSink::RegisterAllBtaHandles() {
|
for (int peer_id = kPeerIdMin; peer_id < kPeerIdMax; peer_id++) {
|
BTA_AvRegister(BTA_AV_CHNL_AUDIO, kBtifAvSinkServiceName.c_str(), peer_id,
|
bta_av_sink_media_callback, UUID_SERVCLASS_AUDIO_SINK);
|
}
|
}
|
|
void BtifAvSink::DeregisterAllBtaHandles() {
|
for (auto it : peer_id2bta_handle_) {
|
tBTA_AV_HNDL bta_handle = it.second;
|
BTA_AvDeregister(bta_handle);
|
}
|
peer_id2bta_handle_.clear();
|
}
|
|
void BtifAvSink::BtaHandleRegistered(uint8_t peer_id, tBTA_AV_HNDL bta_handle) {
|
peer_id2bta_handle_.insert(std::make_pair(peer_id, bta_handle));
|
|
// Set the BTA Handle for the Peer (if exists)
|
BtifAvPeer* peer = FindPeerByPeerId(peer_id);
|
if (peer != nullptr) {
|
peer->SetBtaHandle(bta_handle);
|
}
|
}
|
|
void BtifAvStateMachine::StateIdle::OnEnter() {
|
BTIF_TRACE_DEBUG("%s: Peer %s", __PRETTY_FUNCTION__,
|
peer_.PeerAddress().ToString().c_str());
|
|
peer_.SetEdr(0);
|
peer_.ClearAllFlags();
|
|
// Stop A2DP if this is the active peer
|
if (peer_.IsActivePeer() || peer_.ActivePeerAddress().IsEmpty()) {
|
btif_a2dp_on_idle();
|
}
|
|
// Reset the active peer if this was the active peer and
|
// the Idle state was reentered
|
if (peer_.IsActivePeer() && peer_.CanBeDeleted()) {
|
std::promise<void> peer_ready_promise;
|
if (peer_.IsSink()) {
|
btif_av_source.SetActivePeer(RawAddress::kEmpty,
|
std::move(peer_ready_promise));
|
} else if (peer_.IsSource()) {
|
btif_av_sink.SetActivePeer(RawAddress::kEmpty,
|
std::move(peer_ready_promise));
|
}
|
}
|
|
// Delete peers that are re-entering the Idle state
|
if (peer_.IsSink()) {
|
do_in_main_thread(FROM_HERE, base::Bind(&BtifAvSource::DeleteIdlePeers,
|
base::Unretained(&btif_av_source)));
|
} else if (peer_.IsSource()) {
|
do_in_main_thread(FROM_HERE, base::Bind(&BtifAvSink::DeleteIdlePeers,
|
base::Unretained(&btif_av_sink)));
|
}
|
}
|
|
void BtifAvStateMachine::StateIdle::OnExit() {
|
BTIF_TRACE_DEBUG("%s: Peer %s", __PRETTY_FUNCTION__,
|
peer_.PeerAddress().ToString().c_str());
|
}
|
|
bool BtifAvStateMachine::StateIdle::ProcessEvent(uint32_t event, void* p_data) {
|
BTIF_TRACE_DEBUG("%s: Peer %s : event=%s flags=%s active_peer=%s",
|
__PRETTY_FUNCTION__, peer_.PeerAddress().ToString().c_str(),
|
BtifAvEvent::EventName(event).c_str(),
|
peer_.FlagsToString().c_str(),
|
logbool(peer_.IsActivePeer()).c_str());
|
|
switch (event) {
|
case BTA_AV_ENABLE_EVT:
|
break;
|
|
case BTIF_AV_STOP_STREAM_REQ_EVT:
|
case BTIF_AV_SUSPEND_STREAM_REQ_EVT:
|
case BTIF_AV_ACL_DISCONNECTED:
|
// Ignore. Just re-enter Idle so the peer can be deleted
|
peer_.StateMachine().TransitionTo(BtifAvStateMachine::kStateIdle);
|
break;
|
|
case BTIF_AV_DISCONNECT_REQ_EVT:
|
if (peer_.BtaHandle() != kBtaHandleUnknown) {
|
BTA_AvClose(peer_.BtaHandle());
|
if (peer_.IsSource()) {
|
BTA_AvCloseRc(peer_.BtaHandle());
|
}
|
}
|
// Re-enter Idle so the peer can be deleted
|
peer_.StateMachine().TransitionTo(BtifAvStateMachine::kStateIdle);
|
break;
|
|
case BTIF_AV_CONNECT_REQ_EVT:
|
case BTA_AV_PENDING_EVT: {
|
bool can_connect = true;
|
peer_.SetSelfInitiatedConnection(event == BTIF_AV_CONNECT_REQ_EVT);
|
// Check whether connection is allowed
|
if (peer_.IsSink()) {
|
can_connect = btif_av_source.AllowedToConnect(peer_.PeerAddress());
|
if (!can_connect) src_disconnect_sink(peer_.PeerAddress());
|
} else if (peer_.IsSource()) {
|
can_connect = btif_av_sink.AllowedToConnect(peer_.PeerAddress());
|
if (!can_connect) sink_disconnect_src(peer_.PeerAddress());
|
}
|
if (!can_connect) {
|
BTIF_TRACE_ERROR(
|
"%s: Cannot connect to peer %s: too many connected "
|
"peers",
|
__PRETTY_FUNCTION__, peer_.PeerAddress().ToString().c_str());
|
if (peer_.SelfInitiatedConnection()) {
|
btif_queue_advance();
|
}
|
break;
|
}
|
BTA_AvOpen(peer_.PeerAddress(), peer_.BtaHandle(), true,
|
BTA_SEC_AUTHENTICATE, peer_.LocalUuidServiceClass());
|
peer_.StateMachine().TransitionTo(BtifAvStateMachine::kStateOpening);
|
} break;
|
case BTIF_AV_AVRCP_OPEN_EVT:
|
case BTA_AV_RC_OPEN_EVT: {
|
// IOP_FIX: Jabra 620 only does AVRCP Open without AV Open whenever it
|
// connects. So as per the AV WP, an AVRCP connection cannot exist
|
// without an AV connection. Therefore, we initiate an AV connection
|
// if an RC_OPEN_EVT is received when we are in AV_CLOSED state.
|
// We initiate the AV connection after a small 3s timeout to avoid any
|
// collisions from the headsets, as some headsets initiate the AVRCP
|
// connection first and then immediately initiate the AV connection
|
//
|
// TODO: We may need to do this only on an AVRCP Play. FixMe
|
BTIF_TRACE_WARNING("%s: Peer %s : event=%s received without AV",
|
__PRETTY_FUNCTION__,
|
peer_.PeerAddress().ToString().c_str(),
|
BtifAvEvent::EventName(event).c_str());
|
|
bool can_connect = true;
|
// Check whether connection is allowed
|
if (peer_.IsSink()) {
|
can_connect = btif_av_source.AllowedToConnect(peer_.PeerAddress());
|
if (!can_connect) src_disconnect_sink(peer_.PeerAddress());
|
} else if (peer_.IsSource()) {
|
can_connect = btif_av_sink.AllowedToConnect(peer_.PeerAddress());
|
if (!can_connect) sink_disconnect_src(peer_.PeerAddress());
|
}
|
if (!can_connect) {
|
BTIF_TRACE_ERROR(
|
"%s: Cannot connect to peer %s: too many connected "
|
"peers",
|
__PRETTY_FUNCTION__, peer_.PeerAddress().ToString().c_str());
|
break;
|
}
|
if (btif_av_source.Enabled()) {
|
alarm_set_on_mloop(
|
peer_.AvOpenOnRcTimer(), BtifAvPeer::kTimeoutAvOpenOnRcMs,
|
btif_av_source_initiate_av_open_timer_timeout, &peer_);
|
} else if (btif_av_sink.Enabled()) {
|
alarm_set_on_mloop(peer_.AvOpenOnRcTimer(),
|
BtifAvPeer::kTimeoutAvOpenOnRcMs,
|
btif_av_sink_initiate_av_open_timer_timeout, &peer_);
|
}
|
if (event == BTA_AV_RC_OPEN_EVT) {
|
btif_rc_handler(event, (tBTA_AV*)p_data);
|
}
|
} break;
|
|
case BTA_AV_RC_BROWSE_OPEN_EVT:
|
btif_rc_handler(event, (tBTA_AV*)p_data);
|
break;
|
|
// In case Signalling channel is not down and remote started Streaming
|
// Procedure, we have to handle Config and Open event in Idle state.
|
// We hit these scenarios while running PTS test case for AVRCP Controller.
|
case BTIF_AV_SINK_CONFIG_REQ_EVT: {
|
const btif_av_sink_config_req_t* p_config_req =
|
static_cast<const btif_av_sink_config_req_t*>(p_data);
|
btif_av_report_sink_audio_config_state(p_config_req->peer_address,
|
p_config_req->sample_rate,
|
p_config_req->channel_count);
|
} break;
|
|
case BTA_AV_OPEN_EVT: {
|
tBTA_AV* p_bta_data = (tBTA_AV*)p_data;
|
btav_connection_state_t state;
|
int av_state;
|
tBTA_AV_STATUS status = p_bta_data->open.status;
|
bool can_connect = true;
|
|
LOG_INFO(
|
LOG_TAG, "%s: Peer %s : event=%s flags=%s status=%d(%s) edr=0x%x",
|
__PRETTY_FUNCTION__, peer_.PeerAddress().ToString().c_str(),
|
BtifAvEvent::EventName(event).c_str(), peer_.FlagsToString().c_str(),
|
status, (status == BTA_AV_SUCCESS) ? "SUCCESS" : "FAILED",
|
p_bta_data->open.edr);
|
|
if (p_bta_data->open.status == BTA_AV_SUCCESS) {
|
state = BTAV_CONNECTION_STATE_CONNECTED;
|
av_state = BtifAvStateMachine::kStateOpened;
|
peer_.SetEdr(p_bta_data->open.edr);
|
CHECK(peer_.PeerSep() == p_bta_data->open.sep);
|
// Check whether connection is allowed
|
if (peer_.IsSink()) {
|
can_connect = btif_av_source.AllowedToConnect(peer_.PeerAddress());
|
if (!can_connect) src_disconnect_sink(peer_.PeerAddress());
|
} else if (peer_.IsSource()) {
|
can_connect = btif_av_sink.AllowedToConnect(peer_.PeerAddress());
|
if (!can_connect) sink_disconnect_src(peer_.PeerAddress());
|
}
|
} else {
|
state = BTAV_CONNECTION_STATE_DISCONNECTED;
|
av_state = BtifAvStateMachine::kStateIdle;
|
}
|
|
if (!can_connect) {
|
BTIF_TRACE_ERROR(
|
"%s: Cannot connect to peer %s: too many connected "
|
"peers",
|
__PRETTY_FUNCTION__, peer_.PeerAddress().ToString().c_str());
|
} else {
|
// Report the connection state to the application
|
btif_report_connection_state(peer_.PeerAddress(), state);
|
// Change state to Open/Idle based on the status
|
peer_.StateMachine().TransitionTo(av_state);
|
if (peer_.IsSink()) {
|
// If queued PLAY command, send it now
|
btif_rc_check_handle_pending_play(
|
p_bta_data->open.bd_addr,
|
(p_bta_data->open.status == BTA_AV_SUCCESS));
|
} else if (peer_.IsSource() &&
|
(p_bta_data->open.status == BTA_AV_SUCCESS)) {
|
// Bring up AVRCP connection as well
|
BTA_AvOpenRc(peer_.BtaHandle());
|
}
|
}
|
btif_queue_advance();
|
} break;
|
|
case BTA_AV_REMOTE_CMD_EVT:
|
case BTA_AV_VENDOR_CMD_EVT:
|
case BTA_AV_META_MSG_EVT:
|
case BTA_AV_RC_FEAT_EVT:
|
case BTA_AV_REMOTE_RSP_EVT:
|
btif_rc_handler(event, (tBTA_AV*)p_data);
|
break;
|
|
case BTIF_AV_AVRCP_CLOSE_EVT:
|
case BTA_AV_RC_CLOSE_EVT: {
|
BTIF_TRACE_DEBUG("%s: Peer %s : event=%s : Stopping AV timer",
|
__PRETTY_FUNCTION__,
|
peer_.PeerAddress().ToString().c_str(),
|
BtifAvEvent::EventName(event).c_str());
|
alarm_cancel(peer_.AvOpenOnRcTimer());
|
|
if (event == BTA_AV_RC_CLOSE_EVT) {
|
btif_rc_handler(event, (tBTA_AV*)p_data);
|
}
|
} break;
|
|
case BTIF_AV_OFFLOAD_START_REQ_EVT:
|
BTIF_TRACE_ERROR("%s: Peer %s : event=%s: stream is not Opened",
|
__PRETTY_FUNCTION__,
|
peer_.PeerAddress().ToString().c_str(),
|
BtifAvEvent::EventName(event).c_str());
|
btif_a2dp_on_offload_started(peer_.PeerAddress(), BTA_AV_FAIL);
|
break;
|
|
default:
|
BTIF_TRACE_WARNING("%s: Peer %s : Unhandled event=%s",
|
__PRETTY_FUNCTION__,
|
peer_.PeerAddress().ToString().c_str(),
|
BtifAvEvent::EventName(event).c_str());
|
return false;
|
}
|
|
return true;
|
}
|
|
void BtifAvStateMachine::StateOpening::OnEnter() {
|
BTIF_TRACE_DEBUG("%s: Peer %s", __PRETTY_FUNCTION__,
|
peer_.PeerAddress().ToString().c_str());
|
|
// Inform the application that we are entering connecting state
|
btif_report_connection_state(peer_.PeerAddress(),
|
BTAV_CONNECTION_STATE_CONNECTING);
|
}
|
|
void BtifAvStateMachine::StateOpening::OnExit() {
|
BTIF_TRACE_DEBUG("%s: Peer %s", __PRETTY_FUNCTION__,
|
peer_.PeerAddress().ToString().c_str());
|
}
|
|
bool BtifAvStateMachine::StateOpening::ProcessEvent(uint32_t event,
|
void* p_data) {
|
BTIF_TRACE_DEBUG("%s: Peer %s : event=%s flags=%s active_peer=%s",
|
__PRETTY_FUNCTION__, peer_.PeerAddress().ToString().c_str(),
|
BtifAvEvent::EventName(event).c_str(),
|
peer_.FlagsToString().c_str(),
|
logbool(peer_.IsActivePeer()).c_str());
|
|
switch (event) {
|
case BTIF_AV_STOP_STREAM_REQ_EVT:
|
case BTIF_AV_SUSPEND_STREAM_REQ_EVT:
|
break; // Ignore
|
|
case BTIF_AV_ACL_DISCONNECTED:
|
// ACL Disconnected needs to be handled only in Opening state, because
|
// it is in an intermediate state. In other states we can handle
|
// incoming/outgoing connect/disconnect requests.
|
BTIF_TRACE_WARNING(
|
"%s: Peer %s : event=%s: transitioning to Idle due to ACL Disconnect",
|
__PRETTY_FUNCTION__, peer_.PeerAddress().ToString().c_str(),
|
BtifAvEvent::EventName(event).c_str());
|
btif_report_connection_state(peer_.PeerAddress(),
|
BTAV_CONNECTION_STATE_DISCONNECTED);
|
peer_.StateMachine().TransitionTo(BtifAvStateMachine::kStateIdle);
|
if (peer_.SelfInitiatedConnection()) {
|
btif_queue_advance();
|
}
|
break;
|
case BTA_AV_REJECT_EVT:
|
BTIF_TRACE_WARNING("%s: Peer %s : event=%s flags=%s", __PRETTY_FUNCTION__,
|
peer_.PeerAddress().ToString().c_str(),
|
BtifAvEvent::EventName(event).c_str(),
|
peer_.FlagsToString().c_str());
|
btif_report_connection_state(peer_.PeerAddress(),
|
BTAV_CONNECTION_STATE_DISCONNECTED);
|
peer_.StateMachine().TransitionTo(BtifAvStateMachine::kStateIdle);
|
if (peer_.SelfInitiatedConnection()) {
|
btif_queue_advance();
|
}
|
break;
|
|
case BTA_AV_OPEN_EVT: {
|
tBTA_AV* p_bta_data = (tBTA_AV*)p_data;
|
btav_connection_state_t state;
|
int av_state;
|
tBTA_AV_STATUS status = p_bta_data->open.status;
|
|
LOG_INFO(
|
LOG_TAG, "%s: Peer %s : event=%s flags=%s status=%d(%s) edr=0x%x",
|
__PRETTY_FUNCTION__, peer_.PeerAddress().ToString().c_str(),
|
BtifAvEvent::EventName(event).c_str(), peer_.FlagsToString().c_str(),
|
status, (status == BTA_AV_SUCCESS) ? "SUCCESS" : "FAILED",
|
p_bta_data->open.edr);
|
|
if (p_bta_data->open.status == BTA_AV_SUCCESS) {
|
state = BTAV_CONNECTION_STATE_CONNECTED;
|
av_state = BtifAvStateMachine::kStateOpened;
|
peer_.SetEdr(p_bta_data->open.edr);
|
CHECK(peer_.PeerSep() == p_bta_data->open.sep);
|
} else {
|
if (btif_rc_is_connected_peer(peer_.PeerAddress())) {
|
// Disconnect the AVRCP connection, in case the A2DP connectiton
|
// failed for any reason.
|
BTIF_TRACE_WARNING("%s: Peer %s : Disconnecting AVRCP",
|
__PRETTY_FUNCTION__,
|
peer_.PeerAddress().ToString().c_str());
|
uint8_t peer_handle =
|
btif_rc_get_connected_peer_handle(peer_.PeerAddress());
|
if (peer_handle != BTRC_HANDLE_NONE) {
|
BTA_AvCloseRc(peer_handle);
|
}
|
}
|
state = BTAV_CONNECTION_STATE_DISCONNECTED;
|
av_state = BtifAvStateMachine::kStateIdle;
|
}
|
|
// Report the connection state to the application
|
btif_report_connection_state(peer_.PeerAddress(), state);
|
// Change state to Open/Idle based on the status
|
peer_.StateMachine().TransitionTo(av_state);
|
if (peer_.IsSink()) {
|
// If queued PLAY command, send it now
|
btif_rc_check_handle_pending_play(
|
p_bta_data->open.bd_addr,
|
(p_bta_data->open.status == BTA_AV_SUCCESS));
|
} else if (peer_.IsSource() &&
|
(p_bta_data->open.status == BTA_AV_SUCCESS)) {
|
// Bring up AVRCP connection as well
|
BTA_AvOpenRc(peer_.BtaHandle());
|
}
|
if (peer_.SelfInitiatedConnection()) {
|
btif_queue_advance();
|
}
|
} break;
|
|
case BTIF_AV_SINK_CONFIG_REQ_EVT: {
|
const btif_av_sink_config_req_t* p_config_req =
|
static_cast<const btif_av_sink_config_req_t*>(p_data);
|
if (peer_.IsSource()) {
|
btif_av_report_sink_audio_config_state(p_config_req->peer_address,
|
p_config_req->sample_rate,
|
p_config_req->channel_count);
|
}
|
} break;
|
|
case BTIF_AV_CONNECT_REQ_EVT: {
|
// The device has moved already to Opening, hence don't report the
|
// connection state.
|
BTIF_TRACE_WARNING(
|
"%s: Peer %s : event=%s : device is already connecting, "
|
"ignore Connect request",
|
__PRETTY_FUNCTION__, peer_.PeerAddress().ToString().c_str(),
|
BtifAvEvent::EventName(event).c_str());
|
btif_queue_advance();
|
} break;
|
|
case BTA_AV_PENDING_EVT: {
|
// The device has moved already to Opening, hence don't report the
|
// connection state.
|
BTIF_TRACE_WARNING(
|
"%s: Peer %s : event=%s : device is already connecting, "
|
"ignore incoming request",
|
__PRETTY_FUNCTION__, peer_.PeerAddress().ToString().c_str(),
|
BtifAvEvent::EventName(event).c_str());
|
} break;
|
|
case BTIF_AV_OFFLOAD_START_REQ_EVT:
|
BTIF_TRACE_ERROR("%s: Peer %s : event=%s: stream is not Opened",
|
__PRETTY_FUNCTION__,
|
peer_.PeerAddress().ToString().c_str(),
|
BtifAvEvent::EventName(event).c_str());
|
btif_a2dp_on_offload_started(peer_.PeerAddress(), BTA_AV_FAIL);
|
break;
|
|
case BTA_AV_CLOSE_EVT:
|
btif_a2dp_on_stopped(nullptr);
|
btif_report_connection_state(peer_.PeerAddress(),
|
BTAV_CONNECTION_STATE_DISCONNECTED);
|
peer_.StateMachine().TransitionTo(BtifAvStateMachine::kStateIdle);
|
if (peer_.SelfInitiatedConnection()) {
|
btif_queue_advance();
|
}
|
break;
|
|
case BTIF_AV_DISCONNECT_REQ_EVT:
|
BTA_AvClose(peer_.BtaHandle());
|
btif_report_connection_state(peer_.PeerAddress(),
|
BTAV_CONNECTION_STATE_DISCONNECTED);
|
peer_.StateMachine().TransitionTo(BtifAvStateMachine::kStateIdle);
|
if (peer_.SelfInitiatedConnection()) {
|
btif_queue_advance();
|
}
|
break;
|
|
CHECK_RC_EVENT(event, (tBTA_AV*)p_data);
|
|
default:
|
BTIF_TRACE_WARNING("%s: Peer %s : Unhandled event=%s",
|
__PRETTY_FUNCTION__,
|
peer_.PeerAddress().ToString().c_str(),
|
BtifAvEvent::EventName(event).c_str());
|
return false;
|
}
|
return true;
|
}
|
|
void BtifAvStateMachine::StateOpened::OnEnter() {
|
BTIF_TRACE_DEBUG("%s: Peer %s", __PRETTY_FUNCTION__,
|
peer_.PeerAddress().ToString().c_str());
|
|
peer_.ClearFlags(BtifAvPeer::kFlagLocalSuspendPending |
|
BtifAvPeer::kFlagPendingStart |
|
BtifAvPeer::kFlagPendingStop);
|
|
// Set the active peer if the first connected device.
|
// NOTE: This should be done only if we are A2DP Sink, because the A2DP Sink
|
// implementation in Java doesn't support active devices (yet).
|
// For A2DP Source, the setting of the Active device is done by the
|
// ActiveDeviceManager in Java.
|
if (peer_.IsSource() && btif_av_sink.ActivePeer().IsEmpty()) {
|
std::promise<void> peer_ready_promise;
|
if (!btif_av_sink.SetActivePeer(peer_.PeerAddress(),
|
std::move(peer_ready_promise))) {
|
BTIF_TRACE_ERROR("%s: Error setting %s as active Source peer", __func__,
|
peer_.PeerAddress().ToString().c_str());
|
}
|
}
|
}
|
|
void BtifAvStateMachine::StateOpened::OnExit() {
|
BTIF_TRACE_DEBUG("%s: Peer %s", __PRETTY_FUNCTION__,
|
peer_.PeerAddress().ToString().c_str());
|
|
peer_.ClearFlags(BtifAvPeer::kFlagPendingStart);
|
}
|
|
bool BtifAvStateMachine::StateOpened::ProcessEvent(uint32_t event,
|
void* p_data) {
|
tBTA_AV* p_av = (tBTA_AV*)p_data;
|
|
BTIF_TRACE_DEBUG("%s: Peer %s : event=%s flags=%s active_peer=%s",
|
__PRETTY_FUNCTION__, peer_.PeerAddress().ToString().c_str(),
|
BtifAvEvent::EventName(event).c_str(),
|
peer_.FlagsToString().c_str(),
|
logbool(peer_.IsActivePeer()).c_str());
|
|
if ((event == BTA_AV_REMOTE_CMD_EVT) &&
|
peer_.CheckFlags(BtifAvPeer::kFlagRemoteSuspend) &&
|
(p_av->remote_cmd.rc_id == AVRC_ID_PLAY)) {
|
BTIF_TRACE_EVENT("%s: Peer %s : Resetting remote suspend flag on RC PLAY",
|
__PRETTY_FUNCTION__,
|
peer_.PeerAddress().ToString().c_str());
|
peer_.ClearFlags(BtifAvPeer::kFlagRemoteSuspend);
|
}
|
|
switch (event) {
|
case BTIF_AV_STOP_STREAM_REQ_EVT:
|
case BTIF_AV_SUSPEND_STREAM_REQ_EVT:
|
case BTIF_AV_ACL_DISCONNECTED:
|
break; // Ignore
|
|
case BTIF_AV_START_STREAM_REQ_EVT:
|
LOG_INFO(LOG_TAG, "%s: Peer %s : event=%s flags=%s", __PRETTY_FUNCTION__,
|
peer_.PeerAddress().ToString().c_str(),
|
BtifAvEvent::EventName(event).c_str(),
|
peer_.FlagsToString().c_str());
|
BTA_AvStart(peer_.BtaHandle());
|
peer_.SetFlags(BtifAvPeer::kFlagPendingStart);
|
break;
|
|
case BTA_AV_START_EVT: {
|
LOG_INFO(LOG_TAG,
|
"%s: Peer %s : event=%s status=%d suspending=%d "
|
"initiator=%d flags=%s",
|
__PRETTY_FUNCTION__, peer_.PeerAddress().ToString().c_str(),
|
BtifAvEvent::EventName(event).c_str(), p_av->start.status,
|
p_av->start.suspending, p_av->start.initiator,
|
peer_.FlagsToString().c_str());
|
|
if ((p_av->start.status == BTA_SUCCESS) && p_av->start.suspending)
|
return true;
|
|
// If remote tries to start A2DP when DUT is A2DP Source, then Suspend.
|
// If A2DP is Sink and call is active, then disconnect the AVDTP channel.
|
bool should_suspend = false;
|
if (peer_.IsSink() && !peer_.CheckFlags(BtifAvPeer::kFlagPendingStart |
|
BtifAvPeer::kFlagRemoteSuspend)) {
|
LOG(WARNING) << __PRETTY_FUNCTION__ << ": Peer " << peer_.PeerAddress()
|
<< " : trigger Suspend as remote initiated";
|
should_suspend = true;
|
}
|
|
// If peer is A2DP Source, do ACK commands to audio HAL and start media task
|
if (peer_.IsSink() && btif_a2dp_on_started(peer_.PeerAddress(), &p_av->start)) {
|
// Only clear pending flag after acknowledgement
|
peer_.ClearFlags(BtifAvPeer::kFlagPendingStart);
|
}
|
|
// Remain in Open state if status failed
|
if (p_av->start.status != BTA_AV_SUCCESS) return false;
|
|
if (peer_.IsSource() && peer_.IsActivePeer()) {
|
// Remove flush state, ready for streaming
|
btif_a2dp_sink_set_rx_flush(false);
|
}
|
|
if (should_suspend) {
|
btif_av_source_dispatch_sm_event(peer_.PeerAddress(),
|
BTIF_AV_SUSPEND_STREAM_REQ_EVT);
|
}
|
peer_.StateMachine().TransitionTo(BtifAvStateMachine::kStateStarted);
|
|
} break;
|
|
case BTIF_AV_DISCONNECT_REQ_EVT:
|
BTA_AvClose(peer_.BtaHandle());
|
if (peer_.IsSource()) {
|
BTA_AvCloseRc(peer_.BtaHandle());
|
}
|
|
// Inform the application that we are disconnecting
|
btif_report_connection_state(peer_.PeerAddress(),
|
BTAV_CONNECTION_STATE_DISCONNECTING);
|
|
// Wait in closing state until fully closed
|
peer_.StateMachine().TransitionTo(BtifAvStateMachine::kStateClosing);
|
break;
|
|
case BTA_AV_CLOSE_EVT:
|
// AVDTP link is closed
|
if (peer_.IsActivePeer()) {
|
btif_a2dp_on_stopped(nullptr);
|
}
|
|
// Change state to Idle, send acknowledgement if start is pending
|
if (peer_.CheckFlags(BtifAvPeer::kFlagPendingStart)) {
|
BTIF_TRACE_WARNING("%s: Peer %s : failed pending start request",
|
__PRETTY_FUNCTION__,
|
peer_.PeerAddress().ToString().c_str());
|
btif_a2dp_command_ack(A2DP_CTRL_ACK_FAILURE);
|
// Pending start flag will be cleared when exit current state
|
}
|
|
// Inform the application that we are disconnected
|
btif_report_connection_state(peer_.PeerAddress(),
|
BTAV_CONNECTION_STATE_DISCONNECTED);
|
peer_.StateMachine().TransitionTo(BtifAvStateMachine::kStateIdle);
|
break;
|
|
case BTA_AV_RECONFIG_EVT:
|
if (peer_.CheckFlags(BtifAvPeer::kFlagPendingStart) &&
|
(p_av->reconfig.status == BTA_AV_SUCCESS)) {
|
LOG_INFO(LOG_TAG,
|
"%s : Peer %s : Reconfig done - calling BTA_AvStart()",
|
__PRETTY_FUNCTION__, peer_.PeerAddress().ToString().c_str());
|
BTA_AvStart(peer_.BtaHandle());
|
} else if (peer_.CheckFlags(BtifAvPeer::kFlagPendingStart)) {
|
BTIF_TRACE_WARNING("%s: Peer %s : failed reconfiguration",
|
__PRETTY_FUNCTION__,
|
peer_.PeerAddress().ToString().c_str());
|
peer_.ClearFlags(BtifAvPeer::kFlagPendingStart);
|
btif_a2dp_command_ack(A2DP_CTRL_ACK_FAILURE);
|
}
|
break;
|
|
case BTIF_AV_CONNECT_REQ_EVT: {
|
BTIF_TRACE_WARNING("%s: Peer %s : Ignore %s for same device",
|
__PRETTY_FUNCTION__,
|
peer_.PeerAddress().ToString().c_str(),
|
BtifAvEvent::EventName(event).c_str());
|
btif_queue_advance();
|
} break;
|
|
case BTIF_AV_OFFLOAD_START_REQ_EVT:
|
BTIF_TRACE_ERROR("%s: Peer %s : event=%s: stream is not Opened",
|
__PRETTY_FUNCTION__,
|
peer_.PeerAddress().ToString().c_str(),
|
BtifAvEvent::EventName(event).c_str());
|
btif_a2dp_on_offload_started(peer_.PeerAddress(), BTA_AV_FAIL);
|
break;
|
|
case BTIF_AV_AVRCP_REMOTE_PLAY_EVT:
|
if (peer_.CheckFlags(BtifAvPeer::kFlagRemoteSuspend)) {
|
BTIF_TRACE_EVENT(
|
"%s: Peer %s : Resetting remote suspend flag on RC PLAY",
|
__PRETTY_FUNCTION__, peer_.PeerAddress().ToString().c_str());
|
peer_.ClearFlags(BtifAvPeer::kFlagRemoteSuspend);
|
}
|
break;
|
|
CHECK_RC_EVENT(event, (tBTA_AV*)p_data);
|
|
default:
|
BTIF_TRACE_WARNING("%s: Peer %s : Unhandled event=%s",
|
__PRETTY_FUNCTION__,
|
peer_.PeerAddress().ToString().c_str(),
|
BtifAvEvent::EventName(event).c_str());
|
return false;
|
}
|
return true;
|
}
|
|
void BtifAvStateMachine::StateStarted::OnEnter() {
|
BTIF_TRACE_DEBUG("%s: Peer %s", __PRETTY_FUNCTION__,
|
peer_.PeerAddress().ToString().c_str());
|
|
// We are again in started state, clear any remote suspend flags
|
peer_.ClearFlags(BtifAvPeer::kFlagRemoteSuspend);
|
|
// Report that we have entered the Streaming stage. Usually, this should
|
// be followed by focus grant. See update_audio_focus_state()
|
btif_report_audio_state(peer_.PeerAddress(), BTAV_AUDIO_STATE_STARTED);
|
}
|
|
void BtifAvStateMachine::StateStarted::OnExit() {
|
BTIF_TRACE_DEBUG("%s: Peer %s", __PRETTY_FUNCTION__,
|
peer_.PeerAddress().ToString().c_str());
|
}
|
|
bool BtifAvStateMachine::StateStarted::ProcessEvent(uint32_t event,
|
void* p_data) {
|
tBTA_AV* p_av = (tBTA_AV*)p_data;
|
|
BTIF_TRACE_DEBUG("%s: Peer %s : event=%s flags=%s active_peer=%s",
|
__PRETTY_FUNCTION__, peer_.PeerAddress().ToString().c_str(),
|
BtifAvEvent::EventName(event).c_str(),
|
peer_.FlagsToString().c_str(),
|
logbool(peer_.IsActivePeer()).c_str());
|
|
switch (event) {
|
case BTIF_AV_ACL_DISCONNECTED:
|
break; // Ignore
|
|
case BTIF_AV_START_STREAM_REQ_EVT:
|
LOG_INFO(LOG_TAG, "%s: Peer %s : event=%s flags=%s", __PRETTY_FUNCTION__,
|
peer_.PeerAddress().ToString().c_str(),
|
BtifAvEvent::EventName(event).c_str(),
|
peer_.FlagsToString().c_str());
|
// We were started remotely, just ACK back the local request
|
if (peer_.IsSink()) btif_a2dp_on_started(peer_.PeerAddress(), nullptr);
|
break;
|
|
// FIXME -- use suspend = true always to work around issue with BTA AV
|
case BTIF_AV_STOP_STREAM_REQ_EVT:
|
case BTIF_AV_SUSPEND_STREAM_REQ_EVT:
|
LOG_INFO(LOG_TAG, "%s: Peer %s : event=%s flags=%s", __PRETTY_FUNCTION__,
|
peer_.PeerAddress().ToString().c_str(),
|
BtifAvEvent::EventName(event).c_str(),
|
peer_.FlagsToString().c_str());
|
// Set pending flag to ensure the BTIF task is not trying to restart
|
// the stream while suspend is in progress.
|
peer_.SetFlags(BtifAvPeer::kFlagLocalSuspendPending);
|
|
// If we were remotely suspended but suspend locally, local suspend
|
// always overrides.
|
peer_.ClearFlags(BtifAvPeer::kFlagRemoteSuspend);
|
|
if (peer_.IsSink()) {
|
// Immediately stop transmission of frames while suspend is pending
|
if (peer_.IsActivePeer()) {
|
if (event == BTIF_AV_STOP_STREAM_REQ_EVT) {
|
btif_a2dp_on_stopped(nullptr);
|
} else {
|
// (event == BTIF_AV_SUSPEND_STREAM_REQ_EVT)
|
btif_a2dp_source_set_tx_flush(true);
|
}
|
}
|
} else if (peer_.IsSource()) {
|
btif_a2dp_on_stopped(nullptr);
|
}
|
BTA_AvStop(peer_.BtaHandle(), true);
|
break;
|
|
case BTIF_AV_DISCONNECT_REQ_EVT:
|
LOG_INFO(LOG_TAG, "%s: Peer %s : event=%s flags=%s", __PRETTY_FUNCTION__,
|
peer_.PeerAddress().ToString().c_str(),
|
BtifAvEvent::EventName(event).c_str(),
|
peer_.FlagsToString().c_str());
|
|
// Request AVDTP to close
|
BTA_AvClose(peer_.BtaHandle());
|
if (peer_.IsSource()) {
|
BTA_AvCloseRc(peer_.BtaHandle());
|
}
|
|
// Inform the application that we are disconnecting
|
btif_report_connection_state(peer_.PeerAddress(),
|
BTAV_CONNECTION_STATE_DISCONNECTING);
|
|
// Wait in closing state until fully closed
|
peer_.StateMachine().TransitionTo(BtifAvStateMachine::kStateClosing);
|
break;
|
|
case BTA_AV_SUSPEND_EVT: {
|
LOG_INFO(LOG_TAG,
|
"%s: Peer %s : event=%s status=%d initiator=%d flags=%s",
|
__PRETTY_FUNCTION__, peer_.PeerAddress().ToString().c_str(),
|
BtifAvEvent::EventName(event).c_str(), p_av->suspend.status,
|
p_av->suspend.initiator, peer_.FlagsToString().c_str());
|
|
// A2DP suspended, stop A2DP encoder/decoder until resumed
|
btif_a2dp_on_suspended(&p_av->suspend);
|
|
// If not successful, remain in current state
|
if (p_av->suspend.status != BTA_AV_SUCCESS) {
|
peer_.ClearFlags(BtifAvPeer::kFlagLocalSuspendPending);
|
|
if (peer_.IsSink() && peer_.IsActivePeer()) {
|
// Suspend failed, reset back tx flush state
|
btif_a2dp_source_set_tx_flush(false);
|
}
|
return false;
|
}
|
|
btav_audio_state_t state = BTAV_AUDIO_STATE_REMOTE_SUSPEND;
|
if (p_av->suspend.initiator != true) {
|
// Remote suspend, notify HAL and await audioflinger to
|
// suspend/stop stream.
|
//
|
// Set remote suspend flag to block media task from restarting
|
// stream only if we did not already initiate a local suspend.
|
if (!peer_.CheckFlags(BtifAvPeer::kFlagLocalSuspendPending))
|
peer_.SetFlags(BtifAvPeer::kFlagRemoteSuspend);
|
} else {
|
state = BTAV_AUDIO_STATE_STOPPED;
|
}
|
|
// Suspend completed, clear pending status
|
peer_.ClearFlags(BtifAvPeer::kFlagLocalSuspendPending);
|
|
btif_report_audio_state(peer_.PeerAddress(), state);
|
peer_.StateMachine().TransitionTo(BtifAvStateMachine::kStateOpened);
|
} break;
|
|
case BTA_AV_STOP_EVT:
|
LOG_INFO(LOG_TAG, "%s: Peer %s : event=%s flags=%s", __PRETTY_FUNCTION__,
|
peer_.PeerAddress().ToString().c_str(),
|
BtifAvEvent::EventName(event).c_str(),
|
peer_.FlagsToString().c_str());
|
|
peer_.SetFlags(BtifAvPeer::kFlagPendingStop);
|
peer_.ClearFlags(BtifAvPeer::kFlagLocalSuspendPending);
|
|
btif_a2dp_on_stopped(&p_av->suspend);
|
|
btif_report_audio_state(peer_.PeerAddress(), BTAV_AUDIO_STATE_STOPPED);
|
|
// If stop was successful, change state to Open
|
if (p_av->suspend.status == BTA_AV_SUCCESS)
|
peer_.StateMachine().TransitionTo(BtifAvStateMachine::kStateOpened);
|
|
break;
|
|
case BTA_AV_CLOSE_EVT:
|
LOG_INFO(LOG_TAG, "%s: Peer %s : event=%s flags=%s", __PRETTY_FUNCTION__,
|
peer_.PeerAddress().ToString().c_str(),
|
BtifAvEvent::EventName(event).c_str(),
|
peer_.FlagsToString().c_str());
|
|
peer_.SetFlags(BtifAvPeer::kFlagPendingStop);
|
|
// AVDTP link is closed
|
if (peer_.IsActivePeer()) {
|
btif_a2dp_on_stopped(nullptr);
|
}
|
|
// Inform the application that we are disconnected
|
btif_report_connection_state(peer_.PeerAddress(),
|
BTAV_CONNECTION_STATE_DISCONNECTED);
|
|
peer_.StateMachine().TransitionTo(BtifAvStateMachine::kStateIdle);
|
break;
|
|
case BTIF_AV_OFFLOAD_START_REQ_EVT:
|
BTA_AvOffloadStart(peer_.BtaHandle());
|
break;
|
|
case BTA_AV_OFFLOAD_START_RSP_EVT:
|
btif_a2dp_on_offload_started(peer_.PeerAddress(), p_av->status);
|
break;
|
|
CHECK_RC_EVENT(event, (tBTA_AV*)p_data);
|
|
default:
|
BTIF_TRACE_WARNING("%s: Peer %s : Unhandled event=%s",
|
__PRETTY_FUNCTION__,
|
peer_.PeerAddress().ToString().c_str(),
|
BtifAvEvent::EventName(event).c_str());
|
return false;
|
}
|
|
return true;
|
}
|
|
void BtifAvStateMachine::StateClosing::OnEnter() {
|
BTIF_TRACE_DEBUG("%s: Peer %s", __PRETTY_FUNCTION__,
|
peer_.PeerAddress().ToString().c_str());
|
|
if (peer_.IsActivePeer()) {
|
if (peer_.IsSink()) {
|
// Immediately stop transmission of frames
|
btif_a2dp_source_set_tx_flush(true);
|
// Wait for Audio Flinger to stop A2DP
|
} else if (peer_.IsSource()) {
|
btif_a2dp_sink_set_rx_flush(true);
|
}
|
}
|
}
|
|
void BtifAvStateMachine::StateClosing::OnExit() {
|
BTIF_TRACE_DEBUG("%s: Peer %s", __PRETTY_FUNCTION__,
|
peer_.PeerAddress().ToString().c_str());
|
}
|
|
bool BtifAvStateMachine::StateClosing::ProcessEvent(uint32_t event,
|
void* p_data) {
|
BTIF_TRACE_DEBUG("%s: Peer %s : event=%s flags=%s active_peer=%s",
|
__PRETTY_FUNCTION__, peer_.PeerAddress().ToString().c_str(),
|
BtifAvEvent::EventName(event).c_str(),
|
peer_.FlagsToString().c_str(),
|
logbool(peer_.IsActivePeer()).c_str());
|
|
switch (event) {
|
case BTIF_AV_SUSPEND_STREAM_REQ_EVT:
|
case BTIF_AV_ACL_DISCONNECTED:
|
break; // Ignore
|
|
case BTA_AV_STOP_EVT:
|
case BTIF_AV_STOP_STREAM_REQ_EVT:
|
if (peer_.IsActivePeer()) {
|
btif_a2dp_on_stopped(nullptr);
|
}
|
break;
|
|
case BTA_AV_CLOSE_EVT:
|
// Inform the application that we are disconnecting
|
btif_report_connection_state(peer_.PeerAddress(),
|
BTAV_CONNECTION_STATE_DISCONNECTED);
|
|
peer_.StateMachine().TransitionTo(BtifAvStateMachine::kStateIdle);
|
break;
|
|
// Handle the RC_CLOSE event for the cleanup
|
case BTA_AV_RC_CLOSE_EVT:
|
btif_rc_handler(event, (tBTA_AV*)p_data);
|
break;
|
|
// Handle the RC_BROWSE_CLOSE event for testing
|
case BTA_AV_RC_BROWSE_CLOSE_EVT:
|
btif_rc_handler(event, (tBTA_AV*)p_data);
|
break;
|
|
case BTIF_AV_OFFLOAD_START_REQ_EVT:
|
BTIF_TRACE_ERROR("%s: Peer %s : event=%s: stream is not Opened",
|
__PRETTY_FUNCTION__,
|
peer_.PeerAddress().ToString().c_str(),
|
BtifAvEvent::EventName(event).c_str());
|
btif_a2dp_on_offload_started(peer_.PeerAddress(), BTA_AV_FAIL);
|
break;
|
|
default:
|
BTIF_TRACE_WARNING("%s: Peer %s : Unhandled event=%s",
|
__PRETTY_FUNCTION__,
|
peer_.PeerAddress().ToString().c_str(),
|
BtifAvEvent::EventName(event).c_str());
|
return false;
|
}
|
return true;
|
}
|
|
/**
|
* Timer to trigger AV Open on the Source if the remote Sink device establishes
|
* AVRCP connection without AV connection. The timer is needed to interoperate
|
* with headsets that do establish AV after AVRCP connection.
|
*/
|
static void btif_av_source_initiate_av_open_timer_timeout(void* data) {
|
BtifAvPeer* peer = (BtifAvPeer*)data;
|
|
BTIF_TRACE_DEBUG("%s: Peer %s", __func__,
|
peer->PeerAddress().ToString().c_str());
|
|
// Check if AVRCP is connected to the peer
|
if (!btif_rc_is_connected_peer(peer->PeerAddress())) {
|
BTIF_TRACE_ERROR("%s: AVRCP peer %s is not connected", __func__,
|
peer->PeerAddress().ToString().c_str());
|
return;
|
}
|
|
// Connect to the AVRCP peer
|
if (btif_av_source.Enabled() &&
|
btif_av_source.FindPeer(peer->PeerAddress()) == peer) {
|
BTIF_TRACE_DEBUG("%s: Connecting to AVRCP peer %s", __func__,
|
peer->PeerAddress().ToString().c_str());
|
btif_av_source_dispatch_sm_event(peer->PeerAddress(),
|
BTIF_AV_CONNECT_REQ_EVT);
|
}
|
}
|
|
/**
|
* Timer to trigger AV Open on the Sink if the remote Source device establishes
|
* AVRCP connection without AV connection.
|
*/
|
static void btif_av_sink_initiate_av_open_timer_timeout(void* data) {
|
BtifAvPeer* peer = (BtifAvPeer*)data;
|
|
BTIF_TRACE_DEBUG("%s: Peer %s", __func__,
|
peer->PeerAddress().ToString().c_str());
|
|
// Check if AVRCP is connected to the peer
|
if (!btif_rc_is_connected_peer(peer->PeerAddress())) {
|
BTIF_TRACE_ERROR("%s: AVRCP peer %s is not connected", __func__,
|
peer->PeerAddress().ToString().c_str());
|
return;
|
}
|
|
// Connect to the AVRCP peer
|
if (btif_av_sink.Enabled() &&
|
btif_av_sink.FindPeer(peer->PeerAddress()) == peer) {
|
BTIF_TRACE_DEBUG("%s: Connecting to AVRCP peer %s", __func__,
|
peer->PeerAddress().ToString().c_str());
|
btif_av_sink_dispatch_sm_event(peer->PeerAddress(),
|
BTIF_AV_CONNECT_REQ_EVT);
|
}
|
}
|
|
/**
|
* Report the A2DP connection state
|
*
|
* @param peer_address the peer address
|
* @param state the connection state
|
*/
|
static void btif_report_connection_state(const RawAddress& peer_address,
|
btav_connection_state_t state) {
|
LOG_INFO(LOG_TAG, "%s: peer_address=%s state=%d", __func__,
|
peer_address.ToString().c_str(), state);
|
|
if (btif_av_source.Enabled()) {
|
do_in_jni_thread(FROM_HERE,
|
base::Bind(btif_av_source.Callbacks()->connection_state_cb,
|
peer_address, state));
|
} else if (btif_av_sink.Enabled()) {
|
do_in_jni_thread(FROM_HERE,
|
base::Bind(btif_av_sink.Callbacks()->connection_state_cb,
|
peer_address, state));
|
}
|
}
|
|
/**
|
* Report the audio state of the A2DP connection.
|
* The state is updated when either the remote ends starts streaming
|
* (Started state) or whenever it transitions out of Started state
|
* (to Opened or Streaming state).
|
*
|
* @param peer_address the peer address
|
* @param state the audio state
|
*/
|
static void btif_report_audio_state(const RawAddress& peer_address,
|
btav_audio_state_t state) {
|
LOG_INFO(LOG_TAG, "%s: peer_address=%s state=%d", __func__,
|
peer_address.ToString().c_str(), state);
|
|
if (btif_av_source.Enabled()) {
|
do_in_jni_thread(FROM_HERE,
|
base::Bind(btif_av_source.Callbacks()->audio_state_cb,
|
peer_address, state));
|
} else if (btif_av_sink.Enabled()) {
|
do_in_jni_thread(FROM_HERE,
|
base::Bind(btif_av_sink.Callbacks()->audio_state_cb,
|
peer_address, state));
|
}
|
}
|
|
void 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) {
|
BTIF_TRACE_EVENT("%s: peer_address=%s", __func__,
|
peer_address.ToString().c_str());
|
if (btif_av_source.Enabled()) {
|
do_in_jni_thread(
|
FROM_HERE,
|
base::Bind(btif_av_source.Callbacks()->audio_config_cb, peer_address,
|
codec_config, codecs_local_capabilities,
|
codecs_selectable_capabilities));
|
}
|
}
|
|
/**
|
* Report the audio config state of the A2DP Sink connection.
|
*
|
* @param peer_address the peer address
|
* @param sample_rate the sample rate (in samples per second)
|
* @param channel_count the channel count (1 for Mono, 2 for Stereo)
|
*/
|
static void btif_av_report_sink_audio_config_state(
|
const RawAddress& peer_address, int sample_rate, int channel_count) {
|
LOG_INFO(LOG_TAG, "%s: Peer %s : sample_rate=%d channel_count=%d", __func__,
|
peer_address.ToString().c_str(), sample_rate, channel_count);
|
if (btif_av_sink.Enabled()) {
|
do_in_jni_thread(FROM_HERE,
|
base::Bind(btif_av_sink.Callbacks()->audio_config_cb,
|
peer_address, sample_rate, channel_count));
|
}
|
}
|
|
/**
|
* Process BTIF or BTA AV or BTA AVRCP events. The processing is done on the
|
* JNI thread.
|
*
|
* @param peer_sep the corresponding peer's SEP: AVDT_TSEP_SRC if the peer
|
* is A2DP Source, or AVDT_TSEP_SNK if the peer is A2DP Sink.
|
* @param peer_address the peer address if known, otherwise RawAddress::kEmpty
|
* @param bta_handle the BTA handle for the peer if known, otherwise
|
* kBtaHandleUnknown
|
* @param btif_av_event the corresponding event
|
*/
|
static void btif_av_handle_event(uint8_t peer_sep,
|
const RawAddress& peer_address,
|
tBTA_AV_HNDL bta_handle,
|
const BtifAvEvent& btif_av_event) {
|
BtifAvPeer* peer = nullptr;
|
BTIF_TRACE_EVENT("%s: peer_sep=%s (%d) peer_address=%s handle=0x%x event=%s",
|
__func__, (peer_sep == AVDT_TSEP_SRC) ? "Source" : "Sink",
|
peer_sep, peer_address.ToString().c_str(), bta_handle,
|
btif_av_event.ToString().c_str());
|
|
// Find the peer
|
if (peer_address != RawAddress::kEmpty) {
|
if (peer_sep == AVDT_TSEP_SNK) {
|
peer = btif_av_source.FindOrCreatePeer(peer_address, bta_handle);
|
} else if (peer_sep == AVDT_TSEP_SRC) {
|
peer = btif_av_sink.FindOrCreatePeer(peer_address, bta_handle);
|
}
|
} else if (bta_handle != kBtaHandleUnknown) {
|
if (peer_sep == AVDT_TSEP_SNK) {
|
peer = btif_av_source.FindPeerByHandle(bta_handle);
|
} else if (peer_sep == AVDT_TSEP_SRC) {
|
peer = btif_av_sink.FindPeerByHandle(bta_handle);
|
}
|
}
|
if (peer == nullptr) {
|
BTIF_TRACE_ERROR(
|
"%s: Cannot find or create %s peer for peer_address=%s handle=0x%x : "
|
"event dropped: %s",
|
__func__, (peer_sep == AVDT_TSEP_SRC) ? "Source" : "Sink",
|
peer_address.ToString().c_str(), bta_handle,
|
btif_av_event.ToString().c_str());
|
return;
|
}
|
|
peer->StateMachine().ProcessEvent(btif_av_event.Event(),
|
btif_av_event.Data());
|
}
|
|
/**
|
* Process BTA AV or BTA AVRCP events. The processing is done on the JNI
|
* thread.
|
*
|
* @param peer_sep the corresponding peer's SEP: AVDT_TSEP_SRC if the peer
|
* is A2DP Source, or AVDT_TSEP_SNK if the peer is A2DP Sink.
|
* @param btif_av_event the corresponding event
|
*/
|
static void btif_av_handle_bta_av_event(uint8_t peer_sep,
|
const BtifAvEvent& btif_av_event) {
|
RawAddress peer_address = RawAddress::kEmpty;
|
tBTA_AV_HNDL bta_handle = kBtaHandleUnknown;
|
tBTA_AV_EVT event = btif_av_event.Event();
|
tBTA_AV* p_data = (tBTA_AV*)btif_av_event.Data();
|
|
BTIF_TRACE_DEBUG("%s: peer_sep=%s (%d) event=%s", __func__,
|
(peer_sep == AVDT_TSEP_SRC) ? "Source" : "Sink", peer_sep,
|
btif_av_event.ToString().c_str());
|
|
switch (event) {
|
case BTA_AV_ENABLE_EVT: {
|
const tBTA_AV_ENABLE& enable = p_data->enable;
|
BTIF_TRACE_DEBUG("%s: features=0x%x", __func__, enable.features);
|
return; // Nothing to do
|
}
|
case BTA_AV_REGISTER_EVT: {
|
const tBTA_AV_REGISTER& registr = p_data->registr;
|
bta_handle = registr.hndl;
|
uint8_t peer_id = registr.app_id; // The PeerId is used as AppId
|
BTIF_TRACE_DEBUG("%s: handle=0x%x app_id=%d", __func__, bta_handle,
|
registr.app_id);
|
if (peer_sep == AVDT_TSEP_SNK) {
|
btif_av_source.BtaHandleRegistered(peer_id, bta_handle);
|
} else if (peer_sep == AVDT_TSEP_SRC) {
|
btif_av_sink.BtaHandleRegistered(peer_id, bta_handle);
|
}
|
return; // Nothing else to do
|
}
|
case BTA_AV_OPEN_EVT: {
|
const tBTA_AV_OPEN& open = p_data->open;
|
peer_address = open.bd_addr;
|
bta_handle = open.hndl;
|
break;
|
}
|
case BTA_AV_CLOSE_EVT: {
|
const tBTA_AV_CLOSE& close = p_data->close;
|
bta_handle = close.hndl;
|
break;
|
}
|
case BTA_AV_START_EVT: {
|
const tBTA_AV_START& start = p_data->start;
|
bta_handle = start.hndl;
|
break;
|
}
|
case BTA_AV_SUSPEND_EVT:
|
case BTA_AV_STOP_EVT: {
|
const tBTA_AV_SUSPEND& suspend = p_data->suspend;
|
bta_handle = suspend.hndl;
|
break;
|
}
|
case BTA_AV_PROTECT_REQ_EVT: {
|
const tBTA_AV_PROTECT_REQ& protect_req = p_data->protect_req;
|
bta_handle = protect_req.hndl;
|
break;
|
}
|
case BTA_AV_PROTECT_RSP_EVT: {
|
const tBTA_AV_PROTECT_RSP& protect_rsp = p_data->protect_rsp;
|
bta_handle = protect_rsp.hndl;
|
break;
|
}
|
case BTA_AV_RC_OPEN_EVT: {
|
const tBTA_AV_RC_OPEN& rc_open = p_data->rc_open;
|
peer_address = rc_open.peer_addr;
|
break;
|
}
|
case BTA_AV_RC_CLOSE_EVT: {
|
const tBTA_AV_RC_CLOSE& rc_close = p_data->rc_close;
|
peer_address = rc_close.peer_addr;
|
break;
|
}
|
case BTA_AV_RC_BROWSE_OPEN_EVT: {
|
const tBTA_AV_RC_BROWSE_OPEN& rc_browse_open = p_data->rc_browse_open;
|
peer_address = rc_browse_open.peer_addr;
|
break;
|
}
|
case BTA_AV_RC_BROWSE_CLOSE_EVT: {
|
const tBTA_AV_RC_BROWSE_CLOSE& rc_browse_close = p_data->rc_browse_close;
|
peer_address = rc_browse_close.peer_addr;
|
break;
|
}
|
case BTA_AV_REMOTE_CMD_EVT:
|
case BTA_AV_REMOTE_RSP_EVT:
|
case BTA_AV_VENDOR_CMD_EVT:
|
case BTA_AV_VENDOR_RSP_EVT:
|
case BTA_AV_META_MSG_EVT:
|
case BTA_AV_OFFLOAD_START_RSP_EVT: {
|
// TODO: Might be wrong - this code will be removed once those
|
// events are received from the AVRCP module.
|
if (peer_sep == AVDT_TSEP_SNK) {
|
peer_address = btif_av_source.ActivePeer();
|
} else if (peer_sep == AVDT_TSEP_SRC) {
|
peer_address = btif_av_sink.ActivePeer();
|
}
|
break;
|
}
|
case BTA_AV_RECONFIG_EVT: {
|
const tBTA_AV_RECONFIG& reconfig = p_data->reconfig;
|
bta_handle = reconfig.hndl;
|
break;
|
}
|
case BTA_AV_PENDING_EVT: {
|
const tBTA_AV_PEND& pend = p_data->pend;
|
peer_address = pend.bd_addr;
|
break;
|
}
|
case BTA_AV_REJECT_EVT: {
|
const tBTA_AV_REJECT& reject = p_data->reject;
|
peer_address = reject.bd_addr;
|
bta_handle = reject.hndl;
|
break;
|
}
|
case BTA_AV_RC_FEAT_EVT: {
|
const tBTA_AV_RC_FEAT& rc_feat = p_data->rc_feat;
|
peer_address = rc_feat.peer_addr;
|
break;
|
}
|
}
|
BTIF_TRACE_DEBUG("%s: peer_address=%s handle=0x%x", __func__,
|
peer_address.ToString().c_str(), bta_handle);
|
|
btif_av_handle_event(peer_sep, peer_address, bta_handle, btif_av_event);
|
}
|
|
static void bta_av_source_callback(tBTA_AV_EVT event, tBTA_AV* p_data) {
|
BtifAvEvent btif_av_event(event, p_data, sizeof(tBTA_AV));
|
BTIF_TRACE_EVENT("%s: event=%s", __func__, btif_av_event.ToString().c_str());
|
|
do_in_main_thread(FROM_HERE,
|
base::Bind(&btif_av_handle_bta_av_event,
|
AVDT_TSEP_SNK /* peer_sep */, btif_av_event));
|
}
|
|
static void bta_av_sink_callback(tBTA_AV_EVT event, tBTA_AV* p_data) {
|
BtifAvEvent btif_av_event(event, p_data, sizeof(tBTA_AV));
|
do_in_main_thread(FROM_HERE,
|
base::Bind(&btif_av_handle_bta_av_event,
|
AVDT_TSEP_SRC /* peer_sep */, btif_av_event));
|
}
|
|
// TODO: All processing should be done on the JNI thread
|
static void bta_av_sink_media_callback(tBTA_AV_EVT event,
|
tBTA_AV_MEDIA* p_data) {
|
BTIF_TRACE_EVENT("%s: event=%d", __func__, event);
|
|
switch (event) {
|
case BTA_AV_SINK_MEDIA_DATA_EVT: {
|
BtifAvPeer* peer = btif_av_sink_find_peer(btif_av_sink.ActivePeer());
|
if (peer != nullptr) {
|
int state = peer->StateMachine().StateId();
|
if ((state == BtifAvStateMachine::kStateStarted) ||
|
(state == BtifAvStateMachine::kStateOpened)) {
|
uint8_t queue_len = btif_a2dp_sink_enqueue_buf((BT_HDR*)p_data);
|
BTIF_TRACE_DEBUG("%s: Packets in Sink queue %d", __func__, queue_len);
|
}
|
}
|
break;
|
}
|
case BTA_AV_SINK_MEDIA_CFG_EVT: {
|
btif_av_sink_config_req_t config_req;
|
|
// Update the codec info of the A2DP Sink decoder
|
btif_a2dp_sink_update_decoder((uint8_t*)(p_data->avk_config.codec_info));
|
|
config_req.sample_rate =
|
A2DP_GetTrackSampleRate(p_data->avk_config.codec_info);
|
if (config_req.sample_rate == -1) {
|
APPL_TRACE_ERROR("%s: Cannot get the track frequency", __func__);
|
break;
|
}
|
config_req.channel_count =
|
A2DP_GetTrackChannelCount(p_data->avk_config.codec_info);
|
if (config_req.channel_count == -1) {
|
APPL_TRACE_ERROR("%s: Cannot get the channel count", __func__);
|
break;
|
}
|
config_req.peer_address = p_data->avk_config.bd_addr;
|
BtifAvEvent btif_av_event(BTIF_AV_SINK_CONFIG_REQ_EVT, &config_req,
|
sizeof(config_req));
|
do_in_main_thread(FROM_HERE,
|
base::Bind(&btif_av_handle_event,
|
AVDT_TSEP_SRC, // peer_sep
|
config_req.peer_address, kBtaHandleUnknown,
|
btif_av_event));
|
break;
|
}
|
default:
|
break;
|
}
|
}
|
|
// Initializes the AV interface for source mode
|
static bt_status_t init_src(
|
btav_source_callbacks_t* callbacks, int max_connected_audio_devices,
|
std::vector<btav_a2dp_codec_config_t> codec_priorities) {
|
BTIF_TRACE_EVENT("%s", __func__);
|
return btif_av_source.Init(callbacks, max_connected_audio_devices,
|
codec_priorities);
|
}
|
|
// Initializes the AV interface for sink mode
|
static bt_status_t init_sink(btav_sink_callbacks_t* callbacks) {
|
BTIF_TRACE_EVENT("%s", __func__);
|
return btif_av_sink.Init(callbacks);
|
}
|
|
// Updates the final focus state reported by components calling this module
|
static void update_audio_focus_state(int state) {
|
BTIF_TRACE_DEBUG("%s: state=%d", __func__, state);
|
btif_a2dp_sink_set_focus_state_req((btif_a2dp_sink_focus_state_t)state);
|
}
|
|
// Updates the track gain (used for ducking).
|
static void update_audio_track_gain(float gain) {
|
BTIF_TRACE_DEBUG("%s: gain=%f", __func__, gain);
|
btif_a2dp_sink_set_audio_track_gain(gain);
|
}
|
|
// Establishes the AV signalling channel with the remote headset
|
static bt_status_t connect_int(RawAddress* peer_address, uint16_t uuid) {
|
BTIF_TRACE_EVENT("%s: peer_address=%s uuid=0x%x", __func__,
|
peer_address->ToString().c_str(), uuid);
|
|
BtifAvPeer* peer = nullptr;
|
if (uuid == UUID_SERVCLASS_AUDIO_SOURCE) {
|
peer = btif_av_source.FindOrCreatePeer(*peer_address, kBtaHandleUnknown);
|
if (peer == nullptr) {
|
return BT_STATUS_FAIL;
|
}
|
} else if (uuid == UUID_SERVCLASS_AUDIO_SINK) {
|
peer = btif_av_sink.FindOrCreatePeer(*peer_address, kBtaHandleUnknown);
|
if (peer == nullptr) {
|
return BT_STATUS_FAIL;
|
}
|
}
|
peer->StateMachine().ProcessEvent(BTIF_AV_CONNECT_REQ_EVT, nullptr);
|
return BT_STATUS_SUCCESS;
|
}
|
|
static void set_source_silence_peer_int(const RawAddress& peer_address,
|
bool silence) {
|
BTIF_TRACE_EVENT("%s: peer_address=%s, silence=%s", __func__,
|
peer_address.ToString().c_str(), silence ? "true" : "false");
|
if (!btif_av_source.SetSilencePeer(peer_address, silence)) {
|
BTIF_TRACE_ERROR("%s: Error setting silence state to %s", __func__,
|
peer_address.ToString().c_str());
|
}
|
}
|
|
// Set the active peer
|
static void set_active_peer_int(uint8_t peer_sep,
|
const RawAddress& peer_address,
|
std::promise<void> peer_ready_promise) {
|
BTIF_TRACE_EVENT("%s: peer_sep=%s (%d) peer_address=%s", __func__,
|
(peer_sep == AVDT_TSEP_SRC) ? "Source" : "Sink", peer_sep,
|
peer_address.ToString().c_str());
|
BtifAvPeer* peer = nullptr;
|
if (peer_sep == AVDT_TSEP_SNK) {
|
if (!btif_av_source.SetActivePeer(peer_address,
|
std::move(peer_ready_promise))) {
|
BTIF_TRACE_ERROR("%s: Error setting %s as active Sink peer", __func__,
|
peer_address.ToString().c_str());
|
}
|
return;
|
}
|
if (peer_sep == AVDT_TSEP_SRC) {
|
if (!btif_av_sink.SetActivePeer(peer_address,
|
std::move(peer_ready_promise))) {
|
BTIF_TRACE_ERROR("%s: Error setting %s as active Source peer", __func__,
|
peer_address.ToString().c_str());
|
}
|
return;
|
}
|
// If reached here, we could not set the active peer
|
BTIF_TRACE_ERROR("%s: Cannot set active %s peer to %s: peer not %s", __func__,
|
(peer_sep == AVDT_TSEP_SRC) ? "Source" : "Sink",
|
peer_address.ToString().c_str(),
|
(peer == nullptr) ? "found" : "connected");
|
peer_ready_promise.set_value();
|
}
|
|
static bt_status_t src_connect_sink(const RawAddress& peer_address) {
|
BTIF_TRACE_EVENT("%s: Peer %s", __func__, peer_address.ToString().c_str());
|
|
if (!btif_av_source.Enabled()) {
|
BTIF_TRACE_WARNING("%s: BTIF AV Source is not enabled", __func__);
|
return BT_STATUS_NOT_READY;
|
}
|
|
RawAddress peer_address_copy(peer_address);
|
return btif_queue_connect(UUID_SERVCLASS_AUDIO_SOURCE, &peer_address_copy,
|
connect_int);
|
}
|
|
static bt_status_t sink_connect_src(const RawAddress& peer_address) {
|
LOG_INFO(LOG_TAG, "%s: Peer %s", __func__, peer_address.ToString().c_str());
|
|
if (!btif_av_sink.Enabled()) {
|
BTIF_TRACE_WARNING("%s: BTIF AV Sink is not enabled", __func__);
|
return BT_STATUS_NOT_READY;
|
}
|
|
RawAddress peer_address_copy(peer_address);
|
return btif_queue_connect(UUID_SERVCLASS_AUDIO_SINK, &peer_address_copy,
|
connect_int);
|
}
|
|
static bt_status_t src_disconnect_sink(const RawAddress& peer_address) {
|
LOG_INFO(LOG_TAG, "%s: Peer %s", __func__, peer_address.ToString().c_str());
|
|
if (!btif_av_source.Enabled()) {
|
BTIF_TRACE_WARNING("%s: BTIF AV Source is not enabled", __func__);
|
return BT_STATUS_NOT_READY;
|
}
|
|
BtifAvEvent btif_av_event(BTIF_AV_DISCONNECT_REQ_EVT, &peer_address,
|
sizeof(peer_address));
|
return do_in_main_thread(
|
FROM_HERE, base::Bind(&btif_av_handle_event,
|
AVDT_TSEP_SNK, // peer_sep
|
peer_address, kBtaHandleUnknown, btif_av_event));
|
}
|
|
static bt_status_t sink_disconnect_src(const RawAddress& peer_address) {
|
LOG_INFO(LOG_TAG, "%s: Peer %s", __func__, peer_address.ToString().c_str());
|
|
if (!btif_av_sink.Enabled()) {
|
BTIF_TRACE_WARNING("%s: BTIF AV Sink is not enabled", __func__);
|
return BT_STATUS_NOT_READY;
|
}
|
|
BtifAvEvent btif_av_event(BTIF_AV_DISCONNECT_REQ_EVT, &peer_address,
|
sizeof(peer_address));
|
return do_in_main_thread(
|
FROM_HERE, base::Bind(&btif_av_handle_event,
|
AVDT_TSEP_SRC, // peer_sep
|
peer_address, kBtaHandleUnknown, btif_av_event));
|
}
|
|
static bt_status_t src_set_silence_sink(const RawAddress& peer_address,
|
bool silence) {
|
BTIF_TRACE_EVENT("%s: Peer %s", __func__, peer_address.ToString().c_str());
|
if (!btif_av_source.Enabled()) {
|
BTIF_TRACE_WARNING("%s: BTIF AV Source is not enabled", __func__);
|
return BT_STATUS_NOT_READY;
|
}
|
|
return do_in_main_thread(FROM_HERE, base::Bind(&set_source_silence_peer_int,
|
peer_address, silence));
|
}
|
|
static bt_status_t src_set_active_sink(const RawAddress& peer_address) {
|
BTIF_TRACE_EVENT("%s: Peer %s", __func__, peer_address.ToString().c_str());
|
|
if (!btif_av_source.Enabled()) {
|
LOG(WARNING) << __func__ << ": BTIF AV Source is not enabled";
|
return BT_STATUS_NOT_READY;
|
}
|
|
std::promise<void> peer_ready_promise;
|
std::future<void> peer_ready_future = peer_ready_promise.get_future();
|
bt_status_t status = do_in_main_thread(
|
FROM_HERE, base::BindOnce(&set_active_peer_int,
|
AVDT_TSEP_SNK, // peer_sep
|
peer_address, std::move(peer_ready_promise)));
|
if (status == BT_STATUS_SUCCESS) {
|
peer_ready_future.wait();
|
} else {
|
LOG(WARNING) << __func__ << ": BTIF AV Source fails to change peer";
|
}
|
return status;
|
}
|
|
static bt_status_t codec_config_src(
|
const RawAddress& peer_address,
|
std::vector<btav_a2dp_codec_config_t> codec_preferences) {
|
BTIF_TRACE_EVENT("%s", __func__);
|
|
if (!btif_av_source.Enabled()) {
|
LOG(WARNING) << __func__ << ": BTIF AV Source is not enabled";
|
return BT_STATUS_NOT_READY;
|
}
|
|
std::promise<void> peer_ready_promise;
|
std::future<void> peer_ready_future = peer_ready_promise.get_future();
|
bt_status_t status = do_in_main_thread(
|
FROM_HERE,
|
base::BindOnce(&BtifAvSource::UpdateCodecConfig,
|
base::Unretained(&btif_av_source), peer_address,
|
codec_preferences, std::move(peer_ready_promise)));
|
if (status == BT_STATUS_SUCCESS) {
|
peer_ready_future.wait();
|
} else {
|
LOG(WARNING) << __func__ << ": BTIF AV Source fails to config codec";
|
}
|
return status;
|
}
|
|
static void cleanup_src(void) {
|
BTIF_TRACE_EVENT("%s", __func__);
|
do_in_main_thread(FROM_HERE, base::Bind(&BtifAvSource::Cleanup,
|
base::Unretained(&btif_av_source)));
|
}
|
|
static void cleanup_sink(void) {
|
BTIF_TRACE_EVENT("%s", __func__);
|
do_in_main_thread(FROM_HERE, base::Bind(&BtifAvSink::Cleanup,
|
base::Unretained(&btif_av_sink)));
|
}
|
|
static const btav_source_interface_t bt_av_src_interface = {
|
sizeof(btav_source_interface_t),
|
init_src,
|
src_connect_sink,
|
src_disconnect_sink,
|
src_set_silence_sink,
|
src_set_active_sink,
|
codec_config_src,
|
cleanup_src,
|
};
|
|
static const btav_sink_interface_t bt_av_sink_interface = {
|
sizeof(btav_sink_interface_t), init_sink, sink_connect_src,
|
sink_disconnect_src, cleanup_sink, update_audio_focus_state,
|
update_audio_track_gain,
|
};
|
|
RawAddress btif_av_source_active_peer(void) {
|
return btif_av_source.ActivePeer();
|
}
|
RawAddress btif_av_sink_active_peer(void) { return btif_av_sink.ActivePeer(); }
|
|
bool btif_av_is_sink_enabled(void) { return btif_av_sink.Enabled(); }
|
|
void btif_av_stream_start(void) {
|
LOG_INFO(LOG_TAG, "%s", __func__);
|
btif_av_source_dispatch_sm_event(btif_av_source_active_peer(),
|
BTIF_AV_START_STREAM_REQ_EVT);
|
}
|
|
void btif_av_stream_stop(const RawAddress& peer_address) {
|
LOG_INFO(LOG_TAG, "%s peer %s", __func__, peer_address.ToString().c_str());
|
|
if (!peer_address.IsEmpty()) {
|
btif_av_source_dispatch_sm_event(peer_address, BTIF_AV_STOP_STREAM_REQ_EVT);
|
return;
|
}
|
|
// The active peer might have changed and we might be in the process
|
// of reconfiguring the stream. We need to stop the appopriate peer(s).
|
for (auto it : btif_av_source.Peers()) {
|
const BtifAvPeer* peer = it.second;
|
btif_av_source_dispatch_sm_event(peer->PeerAddress(),
|
BTIF_AV_STOP_STREAM_REQ_EVT);
|
}
|
}
|
|
void btif_av_stream_suspend(void) {
|
LOG_INFO(LOG_TAG, "%s", __func__);
|
// The active peer might have changed and we might be in the process
|
// of reconfiguring the stream. We need to suspend the appropriate peer(s).
|
for (auto it : btif_av_source.Peers()) {
|
const BtifAvPeer* peer = it.second;
|
btif_av_source_dispatch_sm_event(peer->PeerAddress(),
|
BTIF_AV_SUSPEND_STREAM_REQ_EVT);
|
}
|
}
|
|
void btif_av_stream_start_offload(void) {
|
LOG_INFO(LOG_TAG, "%s", __func__);
|
btif_av_source_dispatch_sm_event(btif_av_source_active_peer(),
|
BTIF_AV_OFFLOAD_START_REQ_EVT);
|
}
|
|
void btif_av_src_disconnect_sink(const RawAddress& peer_address) {
|
LOG_INFO(LOG_TAG, "%s: peer %s", __func__, peer_address.ToString().c_str());
|
src_disconnect_sink(peer_address);
|
}
|
|
bool btif_av_stream_ready(void) {
|
// Make sure the main adapter is enabled
|
if (btif_is_enabled() == 0) {
|
BTIF_TRACE_EVENT("%s: Main adapter is not enabled", __func__);
|
return false;
|
}
|
|
BtifAvPeer* peer = btif_av_find_active_peer();
|
if (peer == nullptr) {
|
BTIF_TRACE_WARNING("%s: No active peer found", __func__);
|
return false;
|
}
|
|
int state = peer->StateMachine().StateId();
|
LOG_INFO(LOG_TAG, "%s: Peer %s : state=%d, flags=%s", __func__,
|
peer->PeerAddress().ToString().c_str(), state,
|
peer->FlagsToString().c_str());
|
// check if we are remotely suspended or stop is pending
|
if (peer->CheckFlags(BtifAvPeer::kFlagRemoteSuspend |
|
BtifAvPeer::kFlagPendingStop)) {
|
return false;
|
}
|
|
return (state == BtifAvStateMachine::kStateOpened);
|
}
|
|
bool btif_av_stream_started_ready(void) {
|
BtifAvPeer* peer = btif_av_find_active_peer();
|
if (peer == nullptr) {
|
BTIF_TRACE_WARNING("%s: No active peer found", __func__);
|
return false;
|
}
|
|
int state = peer->StateMachine().StateId();
|
bool ready = false;
|
if (peer->CheckFlags(BtifAvPeer::kFlagLocalSuspendPending |
|
BtifAvPeer::kFlagRemoteSuspend |
|
BtifAvPeer::kFlagPendingStop)) {
|
// Disallow media task to start if we have pending actions
|
ready = false;
|
} else {
|
ready = (state == BtifAvStateMachine::kStateStarted);
|
}
|
LOG_INFO(LOG_TAG, "%s: Peer %s : state=%d flags=%s ready=%d", __func__,
|
peer->PeerAddress().ToString().c_str(), state,
|
peer->FlagsToString().c_str(), ready);
|
|
return ready;
|
}
|
|
static void btif_av_source_dispatch_sm_event(const RawAddress& peer_address,
|
btif_av_sm_event_t event) {
|
BtifAvEvent btif_av_event(event, nullptr, 0);
|
BTIF_TRACE_EVENT("%s: peer_address=%s event=%s", __func__,
|
peer_address.ToString().c_str(),
|
btif_av_event.ToString().c_str());
|
|
do_in_main_thread(FROM_HERE,
|
base::Bind(&btif_av_handle_event,
|
AVDT_TSEP_SNK, // peer_sep
|
peer_address, kBtaHandleUnknown, btif_av_event));
|
}
|
|
static void btif_av_sink_dispatch_sm_event(const RawAddress& peer_address,
|
btif_av_sm_event_t event) {
|
BtifAvEvent btif_av_event(event, nullptr, 0);
|
BTIF_TRACE_EVENT("%s: peer_address=%s event=%s", __func__,
|
peer_address.ToString().c_str(),
|
btif_av_event.ToString().c_str());
|
|
do_in_main_thread(FROM_HERE,
|
base::Bind(&btif_av_handle_event,
|
AVDT_TSEP_SRC, // peer_sep
|
peer_address, kBtaHandleUnknown, btif_av_event));
|
}
|
|
bt_status_t btif_av_source_execute_service(bool enable) {
|
BTIF_TRACE_EVENT("%s: Source service: %s", __func__,
|
(enable) ? "enable" : "disable");
|
|
if (enable) {
|
// TODO: Removed BTA_SEC_AUTHORIZE since the Java/App does not
|
// handle this request in order to allow incoming connections to succeed.
|
// We need to put this back once support for this is added.
|
|
// Added BTA_AV_FEAT_NO_SCO_SSPD - this ensures that the BTA does not
|
// auto-suspend av streaming on AG events(SCO or Call). The suspend shall
|
// be initiated by the app/audioflinger layers.
|
// Support for browsing for SDP record should work only if we enable BROWSE
|
// while registering.
|
tBTA_AV_FEAT features = BTA_AV_FEAT_RCTG | BTA_AV_FEAT_METADATA |
|
BTA_AV_FEAT_VENDOR | BTA_AV_FEAT_NO_SCO_SSPD;
|
|
if (delay_reporting_enabled()) {
|
features |= BTA_AV_FEAT_DELAY_RPT;
|
}
|
|
#if (AVRC_ADV_CTRL_INCLUDED == TRUE)
|
features |= BTA_AV_FEAT_RCCT | BTA_AV_FEAT_ADV_CTRL | BTA_AV_FEAT_BROWSE;
|
#endif
|
BTA_AvEnable(BTA_SEC_AUTHENTICATE, features, bta_av_source_callback);
|
btif_av_source.RegisterAllBtaHandles();
|
return BT_STATUS_SUCCESS;
|
}
|
|
// Disable the service
|
btif_av_source.DeregisterAllBtaHandles();
|
BTA_AvDisable();
|
return BT_STATUS_SUCCESS;
|
}
|
|
bt_status_t btif_av_sink_execute_service(bool enable) {
|
BTIF_TRACE_EVENT("%s: Sink service: %s", __func__,
|
(enable) ? "enable" : "disable");
|
|
if (enable) {
|
// Added BTA_AV_FEAT_NO_SCO_SSPD - this ensures that the BTA does not
|
// auto-suspend AV streaming on AG events (SCO or Call). The suspend shall
|
// be initiated by the app/audioflinger layers.
|
tBTA_AV_FEAT features = BTA_AV_FEAT_NO_SCO_SSPD | BTA_AV_FEAT_RCCT |
|
BTA_AV_FEAT_METADATA | BTA_AV_FEAT_VENDOR |
|
BTA_AV_FEAT_ADV_CTRL | BTA_AV_FEAT_RCTG |
|
BTA_AV_FEAT_BROWSE;
|
BTA_AvEnable(BTA_SEC_AUTHENTICATE, features, bta_av_sink_callback);
|
btif_av_sink.RegisterAllBtaHandles();
|
return BT_STATUS_SUCCESS;
|
}
|
|
// Disable the service
|
btif_av_sink.DeregisterAllBtaHandles();
|
BTA_AvDisable();
|
return BT_STATUS_SUCCESS;
|
}
|
|
// Get the AV callback interface for A2DP source profile
|
const btav_source_interface_t* btif_av_get_src_interface(void) {
|
BTIF_TRACE_EVENT("%s", __func__);
|
return &bt_av_src_interface;
|
}
|
|
// Get the AV callback interface for A2DP sink profile
|
const btav_sink_interface_t* btif_av_get_sink_interface(void) {
|
BTIF_TRACE_EVENT("%s", __func__);
|
return &bt_av_sink_interface;
|
}
|
|
bool btif_av_is_connected(void) {
|
BtifAvPeer* peer = btif_av_find_active_peer();
|
if (peer == nullptr) {
|
BTIF_TRACE_WARNING("%s: No active peer found", __func__);
|
return false;
|
}
|
|
bool connected = peer->IsConnected();
|
BTIF_TRACE_DEBUG("%s: Peer %s is %s", __func__,
|
peer->PeerAddress().ToString().c_str(),
|
(connected) ? "connected" : "not connected");
|
return connected;
|
}
|
|
uint8_t btif_av_get_peer_sep(void) {
|
BtifAvPeer* peer = btif_av_find_active_peer();
|
if (peer == nullptr) {
|
BTIF_TRACE_WARNING("%s: No active peer found", __func__);
|
return AVDT_TSEP_SNK;
|
}
|
|
uint8_t peer_sep = peer->PeerSep();
|
BTIF_TRACE_DEBUG("%s: Peer %s SEP is %s (%d)", __func__,
|
peer->PeerAddress().ToString().c_str(),
|
(peer_sep == AVDT_TSEP_SRC) ? "Source" : "Sink", peer_sep);
|
return peer_sep;
|
}
|
|
void btif_av_clear_remote_suspend_flag(void) {
|
BtifAvPeer* peer = btif_av_find_active_peer();
|
if (peer == nullptr) {
|
BTIF_TRACE_WARNING("%s: No active peer found", __func__);
|
return;
|
}
|
|
BTIF_TRACE_DEBUG("%s: Peer %s : flags=%s are cleared", __func__,
|
peer->PeerAddress().ToString().c_str(),
|
peer->FlagsToString().c_str());
|
peer->ClearFlags(BtifAvPeer::kFlagRemoteSuspend);
|
}
|
|
bool btif_av_is_peer_edr(const RawAddress& peer_address) {
|
BtifAvPeer* peer = btif_av_find_peer(peer_address);
|
if (peer == nullptr) {
|
BTIF_TRACE_WARNING("%s: No peer found for peer_address=%s", __func__,
|
peer_address.ToString().c_str());
|
return false;
|
}
|
if (!peer->IsConnected()) {
|
BTIF_TRACE_WARNING("%s: Peer %s is not connected", __func__,
|
peer_address.ToString().c_str());
|
return false;
|
}
|
|
bool is_edr = peer->IsEdr();
|
BTIF_TRACE_DEBUG("%s: Peer %s : is_edr=%d", __func__,
|
peer_address.ToString().c_str(), is_edr);
|
return is_edr;
|
}
|
|
bool btif_av_peer_supports_3mbps(const RawAddress& peer_address) {
|
BtifAvPeer* peer = btif_av_find_peer(peer_address);
|
if (peer == nullptr) {
|
BTIF_TRACE_WARNING("%s: No peer found for peer_address=%s", __func__,
|
peer_address.ToString().c_str());
|
return false;
|
}
|
|
bool is3mbps = peer->Is3Mbps();
|
bool is_connected = peer->IsConnected();
|
BTIF_TRACE_DEBUG("%s: Peer %s : connected=%d, edr_3mbps=%d", __func__,
|
peer_address.ToString().c_str(), is_connected, is3mbps);
|
return (is_connected && is3mbps);
|
}
|
|
void btif_av_acl_disconnected(const RawAddress& peer_address) {
|
// Inform the application that ACL is disconnected and move to idle state
|
LOG_INFO(LOG_TAG, "%s: Peer %s : ACL Disconnected", __func__,
|
peer_address.ToString().c_str());
|
|
if (btif_av_source.Enabled()) {
|
btif_av_source_dispatch_sm_event(peer_address, BTIF_AV_ACL_DISCONNECTED);
|
} else if (btif_av_sink.Enabled()) {
|
btif_av_sink_dispatch_sm_event(peer_address, BTIF_AV_ACL_DISCONNECTED);
|
}
|
}
|
|
static void btif_debug_av_peer_dump(int fd, const BtifAvPeer& peer) {
|
std::string state_str;
|
int state = peer.StateMachine().StateId();
|
switch (state) {
|
case BtifAvStateMachine::kStateIdle:
|
state_str = "Idle";
|
break;
|
case BtifAvStateMachine::kStateOpening:
|
state_str = "Opening";
|
break;
|
case BtifAvStateMachine::kStateOpened:
|
state_str = "Opened";
|
break;
|
case BtifAvStateMachine::kStateStarted:
|
state_str = "Started";
|
break;
|
case BtifAvStateMachine::kStateClosing:
|
state_str = "Closing";
|
break;
|
default:
|
state_str = "Unknown(" + std::to_string(state) + ")";
|
break;
|
}
|
|
dprintf(fd, " Peer: %s\n", peer.PeerAddress().ToString().c_str());
|
dprintf(fd, " Connected: %s\n", peer.IsConnected() ? "true" : "false");
|
dprintf(fd, " Streaming: %s\n", peer.IsStreaming() ? "true" : "false");
|
dprintf(fd, " SEP: %d(%s)\n", peer.PeerSep(),
|
(peer.IsSource()) ? "Source" : "Sink");
|
dprintf(fd, " State Machine: %s\n", state_str.c_str());
|
dprintf(fd, " Flags: %s\n", peer.FlagsToString().c_str());
|
dprintf(fd, " OpenOnRcTimer: %s\n",
|
alarm_is_scheduled(peer.AvOpenOnRcTimer()) ? "Scheduled"
|
: "Not scheduled");
|
dprintf(fd, " BTA Handle: 0x%x\n", peer.BtaHandle());
|
dprintf(fd, " Peer ID: %d\n", peer.PeerId());
|
dprintf(fd, " EDR: %s\n", peer.IsEdr() ? "true" : "false");
|
dprintf(fd, " Support 3Mbps: %s\n", peer.Is3Mbps() ? "true" : "false");
|
dprintf(fd, " Self Initiated Connection: %s\n",
|
peer.SelfInitiatedConnection() ? "true" : "false");
|
}
|
|
static void btif_debug_av_source_dump(int fd) {
|
bool enabled = btif_av_source.Enabled();
|
|
dprintf(fd, "\nA2DP Source State: %s\n", (enabled) ? "Enabled" : "Disabled");
|
if (!enabled) return;
|
dprintf(fd, " Active peer: %s\n",
|
btif_av_source.ActivePeer().ToString().c_str());
|
for (auto it : btif_av_source.Peers()) {
|
const BtifAvPeer* peer = it.second;
|
btif_debug_av_peer_dump(fd, *peer);
|
}
|
}
|
|
static void btif_debug_av_sink_dump(int fd) {
|
bool enabled = btif_av_sink.Enabled();
|
|
dprintf(fd, "\nA2DP Sink State: %s\n", (enabled) ? "Enabled" : "Disabled");
|
if (!enabled) return;
|
dprintf(fd, " Active peer: %s\n",
|
btif_av_sink.ActivePeer().ToString().c_str());
|
dprintf(fd, " Peers:\n");
|
for (auto it : btif_av_sink.Peers()) {
|
const BtifAvPeer* peer = it.second;
|
btif_debug_av_peer_dump(fd, *peer);
|
}
|
}
|
|
void btif_debug_av_dump(int fd) {
|
btif_debug_av_source_dump(fd);
|
btif_debug_av_sink_dump(fd);
|
}
|
|
void btif_av_set_audio_delay(uint16_t delay) {
|
btif_a2dp_control_set_audio_delay(delay);
|
bluetooth::audio::a2dp::set_remote_delay(delay);
|
}
|
|
void btif_av_reset_audio_delay(void) { btif_a2dp_control_reset_audio_delay(); }
|
|
bool btif_av_is_a2dp_offload_enabled() {
|
return btif_av_source.A2dpOffloadEnabled();
|
}
|
|
bool btif_av_is_peer_silenced(const RawAddress& peer_address) {
|
return btif_av_source.IsPeerSilenced(peer_address);
|
}
|
