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

Commit 0071bf36 authored by android-build-team Robot's avatar android-build-team Robot
Browse files

Snap for 7047375 from 7e0dd5ef to sc-release 

Change-Id: I3e68f0a28d6f9474275379c4b54ffe16cd497ecf
parents 79bfed6b 7e0dd5ef

system/bta/ag/bta_ag_int.h

+8 −0
Original line number Diff line number Diff line
@@ -246,6 +246,14 @@ struct tBTA_AG_SCB { 
  tBTA_AG_HF_IND

      local_hf_indicators[BTA_AG_MAX_NUM_LOCAL_HF_IND]; /* Local supported

                                                    HF indicators */



  std::string ToString() const {

    return base::StringPrintf(

        "codec_updated=%d, codec_fallback=%d, "

        "sco_codec=%d, peer_codec=%d, msbc_settings=%d, device=%s",

        codec_updated, codec_fallback, sco_codec, peer_codecs,

        codec_msbc_settings, peer_addr.ToString().c_str());

  }

};



/* type for sco data */

system/bta/av/bta_av_aact.cc

+8 −5
Original line number Diff line number Diff line
@@ -35,6 +35,7 @@ 
#include "a2dp_sbc.h"

#include "avdt_api.h"

#include "avrcp_service.h"

#include "bta_ar_api.h"

#include "bta_av_int.h"

#include "btif/include/btif_av_co.h"

#include "btif/include/btif_config.h"
@@ -42,12 +43,12 @@ 
#include "device/include/interop.h"

#include "l2c_api.h"

#include "l2cdefs.h"

#include "main/shim/dumpsys.h"

#include "osi/include/log.h"

#include "osi/include/osi.h"

#include "osi/include/properties.h"

#include "stack/include/acl_api.h"

#include "utl.h"

#include "bta_ar_api.h"



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

 *  Constants
@@ -1781,11 +1782,13 @@ void bta_av_conn_failed(tBTA_AV_SCB* p_scb, tBTA_AV_DATA* p_data) { 
void bta_av_do_start(tBTA_AV_SCB* p_scb, tBTA_AV_DATA* p_data) {

  uint8_t cur_role;



  LOG_INFO("%s: peer %s sco_occupied:%s role:0x%x started:%s wait:0x%x",

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

           logbool(bta_av_cb.sco_occupied).c_str(), p_scb->role,

  LOG_INFO(

      "A2dp stream start peer:%s sco_occupied:%s role:%s started:%s wait:0x%x",

      PRIVATE_ADDRESS(p_scb->PeerAddress()),

      logbool(bta_av_cb.sco_occupied).c_str(), RoleText(p_scb->role).c_str(),

      logbool(p_scb->started).c_str(), p_scb->wait);

  if (bta_av_cb.sco_occupied) {

    LOG_WARN("A2dp stream start failed");

    bta_av_start_failed(p_scb, p_data);

    return;

  }

system/bta/dm/bta_dm_act.cc

+27 −14
Original line number Diff line number Diff line
@@ -88,8 +88,8 @@ static void bta_dm_set_eir(char* local_name); 


static void bta_dm_search_timer_cback(void* data);

static void bta_dm_disable_conn_down_timer_cback(void* data);

static void bta_dm_rm_cback(tBTA_SYS_CONN_STATUS status, uint8_t id,

                            uint8_t app_id, const RawAddress& peer_addr);

void bta_dm_rm_cback(tBTA_SYS_CONN_STATUS status, uint8_t id, uint8_t app_id,

                     const RawAddress& peer_addr);

static void bta_dm_adjust_roles(bool delay_role_switch);

static char* bta_dm_get_remname(void);

static void bta_dm_bond_cancel_complete_cback(tBTM_STATUS result);
@@ -2136,11 +2136,22 @@ static void bta_dm_local_name_cback(UNUSED_ATTR void* p_name) { 
static void handle_role_change(const RawAddress& bd_addr, uint8_t new_role,

                               uint8_t hci_status) {

  tBTA_DM_PEER_DEVICE* p_dev = bta_dm_find_peer_device(bd_addr);

  if (!p_dev) return;

  LOG_INFO("%s: peer %s info:0x%x new_role:0x%x dev count:%d hci_status=%d",

           __func__, bd_addr.ToString().c_str(), p_dev->info, new_role,

           bta_dm_cb.device_list.count, hci_status);

  if (p_dev->info & BTA_DM_DI_AV_ACTIVE) {

  if (!p_dev) {

    LOG_WARN(

        "Unable to find device for role change peer:%s new_role:%s "

        "hci_status:%s",

        PRIVATE_ADDRESS(bd_addr), RoleText(new_role).c_str(),

        hci_error_code_text(hci_status).c_str());

    return;

  }



  LOG_INFO(

      "Role change callback peer:%s info:0x%x new_role:%s dev count:%d "

      "hci_status:%s",

      PRIVATE_ADDRESS(bd_addr), p_dev->Info(), RoleText(new_role).c_str(),

      bta_dm_cb.device_list.count, hci_error_code_text(hci_status).c_str());



  if (p_dev->Info() & BTA_DM_DI_AV_ACTIVE) {

    bool need_policy_change = false;



    /* there's AV activity on this link */
@@ -2220,7 +2231,7 @@ static tBTA_DM_PEER_DEVICE* allocate_device_for(const RawAddress& bd_addr, 
  return nullptr;

}



static void bta_dm_acl_up(const RawAddress& bd_addr, tBT_TRANSPORT transport) {

void bta_dm_acl_up(const RawAddress& bd_addr, tBT_TRANSPORT transport) {

  auto device = allocate_device_for(bd_addr, transport);

  if (device == nullptr) {

    LOG_WARN("Unable to allocate device resources for new connection");
@@ -2361,9 +2372,9 @@ static void bta_dm_check_av() { 
    for (i = 0; i < bta_dm_cb.device_list.count; i++) {

      p_dev = &bta_dm_cb.device_list.peer_device[i];

      APPL_TRACE_WARNING("[%d]: state:%d, info:x%x", i, p_dev->conn_state,

                         p_dev->info);

                         p_dev->Info());

      if ((p_dev->conn_state == BTA_DM_CONNECTED) &&

          (p_dev->info & BTA_DM_DI_AV_ACTIVE)) {

          (p_dev->Info() & BTA_DM_DI_AV_ACTIVE)) {

        /* make central and take away the role switch policy */

        BTM_SwitchRoleToCentral(p_dev->peer_bdaddr);

        /* else either already central or can not switch for some reasons */
@@ -2402,12 +2413,16 @@ static void bta_dm_disable_conn_down_timer_cback(UNUSED_ATTR void* data) { 
 * Returns          void

 *

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

static void bta_dm_rm_cback(tBTA_SYS_CONN_STATUS status, uint8_t id,

                            uint8_t app_id, const RawAddress& peer_addr) {

void bta_dm_rm_cback(tBTA_SYS_CONN_STATUS status, uint8_t id, uint8_t app_id,

                     const RawAddress& peer_addr) {

  uint8_t j;

  tBTA_PREF_ROLES role;

  tBTA_DM_PEER_DEVICE* p_dev;



  LOG_DEBUG("BTA Role management callback count:%d status:%s peer:%s",

            bta_dm_cb.cur_av_count, bta_sys_conn_status_text(status).c_str(),

            PRIVATE_ADDRESS(peer_addr));



  p_dev = bta_dm_find_peer_device(peer_addr);

  if (status == BTA_SYS_CONN_OPEN) {

    if (p_dev) {
@@ -2444,8 +2459,6 @@ static void bta_dm_rm_cback(tBTA_SYS_CONN_STATUS status, uint8_t id, 
      /* get cur_av_count from connected services */

      if (BTA_ID_AV == id) bta_dm_cb.cur_av_count = bta_dm_get_av_count();

    }

    APPL_TRACE_WARNING("bta_dm_rm_cback:%d, status:%d", bta_dm_cb.cur_av_count,

                       status);

  }



  /* Don't adjust roles for each busy/idle state transition to avoid

system/bta/dm/bta_dm_int.h

+20 −5
Original line number Diff line number Diff line
@@ -28,11 +28,10 @@ 
#include <memory>

#include <string>

#include "bt_target.h"

#include "bta/include/bta_gatt_api.h"

#include "bta/sys/bta_sys.h"

#include "main/shim/dumpsys.h"



#include "bta/include/bta_gatt_api.h"



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

 *  Constants and data types

 ****************************************************************************/
@@ -197,19 +196,35 @@ inline std::string device_info_text(tBTA_DM_DEV_INFO info) { 
#define BTA_DM_PM_EXECUTE 3

typedef uint8_t tBTA_DM_PM_REQ;



typedef struct {

struct sBTA_DM_PEER_DEVICE {

  RawAddress peer_bdaddr;

  tBTA_DM_CONN_STATE conn_state;

  tBTA_PREF_ROLES pref_role;

  bool in_use;



 private:

  friend void bta_dm_acl_up(const RawAddress& bd_addr, tBT_TRANSPORT transport);

  friend void bta_dm_pm_btm_status(const RawAddress& bd_addr,

                                   tBTM_PM_STATUS status, uint16_t value,

                                   tHCI_STATUS hci_status);

  friend void bta_dm_pm_sniff(struct sBTA_DM_PEER_DEVICE* p_peer_dev,

                              uint8_t index);

  friend void bta_dm_rm_cback(tBTA_SYS_CONN_STATUS status, uint8_t id,

                              uint8_t app_id, const RawAddress& peer_addr);

  friend void handle_remote_features_complete(const RawAddress& bd_addr);

  tBTA_DM_DEV_INFO info;



 public:

  tBTA_DM_DEV_INFO Info() const { return info; }



  tBTA_DM_ENCRYPT_CBACK* p_encrypt_cback;

  tBTM_PM_STATUS prev_low; /* previous low power mode used */

  tBTA_DM_PM_ACTION pm_mode_attempted;

  tBTA_DM_PM_ACTION pm_mode_failed;

  bool remove_dev_pending;

  tBT_TRANSPORT transport;

} tBTA_DM_PEER_DEVICE;

};

typedef struct sBTA_DM_PEER_DEVICE tBTA_DM_PEER_DEVICE;



/* structure to store list of

  active connections */
@@ -452,7 +467,7 @@ extern void bta_dm_remove_device(const RawAddress& bd_addr); 
extern void bta_dm_close_acl(const RawAddress&, bool, tBT_TRANSPORT);



extern void bta_dm_pm_btm_status(const RawAddress&, tBTM_PM_STATUS, uint16_t,

                                 uint8_t);

                                 tHCI_STATUS);

extern void bta_dm_pm_timer(const RawAddress&, tBTA_DM_PM_ACTION);

extern void bta_dm_add_ampkey(tBTA_DM_MSG* p_data);

system/bta/dm/bta_dm_pm.cc

+72 −38
Original line number Diff line number Diff line
@@ -49,9 +49,9 @@ static void bta_dm_pm_set_mode(const RawAddress& peer_addr, 
static void bta_dm_pm_timer_cback(void* data);

static void bta_dm_pm_btm_cback(const RawAddress& bd_addr,

                                tBTM_PM_STATUS status, uint16_t value,

                                uint8_t hci_status);

                                tHCI_STATUS hci_status);

static bool bta_dm_pm_park(const RawAddress& peer_addr);

static void bta_dm_pm_sniff(tBTA_DM_PEER_DEVICE* p_peer_dev, uint8_t index);

void bta_dm_pm_sniff(tBTA_DM_PEER_DEVICE* p_peer_dev, uint8_t index);

static bool bta_dm_pm_is_sco_active();

static int bta_dm_get_sco_index();

static void bta_dm_pm_hid_check(bool bScoActive);
@@ -360,7 +360,7 @@ static void bta_dm_pm_cback(tBTA_SYS_CONN_STATUS status, uint8_t id, 


  p_dev = bta_dm_find_peer_device(peer_addr);

  if (p_dev) {

    LOG_DEBUG("Device info:%s", device_info_text(p_dev->info).c_str());

    LOG_DEBUG("Device info:%s", device_info_text(p_dev->Info()).c_str());

  } else {

    LOG_ERROR("Unable to find peer device...yet soldiering on...");

  }
@@ -368,7 +368,7 @@ static void bta_dm_pm_cback(tBTA_SYS_CONN_STATUS status, uint8_t id, 
  /* set SSR parameters on SYS CONN OPEN */

  int index = BTA_DM_PM_SSR0;

  if ((BTA_SYS_CONN_OPEN == status) && p_dev &&

      (p_dev->info & BTA_DM_DI_USE_SSR)) {

      (p_dev->Info() & BTA_DM_DI_USE_SSR)) {

    index = p_bta_dm_pm_spec[p_bta_dm_pm_cfg[i].spec_idx].ssr;

  } else if (BTA_ID_AV == id) {

    if (BTA_SYS_CONN_BUSY == status) {
@@ -427,7 +427,8 @@ static void bta_dm_pm_cback(tBTA_SYS_CONN_STATUS status, uint8_t id, 
    bta_dm_conn_srvcs.conn_srvc[j].new_request = true;

    bta_dm_conn_srvcs.conn_srvc[j].peer_bdaddr = peer_addr;



    LOG_INFO("New connection service id:%d app_id:%d", id, app_id);

    LOG_INFO("New connection service:%s[%hhu] app_id:%d",

             BtaIdSysText(id).c_str(), id, app_id);



    bta_dm_conn_srvcs.count++;

    bta_dm_conn_srvcs.conn_srvc[j].state = status;
@@ -521,12 +522,18 @@ static void bta_dm_pm_set_mode(const RawAddress& peer_addr, 
  uint8_t timer_idx, available_timer = BTA_DM_PM_MODE_TIMER_MAX;

  uint64_t remaining_ms = 0;



  if (!bta_dm_cb.device_list.count) return;

  if (!bta_dm_cb.device_list.count) {

    LOG_INFO("Device list count is zero");

    return;

  }



  /* see if any attempt to put device in low power mode failed */

  p_peer_device = bta_dm_find_peer_device(peer_addr);

  /* if no peer device found return */

  if (p_peer_device == NULL) return;

  if (p_peer_device == NULL) {

    LOG_INFO("No peer device found");

    return;

  }



  failed_pm = p_peer_device->pm_mode_failed;
@@ -546,9 +553,13 @@ static void bta_dm_pm_set_mode(const RawAddress& peer_addr, 
      p_act0 = &p_pm_spec->actn_tbl[p_srvcs->state][0];

      p_act1 = &p_pm_spec->actn_tbl[p_srvcs->state][1];



      APPL_TRACE_DEBUG("bta_dm_pm_set_mode: srvcsid: %d, state: %d, j: %d",

                       p_srvcs->id, p_srvcs->state, j);

      allowed_modes |= p_pm_spec->allow_mask;

      LOG_DEBUG(

          "Service:%s[%hhu] state:%s[%hhu] allowed_modes:0x%02x "

          "service_index:%hhu ",

          BtaIdSysText(p_srvcs->id).c_str(), p_srvcs->id,

          bta_sys_conn_status_text(p_srvcs->state).c_str(), p_srvcs->state,

          allowed_modes, j);



      /* PM actions are in the order of strictness */
@@ -630,10 +641,8 @@ static void bta_dm_pm_set_mode(const RawAddress& peer_addr, 
                                timeout_ms, p_srvcs->id, pm_action);

          timer_started = true;

        }

      }

      /* no more timers */

      else {

        APPL_TRACE_WARNING("bta_dm_act dm_pm_timer no more");

      } else {

        LOG_WARN("no more timers");

      }

    }

    return;
@@ -641,22 +650,30 @@ static void bta_dm_pm_set_mode(const RawAddress& peer_addr, 
  /* if pending power mode timer expires, and currecnt link is in a

     lower power mode than current profile requirement, igonre it */

  if (pm_req == BTA_DM_PM_EXECUTE && pm_request < pm_action) {

    APPL_TRACE_ERROR("Ignore the power mode request: %d", pm_request)

    LOG_ERROR("Ignore the power mode request: %d", pm_request);

    return;

  }

  if (pm_action == BTA_DM_PM_PARK) {

    p_peer_device->pm_mode_attempted = BTA_DM_PM_PARK;

    bta_dm_pm_park(peer_addr);

    LOG_WARN("DEPRECATED Setting link to park mode peer:%s",

             PRIVATE_ADDRESS(peer_addr));

  } else if (pm_action & BTA_DM_PM_SNIFF) {

    /* dont initiate SNIFF, if link_policy has it disabled */

    if (BTM_is_sniff_allowed_for(peer_addr)) {

      LOG_DEBUG(

          "Link policy allows sniff mode so setting mode "

          "peer:%s",

          PRIVATE_ADDRESS(peer_addr));

      p_peer_device->pm_mode_attempted = BTA_DM_PM_SNIFF;

      bta_dm_pm_sniff(p_peer_device, (uint8_t)(pm_action & 0x0F));

    } else {

      APPL_TRACE_DEBUG(

          "bta_dm_pm_set_mode: Link policy disallows SNIFF, ignore request");

      LOG_DEBUG("Link policy disallows sniff mode, ignore request peer:%s",

                PRIVATE_ADDRESS(peer_addr));

    }

  } else if (pm_action == BTA_DM_PM_ACTIVE) {

    LOG_DEBUG("Setting link to active mode peer:%s",

              PRIVATE_ADDRESS(peer_addr));

    bta_dm_pm_active(peer_addr);

  }

}
@@ -700,7 +717,7 @@ static bool bta_dm_pm_park(const RawAddress& peer_addr) { 
 * Returns          true if sniff attempted, false otherwise.

 *

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

static void bta_dm_pm_sniff(tBTA_DM_PEER_DEVICE* p_peer_dev, uint8_t index) {

void bta_dm_pm_sniff(tBTA_DM_PEER_DEVICE* p_peer_dev, uint8_t index) {

  tBTM_PM_MODE mode = BTM_PM_MD_ACTIVE;

  tBTM_PM_PWR_MD pwr_md;

  tBTM_STATUS status;
@@ -710,33 +727,33 @@ static void bta_dm_pm_sniff(tBTA_DM_PEER_DEVICE* p_peer_dev, uint8_t index) { 
             PRIVATE_ADDRESS(p_peer_dev->peer_bdaddr));

  }

  tBTM_PM_STATUS mode_status = static_cast<tBTM_PM_STATUS>(mode);

  LOG_DEBUG("Current power mode:%s[0x%x] peer_mode:x%02x",

  LOG_DEBUG("Current power mode:%s[0x%x] peer_info:%s[0x%02x]",

            power_mode_status_text(mode_status).c_str(), mode_status,

            p_peer_dev->info);

            device_info_text(p_peer_dev->Info()).c_str(), p_peer_dev->Info());



  uint8_t* p_rem_feat = BTM_ReadRemoteFeatures(p_peer_dev->peer_bdaddr);

  LOG_DEBUG("Current power mode:%s[0x%x] peer_info:%s",

            power_mode_status_text(mode).c_str(), mode,

            device_info_text(p_peer_dev->info).c_str());



  const controller_t* controller = controller_get_interface();

  if (mode != BTM_PM_MD_SNIFF ||

      (controller->supports_sniff_subrating() && p_rem_feat &&

       HCI_SNIFF_SUB_RATE_SUPPORTED(p_rem_feat) &&

       !(p_peer_dev->info & BTA_DM_DI_USE_SSR))) {

       !(p_peer_dev->Info() & BTA_DM_DI_USE_SSR))) {

    /* Dont initiate Sniff if controller has alreay accepted

     * remote sniff params. This avoid sniff loop issue with

     * some agrresive headsets who use sniff latencies more than

     * DUT supported range of Sniff intervals.*/

    if ((mode == BTM_PM_MD_SNIFF) && (p_peer_dev->info & BTA_DM_DI_ACP_SNIFF)) {

      APPL_TRACE_DEBUG("%s: already in remote initiate sniff", __func__);

    if ((mode == BTM_PM_MD_SNIFF) &&

        (p_peer_dev->Info() & BTA_DM_DI_ACP_SNIFF)) {

      LOG_DEBUG("Link already in sniff mode peer:%s",

                PRIVATE_ADDRESS(p_peer_dev->peer_bdaddr));

      return;

    }

  }

  /* if the current mode is not sniff, issue the sniff command.

   * If sniff, but SSR is not used in this link, still issue the command */

  memcpy(&pwr_md, &p_bta_dm_pm_md[index], sizeof(tBTM_PM_PWR_MD));

  if (p_peer_dev->info & BTA_DM_DI_INT_SNIFF) {

  if (p_peer_dev->Info() & BTA_DM_DI_INT_SNIFF) {

    LOG_DEBUG("Trying to force power mode");

    pwr_md.mode |= BTM_PM_MD_FORCE;

  }

  status = BTM_SetPowerMode(bta_dm_cb.pm_id, p_peer_dev->peer_bdaddr, &pwr_md);
@@ -747,10 +764,10 @@ static void bta_dm_pm_sniff(tBTA_DM_PEER_DEVICE* p_peer_dev, uint8_t index) { 
    APPL_TRACE_DEBUG("bta_dm_pm_sniff BTM_SetPowerMode() returns BTM_SUCCESS");

    p_peer_dev->info &=

        ~(BTA_DM_DI_INT_SNIFF | BTA_DM_DI_ACP_SNIFF | BTA_DM_DI_SET_SNIFF);

  } else /* error */

  {

    APPL_TRACE_ERROR(

        "bta_dm_pm_sniff BTM_SetPowerMode() returns ERROR status=%d", status);

  } else {

    LOG_ERROR("Unable to set power mode peer:%s status:%s",

              PRIVATE_ADDRESS(p_peer_dev->peer_bdaddr),

              btm_status_text(status).c_str());

    p_peer_dev->info &=

        ~(BTA_DM_DI_INT_SNIFF | BTA_DM_DI_ACP_SNIFF | BTA_DM_DI_SET_SNIFF);

  }
@@ -878,7 +895,7 @@ void bta_dm_pm_active(const RawAddress& peer_addr) { 
/** BTM power manager callback */

static void bta_dm_pm_btm_cback(const RawAddress& bd_addr,

                                tBTM_PM_STATUS status, uint16_t value,

                                uint8_t hci_status) {

                                tHCI_STATUS hci_status) {

  do_in_main_thread(FROM_HERE, base::Bind(bta_dm_pm_btm_status, bd_addr, status,

                                          value, hci_status));

}
@@ -927,13 +944,21 @@ static void bta_dm_pm_timer_cback(void* data) { 


/** Process pm status event from btm */

void bta_dm_pm_btm_status(const RawAddress& bd_addr, tBTM_PM_STATUS status,

                          uint16_t value, uint8_t hci_status) {

  APPL_TRACE_DEBUG("%s status: %d", __func__, status);

                          uint16_t interval, tHCI_STATUS hci_status) {

  LOG_DEBUG(

      "Power mode notification event status:%s peer:%s interval:%hu "

      "hci_status:%s",

      power_mode_status_text(status).c_str(), PRIVATE_ADDRESS(bd_addr),

      interval, hci_error_code_text(hci_status).c_str());



  tBTA_DM_PEER_DEVICE* p_dev = bta_dm_find_peer_device(bd_addr);

  if (NULL == p_dev) return;

  if (p_dev == nullptr) {

    LOG_INFO("Unable to process power event for peer:%s",

             PRIVATE_ADDRESS(bd_addr));

    return;

  }



  tBTA_DM_DEV_INFO info = p_dev->info;

  tBTA_DM_DEV_INFO info = p_dev->Info();

  /* check new mode */

  switch (status) {

    case BTM_PM_STS_ACTIVE:
@@ -972,10 +997,18 @@ void bta_dm_pm_btm_status(const RawAddress& bd_addr, tBTM_PM_STATUS status, 
      break;



    case BTM_PM_STS_SSR:

      if (value)

      if (hci_status != 0) {

        LOG_WARN("Received error when attempting to set sniff subrating mode");

      }

      if (interval) {

        p_dev->info |= BTA_DM_DI_USE_SSR;

      else

        LOG_DEBUG("Enabling sniff subrating mode for peer:%s",

                  PRIVATE_ADDRESS(bd_addr));

      } else {

        p_dev->info &= ~BTA_DM_DI_USE_SSR;

        LOG_DEBUG("Disabling sniff subrating mode for peer:%s",

                  PRIVATE_ADDRESS(bd_addr));

      }

      break;

    case BTM_PM_STS_SNIFF:

      if (hci_status == 0) {
@@ -1001,6 +1034,7 @@ void bta_dm_pm_btm_status(const RawAddress& bd_addr, tBTM_PM_STATUS status, 
      break;



    default:

      LOG_ERROR("Received unknown power mode status event:%hhu", status);

      break;

      }

}