Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 37d7e9c1 authored by Pavlin Radoslavov's avatar Pavlin Radoslavov
Browse files

Save the AVDTP version after SDP discovery and read it on reconnect 

* Save the AVDTP version discovered by SDP to the device's local
  configuration section with key string of "AvdtpVersion"
* Refactor tBTA_AV_SCB and hide the AVDTP version and peer address
  behind get/set methods:
  AvdtpVersion() / SetAvdtpVersion() / PeerAddress().
* Added new methods tBTA_AV_SCB::OnConnected() and OnDisconnected().
  The former is used to setup some of the internal state when
  connected to a peer: the peer address and read the stored AVDTP
  version from local configuration section.
  The latter is used to reset that state when disconnected
  from that peer.
* Removed field tBTA_AV_SDP_RES.avdt_version because it is never
  set / used.
* Removed duplicate re-definition of AVDT_VERSION inside avdt_api.h

Bug: 78142165
Test: Manual: connect/reconnect with Sennheiser MOMENTUM M2 AEBT headset
Change-Id: Ib9dcd95dc9899fa81f3cd927f127e5cb0f21ef60
parent bb433e24

system/bta/av/bta_av_aact.cc

+168 −140

File changed.

Preview size limit exceeded, changes collapsed.

system/bta/av/bta_av_act.cc

+23 −24
Original line number Diff line number Diff line
@@ -319,7 +319,7 @@ uint8_t bta_av_rc_create(tBTA_AV_CB* p_cb, uint8_t role, uint8_t shdl, 
  tBTA_AV_RCB* p_rcb;



  if (role == AVCT_INT) {

    bda = p_scb->peer_addr;

    bda = p_scb->PeerAddress();

    status = BTA_AV_RC_ROLE_INT;

  } else {

    p_rcb = bta_av_get_rcb_by_shdl(shdl);
@@ -486,7 +486,7 @@ void bta_av_rc_opened(tBTA_AV_CB* p_cb, tBTA_AV_DATA* p_data) { 
  /* find the SCB & stop the timer */

  for (i = 0; i < BTA_AV_NUM_STRS; i++) {

    p_scb = p_cb->p_scb[i];

    if (p_scb && p_scb->peer_addr == p_data->rc_conn_chg.peer_addr) {

    if (p_scb && p_scb->PeerAddress() == p_data->rc_conn_chg.peer_addr) {

      p_scb->rc_handle = p_data->rc_conn_chg.handle;

      APPL_TRACE_DEBUG("%s: shdl:%d, srch %d", __func__, i + 1,

                       p_scb->rc_handle);
@@ -1081,11 +1081,11 @@ void bta_av_stream_chg(tBTA_AV_SCB* p_scb, bool started) { 
  if (started) {

    bta_av_cb.audio_streams |= started_msk;

    /* Let L2CAP know this channel is processed with high priority */

    L2CA_SetAclPriority(p_scb->peer_addr, L2CAP_PRIORITY_HIGH);

    L2CA_SetAclPriority(p_scb->PeerAddress(), L2CAP_PRIORITY_HIGH);

  } else {

    bta_av_cb.audio_streams &= ~started_msk;

    /* Let L2CAP know this channel is processed with low priority */

    L2CA_SetAclPriority(p_scb->peer_addr, L2CAP_PRIORITY_NORMAL);

    L2CA_SetAclPriority(p_scb->PeerAddress(), L2CAP_PRIORITY_NORMAL);

  }

}
@@ -1199,10 +1199,8 @@ void bta_av_conn_chg(tBTA_AV_DATA* p_data) { 
    /* clear the conned mask for this channel */

    p_cb->conn_audio &= ~mask;

    if (p_scb) {

      /* the stream is closed.

       * clear the peer address, so it would not mess up the AVRCP for the next

       * round of operation */

      p_scb->peer_addr = RawAddress::kEmpty;

      // The stream is closed. Clear the state.

      p_scb->OnDisconnected();

      if (p_scb->chnl == BTA_AV_CHNL_AUDIO) {

        if (p_lcb) {

          p_lcb->conn_msk &= ~conn_msk;
@@ -1268,7 +1266,7 @@ void bta_av_conn_chg(tBTA_AV_DATA* p_data) { 
          if (p_scbi->co_started != bta_av_cb.audio_open_cnt) {

            p_scbi->co_started = bta_av_cb.audio_open_cnt;

            L2CA_SetFlushTimeout(

                p_scbi->peer_addr,

                p_scbi->PeerAddress(),

                p_bta_av_cfg->p_audio_flush_to[p_scbi->co_started - 1]);

          }

        }
@@ -1366,7 +1364,7 @@ void bta_av_sig_chg(tBTA_AV_DATA* p_data) { 
          if (p_data->hdr.offset == AVDT_ACP) {

            APPL_TRACE_DEBUG(

                "%s: Incoming L2CAP acquired, set state as incoming", __func__);

            p_cb->p_scb[xx]->peer_addr = p_data->str_msg.bd_addr;

            p_cb->p_scb[xx]->OnConnected(p_data->str_msg.bd_addr);

            p_cb->p_scb[xx]->use_rc =

                true; /* allowing RC for incoming connection */

            bta_av_ssm_execute(p_cb->p_scb[xx], BTA_AV_ACP_CONNECT_EVT, p_data);
@@ -1382,7 +1380,7 @@ void bta_av_sig_chg(tBTA_AV_DATA* p_data) { 


            APPL_TRACE_DEBUG("%s: Re-start timer for AVDTP service", __func__);

            bta_sys_conn_open(BTA_ID_AV, p_cb->p_scb[xx]->app_id,

                              p_cb->p_scb[xx]->peer_addr);

                              p_cb->p_scb[xx]->PeerAddress());

            /* Possible collision : need to avoid outgoing processing while the

             * timer is running */

            p_cb->p_scb[xx]->coll_mask = BTA_AV_COLL_INC_TMR;
@@ -1422,18 +1420,18 @@ void bta_av_sig_chg(tBTA_AV_DATA* p_data) { 
      /* clean up ssm  */

      for (xx = 0; xx < BTA_AV_NUM_STRS; xx++) {

        if (p_cb->p_scb[xx] &&

            p_cb->p_scb[xx]->peer_addr == p_data->str_msg.bd_addr) {

            p_cb->p_scb[xx]->PeerAddress() == p_data->str_msg.bd_addr) {

          APPL_TRACE_DEBUG("%s: Closing timer for AVDTP service", __func__);

          bta_sys_conn_close(BTA_ID_AV, p_cb->p_scb[xx]->app_id,

                             p_cb->p_scb[xx]->peer_addr);

                             p_cb->p_scb[xx]->PeerAddress());

        }

        mask = 1 << (xx + 1);

        if (((mask & p_lcb->conn_msk) || bta_av_cb.conn_lcb) &&

            p_cb->p_scb[xx] &&

            p_cb->p_scb[xx]->peer_addr == p_data->str_msg.bd_addr) {

            p_cb->p_scb[xx]->PeerAddress() == p_data->str_msg.bd_addr) {

          APPL_TRACE_WARNING("%s: Sending AVDT_DISCONNECT_EVT peer_addr=%s",

                             __func__,

                             p_cb->p_scb[xx]->peer_addr.ToString().c_str());

                             p_cb->p_scb[xx]->PeerAddress().ToString().c_str());

          bta_av_ssm_execute(p_cb->p_scb[xx], BTA_AV_AVDT_DISCONNECT_EVT, NULL);

        }

      }
@@ -1775,7 +1773,7 @@ void bta_av_rc_disc_done(UNUSED_ATTR tBTA_AV_DATA* p_data) { 
            (peer_features & BTA_AV_FEAT_RCTG)) ||

           ((p_cb->features & BTA_AV_FEAT_RCTG) &&

            (peer_features & BTA_AV_FEAT_RCCT)))) {

        p_lcb = bta_av_find_lcb(p_scb->peer_addr, BTA_AV_LCB_FIND);

        p_lcb = bta_av_find_lcb(p_scb->PeerAddress(), BTA_AV_LCB_FIND);

        if (p_lcb) {

          rc_handle = bta_av_rc_create(p_cb, AVCT_INT,

                                       (uint8_t)(p_scb->hdi + 1), p_lcb->lidx);
@@ -1787,7 +1785,7 @@ void bta_av_rc_disc_done(UNUSED_ATTR tBTA_AV_DATA* p_data) { 
        /* can not find AVRC on peer device. report failure */

        p_scb->use_rc = false;

        tBTA_AV_RC_OPEN rc_open;

        rc_open.peer_addr = p_scb->peer_addr;

        rc_open.peer_addr = p_scb->PeerAddress();

        rc_open.peer_features = 0;

        rc_open.status = BTA_AV_FAIL_SDP;

        tBTA_AV bta_av_data;
@@ -1808,7 +1806,7 @@ void bta_av_rc_disc_done(UNUSED_ATTR tBTA_AV_DATA* p_data) { 
       */

      rc_feat.peer_addr = p_cb->lcb[p_cb->rcb[rc_handle].lidx].addr;

    } else {

      rc_feat.peer_addr = p_scb->peer_addr;

      rc_feat.peer_addr = p_scb->PeerAddress();

    }

    tBTA_AV bta_av_data;

    bta_av_data.rc_feat = rc_feat;
@@ -1853,7 +1851,7 @@ void bta_av_rc_closed(tBTA_AV_DATA* p_data) { 
          p_scb = bta_av_cb.p_scb[p_rcb->shdl - 1];

        }

        if (p_scb) {

          rc_close.peer_addr = p_scb->peer_addr;

          rc_close.peer_addr = p_scb->PeerAddress();

          if (p_scb->rc_handle == p_rcb->handle)

            p_scb->rc_handle = BTA_AV_RC_HANDLE_NONE;

          APPL_TRACE_DEBUG("%s: shdl:%d, srch:%d", __func__, p_rcb->shdl,
@@ -1971,7 +1969,7 @@ void bta_av_rc_disc(uint8_t disc) { 
                          ATTR_ID_SUPPORTED_FEATURES};

  uint8_t hdi;

  tBTA_AV_SCB* p_scb;

  RawAddress* p_addr = NULL;

  RawAddress peer_addr = RawAddress::kEmpty;

  uint8_t rc_handle;



  APPL_TRACE_DEBUG("%s: disc: 0x%x, bta_av_cb.disc: 0x%x", __func__, disc,
@@ -1982,7 +1980,7 @@ void bta_av_rc_disc(uint8_t disc) { 
    /* this is the rc handle/index to tBTA_AV_RCB */

    rc_handle = disc & (~BTA_AV_CHNL_MSK);

    if (p_cb->rcb[rc_handle].lidx) {

      p_addr = &p_cb->lcb[p_cb->rcb[rc_handle].lidx - 1].addr;

      peer_addr = p_cb->lcb[p_cb->rcb[rc_handle].lidx - 1].addr;

    }

  } else {

    hdi = (disc & BTA_AV_HNDL_MSK) - 1;
@@ -1990,11 +1988,11 @@ void bta_av_rc_disc(uint8_t disc) { 


    if (p_scb) {

      APPL_TRACE_DEBUG("%s: rc_handle %d", __func__, p_scb->rc_handle);

      p_addr = &p_scb->peer_addr;

      peer_addr = p_scb->PeerAddress();

    }

  }



  if (p_addr) {

  if (!peer_addr.IsEmpty()) {

    /* allocate discovery database */

    if (p_cb->p_disc_db == NULL)

      p_cb->p_disc_db = (tSDP_DISCOVERY_DB*)osi_malloc(BTA_AV_DISC_BUF_SIZE);
@@ -2006,7 +2004,8 @@ void bta_av_rc_disc(uint8_t disc) { 
    db_params.p_attrs = attr_list;



    /* searching for UUID_SERVCLASS_AV_REMOTE_CONTROL gets both TG and CT */

    if (AVRC_FindService(UUID_SERVCLASS_AV_REMOTE_CONTROL, *p_addr, &db_params,

    if (AVRC_FindService(UUID_SERVCLASS_AV_REMOTE_CONTROL, peer_addr,

                         &db_params,

                         base::Bind(bta_av_avrc_sdp_cback)) == AVRC_SUCCESS) {

      p_cb->disc = disc;

      APPL_TRACE_DEBUG("%s: disc 0x%x", __func__, p_cb->disc);

system/bta/av/bta_av_int.h

+37 −4
Original line number Diff line number Diff line
@@ -369,7 +369,6 @@ typedef struct { 
/* data type for BTA_AV_SDP_DISC_OK_EVT */

typedef struct {

  BT_HDR hdr;

  uint16_t avdt_version; /* AVDTP protocol version */

} tBTA_AV_SDP_RES;



/* data type for BTA_AV_API_OFFLOAD_RSP_EVT */
@@ -456,7 +455,9 @@ typedef union { 
  0x02 /* API open was called while incoming timer is running */



/* type for AV stream control block */

struct tBTA_AV_SCB {

// TODO: This should be renamed and changed to a proper class

struct tBTA_AV_SCB final {

 public:

  const tBTA_AV_ACT* p_act_tbl; /* the action table for stream state machine */

  const tBTA_AV_CO_FUNCTS* p_cos; /* the associated callout functions */

  bool sdp_discovery_started; /* variable to determine whether SDP is started */
@@ -467,10 +468,8 @@ struct tBTA_AV_SCB { 
  tAVDT_SEP_INFO sep_info[BTA_AV_NUM_SEPS]; /* stream discovery results */

  AvdtpSepConfig cfg;                       /* local SEP configuration */

  alarm_t* avrc_ct_timer;                   /* delay timer for AVRC CT */

  RawAddress peer_addr;                     /* peer BD address */

  uint16_t l2c_cid;                         /* L2CAP channel ID */

  uint16_t stream_mtu;                      /* MTU of stream */

  uint16_t avdt_version;      /* the avdt version of peer device */

  tBTA_SEC sec_mask;          /* security mask */

  uint8_t media_type;         /* Media type: AVDT_MEDIA_TYPE_* */

  bool cong;                  /* true if AVDTP congested */
@@ -515,6 +514,40 @@ struct tBTA_AV_SCB { 
  uint16_t uuid_int; /*intended UUID of Initiator to connect to */

  bool offload_start_pending;

  bool offload_started;



  /**

   * Called to setup the state when connected to a peer.

   *

   * @param peer_address the peer address

   */

  void OnConnected(const RawAddress& peer_address);



  /**

   * Called to clear the state when disconnected from a peer.

   *

   */

  void OnDisconnected();



  /**

   * Get the peer address.

   */

  const RawAddress& PeerAddress() const { return peer_address_; }



  /**

   * Get the AVDTP version of the peer device.

   */

  uint16_t AvdtpVersion() const { return avdtp_version_; }



  /**

   * Set the AVDTP version of the peer device.

   *

   * @param avdtp_version the AVDTP version to use

   */

  void SetAvdtpVersion(uint16_t avdtp_version);



 private:

  RawAddress peer_address_;  // Peer address

  uint16_t avdtp_version_;   // The AVDTP version of the peer device

};



#define BTA_AV_RC_ROLE_MASK 0x10

system/bta/av/bta_av_main.cc

+55 −17
Original line number Diff line number Diff line
@@ -35,6 +35,7 @@ 
#include "bta_av_co.h"

#include "bta_av_int.h"

#include "btif/include/btif_av_co.h"

#include "btif/include/btif_config.h"

#include "l2c_api.h"

#include "l2cdefs.h"

#include "utl.h"
@@ -267,7 +268,7 @@ static tBTA_AV_SCB* bta_av_addr_to_scb(const RawAddress& bd_addr) { 


  for (xx = 0; xx < BTA_AV_NUM_STRS; xx++) {

    if (bta_av_cb.p_scb[xx]) {

      if (bd_addr == bta_av_cb.p_scb[xx]->peer_addr) {

      if (bd_addr == bta_av_cb.p_scb[xx]->PeerAddress()) {

        p_scb = bta_av_cb.p_scb[xx];

        break;

      }
@@ -316,6 +317,8 @@ static tBTA_AV_SCB* bta_av_alloc_scb(tBTA_AV_CHNL chnl) { 
  for (int xx = 0; xx < BTA_AV_NUM_STRS; xx++) {

    if (bta_av_cb.p_scb[xx] != nullptr) continue;

    // Found an empty spot

    // TODO: After tBTA_AV_SCB is changed to a proper class, the entry

    // here should be allocated by C++ 'new' statement.

    tBTA_AV_SCB* p_ret = (tBTA_AV_SCB*)osi_calloc(sizeof(tBTA_AV_SCB));

    p_ret->rc_handle = BTA_AV_RC_HANDLE_NONE;

    p_ret->chnl = chnl;
@@ -338,9 +341,43 @@ void bta_av_free_scb(tBTA_AV_SCB* p_scb) { 
  CHECK(p_scb == bta_av_cb.p_scb[scb_index]);

  bta_av_cb.p_scb[scb_index] = nullptr;

  alarm_free(p_scb->avrc_ct_timer);

  // TODO: After tBTA_AV_SCB is changed to a proper class, the entry

  // here should be de-allocated by C++ 'delete' statement.

  osi_free(p_scb);

}



void tBTA_AV_SCB::OnConnected(const RawAddress& peer_address) {

  peer_address_ = peer_address;



  if (peer_address.IsEmpty()) {

    LOG_ERROR(LOG_TAG, "%s: Invalid peer address: %s", __func__,

              peer_address.ToString().c_str());

    return;

  }



  // Read and restore the AVDTP version from local storage

  uint16_t avdtp_version = 0;

  size_t version_value_size = sizeof(avdtp_version);

  if (!btif_config_get_bin(peer_address_.ToString(), AVDTP_VERSION_CONFIG_KEY,

                           (uint8_t*)&avdtp_version, &version_value_size)) {

    LOG_WARN(LOG_TAG, "%s: Failed to read cached peer AVDTP version for %s",

             __func__, peer_address_.ToString().c_str());

  } else {

    SetAvdtpVersion(avdtp_version);

  }

}



void tBTA_AV_SCB::OnDisconnected() {

  peer_address_ = RawAddress::kEmpty;

  SetAvdtpVersion(0);

}



void tBTA_AV_SCB::SetAvdtpVersion(uint16_t avdtp_version) {

  avdtp_version_ = avdtp_version;

  LOG_DEBUG(LOG_TAG, "%s: AVDTP version for %s set to 0x%x", __func__,

            peer_address_.ToString().c_str(), avdtp_version_);

}



/*******************************************************************************

 ******************************************************************************/

void bta_av_conn_cback(UNUSED_ATTR uint8_t handle, const RawAddress& bd_addr,
@@ -775,7 +812,7 @@ bool bta_av_chk_start(tBTA_AV_SCB* p_scb) { 
        if (p_scbi->co_started != bta_av_cb.audio_open_cnt) {

          p_scbi->co_started = bta_av_cb.audio_open_cnt;

          L2CA_SetFlushTimeout(

              p_scbi->peer_addr,

              p_scbi->PeerAddress(),

              p_bta_av_cfg->p_audio_flush_to[p_scbi->co_started - 1]);

        }

      }
@@ -805,7 +842,7 @@ void bta_av_restore_switch(void) { 
    if (p_cb->conn_audio == mask) {

      if (p_cb->p_scb[i]) {

        bta_sys_set_policy(BTA_ID_AV, HCI_ENABLE_MASTER_SLAVE_SWITCH,

                           p_cb->p_scb[i]->peer_addr);

                           p_cb->p_scb[i]->PeerAddress());

      }

      break;

    }
@@ -838,7 +875,7 @@ static void bta_av_sys_rs_cback(UNUSED_ATTR tBTA_SYS_CONN_STATUS status, 
     * role change event */

    /* note that more than one SCB (a2dp & vdp) maybe waiting for this event */

    p_scb = bta_av_cb.p_scb[i];

    if (p_scb && p_scb->peer_addr == peer_addr) {

    if (p_scb && p_scb->PeerAddress() == peer_addr) {

      tBTA_AV_ROLE_RES* p_buf =

          (tBTA_AV_ROLE_RES*)osi_malloc(sizeof(tBTA_AV_ROLE_RES));

      APPL_TRACE_DEBUG(
@@ -848,7 +885,8 @@ static void bta_av_sys_rs_cback(UNUSED_ATTR tBTA_SYS_CONN_STATUS status, 
      if ((id != BTM_ROLE_MASTER) && (app_id != HCI_SUCCESS))

      {

          bta_sys_set_policy(BTA_ID_AV,

      (HCI_ENABLE_MASTER_SLAVE_SWITCH|HCI_ENABLE_SNIFF_MODE), p_scb->peer_addr);

      (HCI_ENABLE_MASTER_SLAVE_SWITCH|HCI_ENABLE_SNIFF_MODE),

      p_scb->PeerAddress());

      }

      */

      p_buf->hdr.event = BTA_AV_ROLE_CHANGE_EVT;
@@ -877,8 +915,8 @@ static void bta_av_sys_rs_cback(UNUSED_ATTR tBTA_SYS_CONN_STATUS status, 
    }

    if (p_scb && p_scb->q_tag == BTA_AV_Q_TAG_OPEN) {

      APPL_TRACE_DEBUG("%s: peer %s rs_idx:%d, hndl:0x%x q_tag:%d", __func__,

                       p_scb->peer_addr.ToString().c_str(), bta_av_cb.rs_idx,

                       p_scb->hndl, p_scb->q_tag);

                       p_scb->PeerAddress().ToString().c_str(),

                       bta_av_cb.rs_idx, p_scb->hndl, p_scb->q_tag);



      if (HCI_SUCCESS == app_id || HCI_ERR_NO_CONNECTION == app_id) {

        p_scb->q_info.open.switch_res = BTA_AV_RS_OK;
@@ -887,7 +925,7 @@ static void bta_av_sys_rs_cback(UNUSED_ATTR tBTA_SYS_CONN_STATUS status, 
            "%s: peer %s (p_scb peer %s) role switch failed: new_role:%d "

            "hci_status:0x%x",

            __func__, peer_addr.ToString().c_str(),

            p_scb->peer_addr.ToString().c_str(), id, app_id);

            p_scb->PeerAddress().ToString().c_str(), id, app_id);

        p_scb->q_info.open.switch_res = BTA_AV_RS_FAIL;

      }
@@ -978,15 +1016,15 @@ bool bta_av_switch_if_needed(tBTA_AV_SCB* p_scb) { 
    if (p_scbi && (p_scb->hdi != i) &&   /* not the original channel */

        ((bta_av_cb.conn_audio & mask))) /* connected audio */

    {

      BTM_GetRole(p_scbi->peer_addr, &role);

      BTM_GetRole(p_scbi->PeerAddress(), &role);

      /* this channel is open - clear the role switch link policy for this link

       */

      if (BTM_ROLE_MASTER != role) {

        if (bta_av_cb.features & BTA_AV_FEAT_MASTER)

          bta_sys_clear_policy(BTA_ID_AV, HCI_ENABLE_MASTER_SLAVE_SWITCH,

                               p_scbi->peer_addr);

                               p_scbi->PeerAddress());

        if (BTM_CMD_STARTED !=

            BTM_SwitchRole(p_scbi->peer_addr, BTM_ROLE_MASTER, NULL)) {

            BTM_SwitchRole(p_scbi->PeerAddress(), BTM_ROLE_MASTER, NULL)) {

          /* can not switch role on SCBI

           * start the timer on SCB - because this function is ONLY called when

           * SCB gets API_OPEN */
@@ -1018,7 +1056,7 @@ bool bta_av_link_role_ok(tBTA_AV_SCB* p_scb, uint8_t bits) { 
  uint8_t role;

  bool is_ok = true;



  if (BTM_GetRole(p_scb->peer_addr, &role) == BTM_SUCCESS) {

  if (BTM_GetRole(p_scb->PeerAddress(), &role) == BTM_SUCCESS) {

    LOG_INFO(LOG_TAG,

             "%s: hndl:x%x role:%d conn_audio:x%x bits:%d features:x%x",

             __func__, p_scb->hndl, role, bta_av_cb.conn_audio, bits,
@@ -1028,10 +1066,10 @@ bool bta_av_link_role_ok(tBTA_AV_SCB* p_scb, uint8_t bits) { 
         (bta_av_cb.features & BTA_AV_FEAT_MASTER))) {

      if (bta_av_cb.features & BTA_AV_FEAT_MASTER)

        bta_sys_clear_policy(BTA_ID_AV, HCI_ENABLE_MASTER_SLAVE_SWITCH,

                             p_scb->peer_addr);

                             p_scb->PeerAddress());



      if (BTM_CMD_STARTED !=

          BTM_SwitchRole(p_scb->peer_addr, BTM_ROLE_MASTER, NULL)) {

          BTM_SwitchRole(p_scb->PeerAddress(), BTM_ROLE_MASTER, NULL)) {

        /* can not switch role on SCB - start the timer on SCB */

      }

      is_ok = false;
@@ -1113,7 +1151,7 @@ void bta_av_dup_audio_buf(tBTA_AV_SCB* p_scb, BT_HDR* p_buf) { 


    if (list_length(p_scbi->a2dp_list) > p_bta_av_cfg->audio_mqs) {

      // Drop the oldest packet

      bta_av_co_audio_drop(p_scbi->hndl, p_scbi->peer_addr);

      bta_av_co_audio_drop(p_scbi->hndl, p_scbi->PeerAddress());

      BT_HDR* p_buf_drop = static_cast<BT_HDR*>(list_front(p_scbi->a2dp_list));

      list_remove(p_scbi->a2dp_list, p_buf_drop);

      osi_free(p_buf_drop);
@@ -1390,7 +1428,7 @@ void bta_debug_av_dump(int fd) { 
      continue;

    }

    dprintf(fd, "\n  BTA ID: %zu peer: %s\n", i,

            p_scb->peer_addr.ToString().c_str());

            p_scb->PeerAddress().ToString().c_str());

    dprintf(fd, "    SDP discovery started: %s\n",

            p_scb->sdp_discovery_started ? "true" : "false");

    for (size_t j = 0; j < BTAV_A2DP_CODEC_INDEX_MAX; j++) {
@@ -1418,7 +1456,7 @@ void bta_debug_av_dump(int fd) { 
    // TODO: Print p_scb->sep_info[], cfg, avrc_ct_timer, current_codec ?

    dprintf(fd, "    L2CAP Channel ID: %d\n", p_scb->l2c_cid);

    dprintf(fd, "    Stream MTU: %d\n", p_scb->stream_mtu);

    dprintf(fd, "    AVDTP version: 0x%x\n", p_scb->avdt_version);

    dprintf(fd, "    AVDTP version: 0x%x\n", p_scb->AvdtpVersion());

    dprintf(fd, "    Security mask: 0x%x\n", p_scb->sec_mask);

    dprintf(fd, "    Media type: %d\n", p_scb->media_type);

    dprintf(fd, "    Congested: %s\n", p_scb->cong ? "true" : "false");

system/bta/av/bta_av_ssm.cc

+5 −5
Original line number Diff line number Diff line
@@ -488,7 +488,7 @@ void bta_av_ssm_execute(tBTA_AV_SCB* p_scb, uint16_t event, 


  APPL_TRACE_VERBOSE(

      "%s: peer %s AV event(0x%x)=0x%x(%s) state=%d(%s) p_scb=%p", __func__,

      p_scb->peer_addr.ToString().c_str(), p_scb->hndl, event,

      p_scb->PeerAddress().ToString().c_str(), p_scb->hndl, event,

      bta_av_evt_code(event), p_scb->state, bta_av_sst_code(p_scb->state),

      p_scb);
@@ -500,7 +500,7 @@ void bta_av_ssm_execute(tBTA_AV_SCB* p_scb, uint16_t event, 
  p_scb->state = state_table[event][BTA_AV_SNEXT_STATE];



  APPL_TRACE_VERBOSE("%s: peer %s AV next state=%d(%s) p_scb=%p", __func__,

                     p_scb->peer_addr.ToString().c_str(), p_scb->state,

                     p_scb->PeerAddress().ToString().c_str(), p_scb->state,

                     bta_av_sst_code(p_scb->state), p_scb);



  /* execute action functions */
@@ -572,9 +572,9 @@ void bta_av_set_scb_sst_init(tBTA_AV_SCB* p_scb) { 


  APPL_TRACE_VERBOSE(

      "%s: peer %s AV (hndl=0x%x) state=%d(%s) next state=%d(%s) p_scb=%p",

      __func__, p_scb->peer_addr.ToString().c_str(), p_scb->hndl, p_scb->state,

      bta_av_sst_code(p_scb->state), next_state, bta_av_sst_code(next_state),

      p_scb);

      __func__, p_scb->PeerAddress().ToString().c_str(), p_scb->hndl,

      p_scb->state, bta_av_sst_code(p_scb->state), next_state,

      bta_av_sst_code(next_state), p_scb);



  p_scb->state = next_state;

}