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

Commit 3512c2c2 authored by Chris Manton's avatar Chris Manton
Browse files

Encapsulate bta/dm/bta_dm_int::tBTA_DM_DEV_INFO 

Towards readable code

Bug: 163134718
Tag: #refactor
Test: gd/cert/run --host

Change-Id: Ie829593e381619b7ee46e2fb73d9b5bb842b2d31
parent 7732014a

system/bta/dm/bta_dm_act.cc

+23 −12
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,8 +2413,8 @@ 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;

system/bta/dm/bta_dm_int.h

+19 −4
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,

                                   uint8_t 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 */

system/bta/dm/bta_dm_pm.cc

+10 −9
Original line number Diff line number Diff line
@@ -51,7 +51,7 @@ static void bta_dm_pm_btm_cback(const RawAddress& bd_addr, 
                                tBTM_PM_STATUS status, uint16_t value,

                                uint8_t 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) {
@@ -700,7 +700,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;
@@ -712,7 +712,7 @@ static void bta_dm_pm_sniff(tBTA_DM_PEER_DEVICE* p_peer_dev, uint8_t index) { 
  tBTM_PM_STATUS mode_status = static_cast<tBTM_PM_STATUS>(mode);

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

            power_mode_status_text(mode_status).c_str(), mode_status,

            p_peer_dev->info);

            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",
@@ -723,12 +723,13 @@ static void bta_dm_pm_sniff(tBTA_DM_PEER_DEVICE* p_peer_dev, uint8_t index) { 
  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)) {

    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__);

      return;

    }
@@ -736,7 +737,7 @@ static void bta_dm_pm_sniff(tBTA_DM_PEER_DEVICE* p_peer_dev, uint8_t index) { 
  /* 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) {

    pwr_md.mode |= BTM_PM_MD_FORCE;

  }

  status = BTM_SetPowerMode(bta_dm_cb.pm_id, p_peer_dev->peer_bdaddr, &pwr_md);
@@ -933,7 +934,7 @@ void bta_dm_pm_btm_status(const RawAddress& bd_addr, tBTM_PM_STATUS status, 
  tBTA_DM_PEER_DEVICE* p_dev = bta_dm_find_peer_device(bd_addr);

  if (NULL == p_dev) 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: