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

Commit f57dd95a authored by Henri Chataing's avatar Henri Chataing
Browse files

system/stack/gatt: Migrate to libbluetooth_log 

Test: m com.android.btservices
Bug: 305066880
Flag: EXEMPT, mechanical refactor
Change-Id: I6dd97f7a8b2671a6a5f117457b928fca060ba5e7
parent 382f5449

system/include/hardware/bt_common_types.h

+10 −0
Original line number Diff line number Diff line
@@ -128,4 +128,14 @@ struct MsftAdvMonitor { 
  std::vector<MsftAdvMonitorPattern> patterns;

};



#if __has_include(<bluetooth/log.h>)

#include <bluetooth/log.h>



namespace fmt {

template <>

struct formatter<bt_gatt_db_attribute_type_t>

    : enum_formatter<bt_gatt_db_attribute_type_t> {};

}  // namespace fmt

#endif  // __has_include(<bluetooth/log.h>)



#endif /* ANDROID_INCLUDE_BT_COMMON_TYPES_H */

system/stack/Android.bp

+4 −0
Original line number Diff line number Diff line
@@ -971,6 +971,7 @@ cc_test { 
        "libcutils",

    ],

    static_libs: [

        "libbase",

        "libbluetooth-types",

        "libbluetooth_gd",

        "libbluetooth_log",
@@ -1024,6 +1025,7 @@ cc_test { 
        "libcutils",

    ],

    static_libs: [

        "libbase",

        "libbluetooth-types",

        "libbluetooth_crypto_toolbox",

        "libbluetooth_gd",
@@ -1326,6 +1328,7 @@ cc_test { 
        "libcutils",

    ],

    static_libs: [

        "libbase",

        "libbluetooth-types",

        "libbluetooth_crypto_toolbox",

        "libbluetooth_gd",
@@ -1858,6 +1861,7 @@ cc_test { 
    ],

    static_libs: [

        "bluetooth_flags_c_lib",

        "libbase",

        "libbluetooth-types",

        "libbluetooth_crypto_toolbox",

        "libbluetooth_gd",

system/stack/gatt/att_protocol.cc

+41 −38
Original line number Diff line number Diff line
@@ -23,6 +23,7 @@ 
 ******************************************************************************/



#include <base/logging.h>

#include <bluetooth/log.h>



#include "gatt_int.h"

#include "internal_include/bt_target.h"
@@ -39,6 +40,8 @@ 


using base::StringPrintf;

using bluetooth::Uuid;

using namespace bluetooth;



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

 *   ATT protocl message building utility                              *

 **********************************************************************/
@@ -312,8 +315,7 @@ static BT_HDR* attp_build_value_cmd(uint16_t payload_size, uint8_t op_code, 
      /* update handle value pair length */

      if (op_code == GATT_RSP_READ_BY_TYPE) *p_pair_len = (len + 2);



      LOG(WARNING) << StringPrintf(

          "attribute value too long, to be truncated to %d", len);

      log::warn("attribute value too long, to be truncated to {}", len);

    }



    ARRAY_TO_STREAM(p, p_data, len);
@@ -335,18 +337,18 @@ tGATT_STATUS attp_send_msg_to_l2cap(tGATT_TCB& tcb, uint16_t lcid, 
  uint16_t l2cap_ret;



  if (lcid == L2CAP_ATT_CID) {

    LOG_DEBUG("Sending ATT message on att fixed channel");

    log::debug("Sending ATT message on att fixed channel");

    l2cap_ret = L2CA_SendFixedChnlData(lcid, tcb.peer_bda, p_toL2CAP);

  } else {

    LOG_DEBUG("Sending ATT message on lcid:%hu", lcid);

    log::debug("Sending ATT message on lcid:{}", lcid);

    l2cap_ret = (uint16_t)L2CA_DataWrite(lcid, p_toL2CAP);

  }



  if (l2cap_ret == L2CAP_DW_FAILED) {

    LOG(ERROR) << __func__ << ": failed to write data to L2CAP";

    log::error("failed to write data to L2CAP");

    return GATT_INTERNAL_ERROR;

  } else if (l2cap_ret == L2CAP_DW_CONGESTED) {

    VLOG(1) << StringPrintf("ATT congested, message accepted");

    log::verbose("ATT congested, message accepted");

    return GATT_CONGESTED;

  }

  return GATT_SUCCESS;
@@ -358,7 +360,8 @@ BT_HDR* attp_build_sr_msg(tGATT_TCB& tcb, uint8_t op_code, tGATT_SR_MSG* p_msg, 
  uint16_t offset = 0;



  if (payload_size == 0) {

    LOG_ERROR("Cannot send response (op: 0x%02x) due to payload size = 0, %s",

    log::error(

        "Cannot send response (op: 0x{:02x}) due to payload size = 0, {}",

        op_code, ADDRESS_TO_LOGGABLE_CSTR(tcb.peer_bda));

    return nullptr;

  }
@@ -366,8 +369,8 @@ BT_HDR* attp_build_sr_msg(tGATT_TCB& tcb, uint8_t op_code, tGATT_SR_MSG* p_msg, 
  switch (op_code) {

    case GATT_RSP_READ_BLOB:

    case GATT_RSP_PREPARE_WRITE:

      VLOG(1) << StringPrintf(

          "ATT_RSP_READ_BLOB/GATT_RSP_PREPARE_WRITE: len = %d offset = %d",

      log::verbose(

          "ATT_RSP_READ_BLOB/GATT_RSP_PREPARE_WRITE: len = {} offset = {}",

          p_msg->attr_value.len, p_msg->attr_value.offset);

      offset = p_msg->attr_value.offset;

      FALLTHROUGH_INTENDED; /* FALLTHROUGH */
@@ -393,7 +396,7 @@ BT_HDR* attp_build_sr_msg(tGATT_TCB& tcb, uint8_t op_code, tGATT_SR_MSG* p_msg, 
      return attp_build_mtu_cmd(op_code, p_msg->mtu);



    default:

      LOG(FATAL) << "attp_build_sr_msg: unknown op code = " << +op_code;

      log::fatal("attp_build_sr_msg: unknown op code = {}", +op_code);

      return nullptr;

  }

}
@@ -414,11 +417,11 @@ BT_HDR* attp_build_sr_msg(tGATT_TCB& tcb, uint8_t op_code, tGATT_SR_MSG* p_msg, 
 ******************************************************************************/

tGATT_STATUS attp_send_sr_msg(tGATT_TCB& tcb, uint16_t cid, BT_HDR* p_msg) {

  if (p_msg == NULL) {

    LOG_WARN("Unable to send empty message");

    log::warn("Unable to send empty message");

    return GATT_NO_RESOURCES;

  }



  LOG_DEBUG("Sending server response or indication message to client");

  log::debug("Sending server response or indication message to client");

  p_msg->offset = L2CAP_MIN_OFFSET;

  return attp_send_msg_to_l2cap(tcb, cid, p_msg);

}
@@ -442,24 +445,24 @@ static tGATT_STATUS attp_cl_send_cmd(tGATT_TCB& tcb, tGATT_CLCB* p_clcb, 
  if (gatt_tcb_is_cid_busy(tcb, p_clcb->cid) &&

      cmd_code != GATT_HANDLE_VALUE_CONF) {

    if (gatt_cmd_enq(tcb, p_clcb, true, cmd_code, p_cmd)) {

      LOG_DEBUG("Enqueued ATT command %p conn_id=0x%04x, cid=%d", p_clcb,

                p_clcb->conn_id, p_clcb->cid);

      log::debug("Enqueued ATT command {} conn_id=0x{:04x}, cid={}",

                 fmt::ptr(p_clcb), p_clcb->conn_id, p_clcb->cid);

      return GATT_CMD_STARTED;

    }



    LOG_ERROR("%s, cid 0x%02x already disconnected",

    log::error("{}, cid 0x{:02x} already disconnected",

               ADDRESS_TO_LOGGABLE_CSTR(tcb.peer_bda), p_clcb->cid);

    return GATT_INTERNAL_ERROR;

  }



  LOG_DEBUG(

      "Sending ATT command to l2cap cid:0x%04x eatt_channels:%u transport:%s",

      p_clcb->cid, tcb.eatt, bt_transport_text(tcb.transport).c_str());

  log::debug(

      "Sending ATT command to l2cap cid:0x{:04x} eatt_channels:{} transport:{}",

      p_clcb->cid, tcb.eatt, bt_transport_text(tcb.transport));

  tGATT_STATUS att_ret = attp_send_msg_to_l2cap(tcb, p_clcb->cid, p_cmd);

  if (att_ret != GATT_CONGESTED && att_ret != GATT_SUCCESS) {

    LOG_WARN(

        "Unable to send ATT command to l2cap layer %p conn_id=0x%04x, cid=%d",

        p_clcb, p_clcb->conn_id, p_clcb->cid);

    log::warn(

        "Unable to send ATT command to l2cap layer {} conn_id=0x{:04x}, cid={}",

        fmt::ptr(p_clcb), p_clcb->conn_id, p_clcb->cid);

    return GATT_INTERNAL_ERROR;

  }
@@ -467,11 +470,12 @@ static tGATT_STATUS attp_cl_send_cmd(tGATT_TCB& tcb, tGATT_CLCB* p_clcb, 
    return att_ret;

  }



  LOG_DEBUG("Starting ATT response timer %p conn_id=0x%04x, cid=%d", p_clcb,

            p_clcb->conn_id, p_clcb->cid);

  log::debug("Starting ATT response timer {} conn_id=0x{:04x}, cid={}",

             fmt::ptr(p_clcb), p_clcb->conn_id, p_clcb->cid);

  gatt_start_rsp_timer(p_clcb);

  if (!gatt_cmd_enq(tcb, p_clcb, false, cmd_code, NULL)) {

    LOG_ERROR("Could not queue sent request. %s, cid 0x%02x already disconnected",

    log::error(

        "Could not queue sent request. {}, cid 0x{:02x} already disconnected",

        ADDRESS_TO_LOGGABLE_CSTR(tcb.peer_bda), p_clcb->cid);

    return GATT_INTERNAL_ERROR;

  }
@@ -530,13 +534,13 @@ tGATT_STATUS attp_send_cl_msg(tGATT_TCB& tcb, tGATT_CLCB* p_clcb, 
  uint16_t offset = 0, handle;



  if (!p_clcb) {

    LOG_ERROR("Missing p_clcb");

    log::error("Missing p_clcb");

    return GATT_ILLEGAL_PARAMETER;

  }



  uint16_t payload_size = gatt_tcb_get_payload_size(tcb, p_clcb->cid);

  if (payload_size == 0) {

    LOG_ERROR("Cannot send request (op: 0x%02x) due to payload size = 0, %s",

    log::error("Cannot send request (op: 0x{:02x}) due to payload size = 0, {}",

               op_code, ADDRESS_TO_LOGGABLE_CSTR(tcb.peer_bda));

    return GATT_NO_RESOURCES;

  }
@@ -544,8 +548,8 @@ tGATT_STATUS attp_send_cl_msg(tGATT_TCB& tcb, tGATT_CLCB* p_clcb, 
  switch (op_code) {

    case GATT_REQ_MTU:

      if (p_msg->mtu > GATT_MAX_MTU_SIZE) {

        LOG_WARN(

            "GATT message MTU is larger than max GATT MTU size op_code:%hhu",

        log::warn(

            "GATT message MTU is larger than max GATT MTU size op_code:{}",

            op_code);

        return GATT_ILLEGAL_PARAMETER;

      }
@@ -558,7 +562,7 @@ tGATT_STATUS attp_send_cl_msg(tGATT_TCB& tcb, tGATT_CLCB* p_clcb, 
      if (!GATT_HANDLE_IS_VALID(p_msg->browse.s_handle) ||

          !GATT_HANDLE_IS_VALID(p_msg->browse.e_handle) ||

          p_msg->browse.s_handle > p_msg->browse.e_handle) {

        LOG_WARN("GATT message has invalid handle op_code:%hhu", op_code);

        log::warn("GATT message has invalid handle op_code:{}", op_code);

        return GATT_ILLEGAL_PARAMETER;

      }
@@ -574,7 +578,7 @@ tGATT_STATUS attp_send_cl_msg(tGATT_TCB& tcb, tGATT_CLCB* p_clcb, 
          (op_code == GATT_REQ_READ) ? p_msg->handle : p_msg->read_blob.handle;

      /*  handle checking */

      if (!GATT_HANDLE_IS_VALID(handle)) {

        LOG_WARN("GATT message has invalid handle op_code:%hhu", op_code);

        log::warn("GATT message has invalid handle op_code:{}", op_code);

        return GATT_ILLEGAL_PARAMETER;

      }
@@ -588,7 +592,7 @@ tGATT_STATUS attp_send_cl_msg(tGATT_TCB& tcb, tGATT_CLCB* p_clcb, 
    case GATT_CMD_WRITE:

    case GATT_SIGN_CMD_WRITE:

      if (!GATT_HANDLE_IS_VALID(p_msg->attr_value.handle)) {

        LOG_WARN("GATT message has invalid handle op_code:%hhu", op_code);

        log::warn("GATT message has invalid handle op_code:{}", op_code);

        return GATT_ILLEGAL_PARAMETER;

      }
@@ -618,9 +622,8 @@ tGATT_STATUS attp_send_cl_msg(tGATT_TCB& tcb, tGATT_CLCB* p_clcb, 
  }



  if (p_cmd == NULL) {

    LOG_WARN(

        "Unable to build proper GATT message to send to peer device "

        "op_code:%hhu",

    log::warn(

        "Unable to build proper GATT message to send to peer device op_code:{}",

        op_code);

    return GATT_NO_RESOURCES;

  }

system/stack/gatt/connection_manager.cc

+67 −63
Original line number Diff line number Diff line
@@ -22,6 +22,7 @@ 
#include <base/functional/callback.h>

#include <base/location.h>

#include <base/logging.h>

#include <bluetooth/log.h>



#include <map>

#include <memory>
@@ -41,6 +42,8 @@ 


#define DIRECT_CONNECT_TIMEOUT (30 * 1000) /* 30 seconds */



using namespace bluetooth;



constexpr char kBtmLogTag[] = "TA";



struct closure_data {
@@ -50,7 +53,7 @@ struct closure_data { 


static void alarm_closure_cb(void* p) {

  closure_data* data = (closure_data*)p;

  VLOG(1) << "executing timer scheduled at %s" << data->posted_from.ToString();

  log::verbose("executing timer scheduled at {}", data->posted_from.ToString());

  std::move(data->user_task).Run();

  delete data;

}
@@ -61,7 +64,7 @@ void alarm_set_closure(const base::Location& posted_from, alarm_t* alarm, 
  closure_data* data = new closure_data;

  data->posted_from = posted_from;

  data->user_task = std::move(user_task);

  VLOG(1) << "scheduling timer %s" << data->posted_from.ToString();

  log::verbose("scheduling timer {}", data->posted_from.ToString());

  alarm_set_on_mloop(alarm, interval_ms, alarm_closure_cb, data);

}
@@ -112,7 +115,7 @@ bool is_anyone_connecting( 
/** background connection device from the list. Returns pointer to the device

 * record, or nullptr if not found */

std::set<tAPP_ID> get_apps_connecting_to(const RawAddress& address) {

  LOG_DEBUG("address=%s", ADDRESS_TO_LOGGABLE_CSTR(address));

  log::debug("address={}", ADDRESS_TO_LOGGABLE_CSTR(address));

  auto it = bgconn_dev.find(address);

  return (it != bgconn_dev.end()) ? it->second.doing_bg_conn

                                  : std::set<tAPP_ID>();
@@ -135,14 +138,14 @@ bool IsTargetedAnnouncement(const uint8_t* p_eir, uint16_t eir_len) { 
    }



    STREAM_TO_UINT16(uuid, p_tmp);

    LOG_DEBUG("Found UUID 0x%04x", uuid);

    log::debug("Found UUID 0x{:04x}", uuid);



    if (uuid != 0x184E && uuid != 0x1853) {

      continue;

    }



    STREAM_TO_UINT8(announcement_type, p_tmp);

    LOG_DEBUG("Found announcement_type 0x%02x", announcement_type);

    log::debug("Found announcement_type 0x{:02x}", announcement_type);

    if (announcement_type == 0x01) {

      return true;

    }
@@ -164,21 +167,22 @@ static void target_announcement_observe_results_cb(tBTM_INQ_RESULTS* p_inq, 
  }



  if (!IsTargetedAnnouncement(p_eir, eir_len)) {

    LOG_DEBUG("Not a targeted announcement for device %s",

    log::debug("Not a targeted announcement for device {}",

               ADDRESS_TO_LOGGABLE_CSTR(addr));

    return;

  }



  LOG_INFO("Found targeted announcement for device %s",

  log::info("Found targeted announcement for device {}",

            ADDRESS_TO_LOGGABLE_CSTR(addr));



  if (it->second.is_in_accept_list) {

    LOG_INFO("Device %s is already connecting", ADDRESS_TO_LOGGABLE_CSTR(addr));

    log::info("Device {} is already connecting",

              ADDRESS_TO_LOGGABLE_CSTR(addr));

    return;

  }



  if (BTM_GetHCIConnHandle(addr, BT_TRANSPORT_LE) != 0xFFFF) {

    LOG_DEBUG("Device %s already connected", ADDRESS_TO_LOGGABLE_CSTR(addr));

    log::debug("Device {} already connected", ADDRESS_TO_LOGGABLE_CSTR(addr));

    return;

  }
@@ -193,7 +197,7 @@ static void target_announcement_observe_results_cb(tBTM_INQ_RESULTS* p_inq, 
}



void target_announcements_filtering_set(bool enable) {

  LOG_DEBUG("enable %d", enable);

  log::debug("enable {}", enable);

  BTM_LogHistory(kBtmLogTag, RawAddress::kEmpty,

                 (enable ? "Start filtering" : "Stop filtering"));
@@ -211,7 +215,7 @@ void target_announcements_filtering_set(bool enable) { 
 */

bool background_connect_targeted_announcement_add(tAPP_ID app_id,

                                                  const RawAddress& address) {

  LOG_INFO("app_id=%d, address=%s", static_cast<int>(app_id),

  log::info("app_id={}, address={}", static_cast<int>(app_id),

            ADDRESS_TO_LOGGABLE_CSTR(address));



  bool disable_accept_list = false;
@@ -220,9 +224,9 @@ bool background_connect_targeted_announcement_add(tAPP_ID app_id, 
  if (it != bgconn_dev.end()) {

    // check if filtering already enabled

    if (it->second.doing_targeted_announcements_conn.count(app_id)) {

      LOG_INFO(

          "app_id=%d, already doing targeted announcement filtering to "

          "address=%s",

      log::info(

          "app_id={}, already doing targeted announcement filtering to "

          "address={}",

          static_cast<int>(app_id), ADDRESS_TO_LOGGABLE_CSTR(address));

      return true;

    }
@@ -232,14 +236,14 @@ bool background_connect_targeted_announcement_add(tAPP_ID app_id, 


    // Check if connecting

    if (!it->second.doing_direct_conn.empty()) {

      LOG_INFO("app_id=%d, address=%s, already in direct connection",

      log::info("app_id={}, address={}, already in direct connection",

                static_cast<int>(app_id), ADDRESS_TO_LOGGABLE_CSTR(address));



    } else if (!targeted_filtering_enabled &&

               !it->second.doing_bg_conn.empty()) {

      // device is already in the acceptlist so we would have to remove it

      LOG_INFO(

          "already doing background connection to address=%s. Need to disable "

      log::info(

          "already doing background connection to address={}. Need to disable "

          "it.",

          ADDRESS_TO_LOGGABLE_CSTR(address));

      disable_accept_list = true;
@@ -266,7 +270,7 @@ bool background_connect_targeted_announcement_add(tAPP_ID app_id, 
/** Add a device from the background connection list.  Returns true if device

 * added to the list, or already in list, false otherwise */

bool background_connect_add(uint8_t app_id, const RawAddress& address) {

  LOG_DEBUG("app_id=%d, address=%s", static_cast<int>(app_id),

  log::debug("app_id={}, address={}", static_cast<int>(app_id),

             ADDRESS_TO_LOGGABLE_CSTR(address));

  auto it = bgconn_dev.find(address);

  bool in_acceptlist = false;
@@ -274,14 +278,14 @@ bool background_connect_add(uint8_t app_id, const RawAddress& address) { 
  if (it != bgconn_dev.end()) {

    // device already in the acceptlist, just add interested app to the list

    if (it->second.doing_bg_conn.count(app_id)) {

      LOG_DEBUG("app_id=%d, already doing background connection to address=%s",

      log::debug("app_id={}, already doing background connection to address={}",

                 static_cast<int>(app_id), ADDRESS_TO_LOGGABLE_CSTR(address));

      return true;

    }



    // Already in acceptlist ?

    if (it->second.is_in_accept_list) {

      LOG_DEBUG("app_id=%d, address=%s, already in accept list",

      log::debug("app_id={}, address={}, already in accept list",

                 static_cast<int>(app_id), ADDRESS_TO_LOGGABLE_CSTR(address));

      in_acceptlist = true;

    } else {
@@ -293,10 +297,10 @@ bool background_connect_add(uint8_t app_id, const RawAddress& address) { 
  if (!in_acceptlist) {

    // the device is not in the acceptlist

    if (is_targeted_announcement_enabled) {

      LOG_DEBUG("Targeted announcement enabled, do not add to AcceptList");

      log::debug("Targeted announcement enabled, do not add to AcceptList");

    } else {

      if (!BTM_AcceptlistAdd(address)) {

        LOG_WARN("Failed to add device %s to accept list for app %d",

        log::warn("Failed to add device {} to accept list for app {}",

                  ADDRESS_TO_LOGGABLE_CSTR(address), static_cast<int>(app_id));

        return false;

      }
@@ -313,10 +317,10 @@ bool background_connect_add(uint8_t app_id, const RawAddress& address) { 
/** Removes all registrations for connection for given device.

 * Returns true if anything was removed, false otherwise */

bool remove_unconditional(const RawAddress& address) {

  LOG_DEBUG("address=%s", ADDRESS_TO_LOGGABLE_CSTR(address));

  log::debug("address={}", ADDRESS_TO_LOGGABLE_CSTR(address));

  auto it = bgconn_dev.find(address);

  if (it == bgconn_dev.end()) {

    LOG_WARN("address %s is not found", ADDRESS_TO_LOGGABLE_CSTR(address));

    log::warn("address {} is not found", ADDRESS_TO_LOGGABLE_CSTR(address));

    return false;

  }
@@ -329,11 +333,11 @@ bool remove_unconditional(const RawAddress& address) { 
 * advertising list.  Returns true if device was on the list and was

 * successfully removed */

bool background_connect_remove(uint8_t app_id, const RawAddress& address) {

  LOG_DEBUG("app_id=%d, address=%s", static_cast<int>(app_id),

  log::debug("app_id={}, address={}", static_cast<int>(app_id),

             ADDRESS_TO_LOGGABLE_CSTR(address));

  auto it = bgconn_dev.find(address);

  if (it == bgconn_dev.end()) {

    LOG_WARN("address %s is not found", ADDRESS_TO_LOGGABLE_CSTR(address));

    log::warn("address {} is not found", ADDRESS_TO_LOGGABLE_CSTR(address));

    return false;

  }
@@ -345,7 +349,7 @@ bool background_connect_remove(uint8_t app_id, const RawAddress& address) { 
  bool removed_from_ta =

      (it->second.doing_targeted_announcements_conn.erase(app_id) > 0);

  if (!removed_from_bg_conn && !removed_from_ta) {

    LOG_WARN("Failed to remove background connection app %d for address %s",

    log::warn("Failed to remove background connection app {} for address {}",

              static_cast<int>(app_id), ADDRESS_TO_LOGGABLE_CSTR(address));

    return false;

  }
@@ -356,17 +360,17 @@ bool background_connect_remove(uint8_t app_id, const RawAddress& address) { 
  }



  if (is_anyone_connecting(it)) {

    LOG_DEBUG("some device is still connecting, app_id=%d, address=%s",

    log::debug("some device is still connecting, app_id={}, address={}",

               static_cast<int>(app_id), ADDRESS_TO_LOGGABLE_CSTR(address));

    /* Check which method should be used now.*/

    if (!accept_list_enabled) {

      /* Accept list was not used */

      if (!it->second.doing_targeted_announcements_conn.empty()) {

        /* Keep using filtering */

        LOG_DEBUG(" Keep using target announcement filtering");

        log::debug("Keep using target announcement filtering");

      } else if (!it->second.doing_bg_conn.empty()) {

        if (!BTM_AcceptlistAdd(address)) {

          LOG_WARN("Could not re add device to accept list");

          log::warn("Could not re add device to accept list");

        } else {

          bgconn_dev[address].is_in_accept_list = true;

        }
@@ -397,7 +401,7 @@ bool is_background_connection(const RawAddress& address) { 


/** deregister all related background connetion device. */

void on_app_deregistered(uint8_t app_id) {

  LOG_DEBUG("app_id=%d", static_cast<int>(app_id));

  log::debug("app_id={}", static_cast<int>(app_id));

  auto it = bgconn_dev.begin();

  auto end = bgconn_dev.end();

  /* update the BG conn device list */
@@ -418,7 +422,7 @@ void on_app_deregistered(uint8_t app_id) { 


static void remove_all_clients_with_pending_connections(

    const RawAddress& address) {

  LOG_DEBUG("address=%s", ADDRESS_TO_LOGGABLE_CSTR(address));

  log::debug("address={}", ADDRESS_TO_LOGGABLE_CSTR(address));

  auto it = bgconn_dev.find(address);

  while (it != bgconn_dev.end() && !it->second.doing_direct_conn.empty()) {

    uint8_t app_id = it->second.doing_direct_conn.begin()->first;
@@ -428,14 +432,14 @@ static void remove_all_clients_with_pending_connections( 
}



void on_connection_complete(const RawAddress& address) {

  LOG_INFO("Le connection completed to device:%s",

  log::info("Le connection completed to device:{}",

            ADDRESS_TO_LOGGABLE_CSTR(address));



  remove_all_clients_with_pending_connections(address);

}



void on_connection_timed_out_from_shim(const RawAddress& address) {

  LOG_INFO("Connection failed %s", ADDRESS_TO_LOGGABLE_CSTR(address));

  log::info("Connection failed {}", ADDRESS_TO_LOGGABLE_CSTR(address));

  on_connection_timed_out(0x00, address);

}
@@ -450,7 +454,7 @@ void reset(bool after_reset) { 
}



void wl_direct_connect_timeout_cb(uint8_t app_id, const RawAddress& address) {

  LOG_DEBUG("app_id=%d, address=%s", static_cast<int>(app_id),

  log::debug("app_id={}, address={}", static_cast<int>(app_id),

             ADDRESS_TO_LOGGABLE_CSTR(address));

  on_connection_timed_out(app_id, address);
@@ -462,21 +466,21 @@ void wl_direct_connect_timeout_cb(uint8_t app_id, const RawAddress& address) { 
/** Add a device to the direct connection list. Returns true if device

 * added to the list, false otherwise */

bool direct_connect_add(uint8_t app_id, const RawAddress& address) {

  LOG_DEBUG("app_id=%d, address=%s", static_cast<int>(app_id),

  log::debug("app_id={}, address={}", static_cast<int>(app_id),

             ADDRESS_TO_LOGGABLE_CSTR(address));

  bool in_acceptlist = false;

  auto it = bgconn_dev.find(address);

  if (it != bgconn_dev.end()) {

    // app already trying to connect to this particular device

    if (it->second.doing_direct_conn.count(app_id)) {

      LOG(INFO) << "direct connect attempt from app_id=" << loghex(app_id)

                << " already in progress";

      log::info("direct connect attempt from app_id={} already in progress",

                loghex(app_id));

      return false;

    }



    // are we already in the acceptlist ?

    if (it->second.is_in_accept_list) {

      LOG_WARN("Background connection attempt already in progress app_id=%x",

      log::warn("Background connection attempt already in progress app_id={:x}",

                app_id);

      in_acceptlist = true;

    }
@@ -485,7 +489,7 @@ bool direct_connect_add(uint8_t app_id, const RawAddress& address) { 
  if (!in_acceptlist) {

    if (!BTM_AcceptlistAdd(address, true)) {

      // if we can't add to acceptlist, turn parameters back to slow.

      LOG_WARN("Unable to add le device to acceptlist");

      log::warn("Unable to add le device to acceptlist");

      return false;

    }

    bgconn_dev[address].is_in_accept_list = true;
@@ -510,18 +514,18 @@ static void schedule_direct_connect_add(uint8_t app_id, 


bool direct_connect_remove(uint8_t app_id, const RawAddress& address,

                           bool connection_timeout) {

  LOG_DEBUG("app_id=%d, address=%s", static_cast<int>(app_id),

  log::debug("app_id={}, address={}", static_cast<int>(app_id),

             ADDRESS_TO_LOGGABLE_CSTR(address));

  auto it = bgconn_dev.find(address);

  if (it == bgconn_dev.end()) {

    LOG_WARN("Unable to find background connection to remove peer:%s",

    log::warn("Unable to find background connection to remove peer:{}",

              ADDRESS_TO_LOGGABLE_CSTR(address));

    return false;

  }



  auto app_it = it->second.doing_direct_conn.find(app_id);

  if (app_it == it->second.doing_direct_conn.end()) {

    LOG_WARN("Unable to find direct connection to remove peer:%s",

    log::warn("Unable to find direct connection to remove peer:{}",

              ADDRESS_TO_LOGGABLE_CSTR(address));

    return false;

  }
@@ -540,8 +544,8 @@ bool direct_connect_remove(uint8_t app_id, const RawAddress& address, 
       * the allow list.

       */

      if (!BTM_AcceptlistAdd(address)) {

        LOG_WARN(

            "Failed to re-add device %s to accept list after connection "

        log::warn(

            "Failed to re-add device {} to accept list after connection "

            "timeout",

            ADDRESS_TO_LOGGABLE_CSTR(address));

      }

system/stack/gatt/gatt_api.cc

+144 −155

File changed.

Preview size limit exceeded, changes collapsed.