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

Commit fc57e5f8 authored by Jakub Pawlowski's avatar Jakub Pawlowski Committed by Jakub Pawłowski
Browse files

Separate service and device discovery state machines 

Bug: 330675788
Bug: 335732980
Flag: com.android.bluetooth.flags.separate_service_and_device_discovery
Test: mma -j32
Change-Id: I7188a498f0b258e21f0270b825da4bc95fe9d6a5
parent 65413be0

system/bta/dm/bta_dm_disc.cc

+128 −122
Original line number Diff line number Diff line
@@ -75,12 +75,24 @@ constexpr char kBtmLogTag[] = "SDP"; 
tBTA_DM_SEARCH_CB bta_dm_search_cb;

}  // namespace



static void bta_dm_search_sm_execute(tBTA_DM_EVT event,

static void bta_dm_search_sm_execute(tBTA_DM_DEV_SEARCH_EVT event,

                                     std::unique_ptr<tBTA_DM_MSG> msg);

static void post_disc_evt(tBTA_DM_EVT event, std::unique_ptr<tBTA_DM_MSG> msg) {

static void post_search_evt(tBTA_DM_DEV_SEARCH_EVT event,

                            std::unique_ptr<tBTA_DM_MSG> msg) {

  if (do_in_main_thread(FROM_HERE, base::BindOnce(&bta_dm_search_sm_execute,

                                                  event, std::move(msg))) !=

      BT_STATUS_SUCCESS) {

    log::error("post_search_evt failed");

  }

}



static void bta_dm_disc_sm_execute(tBTA_DM_DISC_EVT event,

                                   std::unique_ptr<tBTA_DM_MSG> msg);

static void post_disc_evt(tBTA_DM_DISC_EVT event,

                          std::unique_ptr<tBTA_DM_MSG> msg) {

  if (do_in_main_thread(FROM_HERE, base::BindOnce(&bta_dm_disc_sm_execute,

                                                  event, std::move(msg))) !=

      BT_STATUS_SUCCESS) {

    log::error("post_disc_evt failed");

  }

}
@@ -223,7 +235,7 @@ void bta_dm_disc_remove_device(const RawAddress& bd_addr) { 
    bta_dm_disc_legacy::bta_dm_disc_remove_device(bd_addr);

    return;

  }

  if (bta_dm_search_cb.state == BTA_DM_DISCOVER_ACTIVE &&

  if (bta_dm_search_cb.service_discovery_state == BTA_DM_DISCOVER_ACTIVE &&

      bta_dm_search_cb.peer_bdaddr == bd_addr) {

    log::info(

        "Device removed while service discovery was pending, conclude the "
@@ -289,13 +301,18 @@ const uint16_t bta_service_id_to_uuid_lkup_tbl[BTA_MAX_SERVICE_ID] = { 
#define MAX_DISC_RAW_DATA_BUF (4096)

static uint8_t g_disc_raw_data_buf[MAX_DISC_RAW_DATA_BUF];



static void bta_dm_search_set_state(tBTA_DM_STATE state) {

  bta_dm_search_cb.state = state;

static void bta_dm_search_set_state(tBTA_DM_DEVICE_SEARCH_STATE state) {

  bta_dm_search_cb.search_state = state;

}

static tBTA_DM_STATE bta_dm_search_get_state() {

  return bta_dm_search_cb.state;

static tBTA_DM_DEVICE_SEARCH_STATE bta_dm_search_get_state() {

  return bta_dm_search_cb.search_state;

}

static void bta_dm_discovery_set_state(tBTA_DM_SERVICE_DISCOVERY_STATE state) {

  bta_dm_search_cb.service_discovery_state = state;

}

static tBTA_DM_SERVICE_DISCOVERY_STATE bta_dm_discovery_get_state() {

  return bta_dm_search_cb.service_discovery_state;

}



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

 *

 * Function         bta_dm_search_start
@@ -329,6 +346,9 @@ static void bta_dm_search_start(tBTA_DM_API_SEARCH& search) { 
  }

}



// TODO. Currently we did nothing

static void bta_dm_discovery_cancel() {}



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

 *

 * Function         bta_dm_search_cancel
@@ -402,12 +422,24 @@ static void bta_dm_discover(tBTA_DM_API_DISCOVER& discover) { 
 *

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

static void bta_dm_disable_search_and_disc(void) {

  switch (bta_dm_discovery_get_state()) {

    case BTA_DM_DISCOVER_IDLE:

      break;

    case BTA_DM_DISCOVER_ACTIVE:

    default:

      log::debug(

          "Discovery state machine is not idle so issuing discovery cancel "

          "current "

          "state:{}",

          bta_dm_state_text(bta_dm_discovery_get_state()));

      bta_dm_discovery_cancel();

  }



  switch (bta_dm_search_get_state()) {

    case BTA_DM_SEARCH_IDLE:

      break;

    case BTA_DM_SEARCH_ACTIVE:

    case BTA_DM_SEARCH_CANCELLING:

    case BTA_DM_DISCOVER_ACTIVE:

    default:

      log::debug(

          "Search state machine is not idle so issuing search cancel current "
@@ -538,11 +570,6 @@ static void bta_dm_remote_name_cmpl( 
    case BTA_DM_SEARCH_ACTIVE:

      bta_dm_discover_name(bta_dm_search_cb.peer_bdaddr);

      break;

    case BTA_DM_DISCOVER_ACTIVE:

      /* TODO: Get rid of this case when Name and Service discovery state

       * machines are separated */

      bta_dm_discover_name(remote_name_msg.bd_addr);

      break;

    case BTA_DM_SEARCH_IDLE:

    case BTA_DM_SEARCH_CANCELLING:

      log::warn("Received remote name request in state:{}",
@@ -798,7 +825,7 @@ static void bta_dm_sdp_result(tBTA_DM_SDP_RESULT& sdp_event) { 
      }

      disc_result.bd_addr = bta_dm_search_cb.peer_bdaddr;



      bta_dm_search_sm_execute(BTA_DM_DISCOVERY_RESULT_EVT, std::move(msg));

      bta_dm_disc_sm_execute(BTA_DM_DISCOVERY_RESULT_EVT, std::move(msg));

    }

  } else {

    BTM_LogHistory(
@@ -822,7 +849,7 @@ static void bta_dm_sdp_result(tBTA_DM_SDP_RESULT& sdp_event) { 
    disc_result.services = bta_dm_search_cb.services_found;

    disc_result.bd_addr = bta_dm_search_cb.peer_bdaddr;



    bta_dm_search_sm_execute(BTA_DM_DISCOVERY_RESULT_EVT, std::move(msg));

    bta_dm_disc_sm_execute(BTA_DM_DISCOVERY_RESULT_EVT, std::move(msg));

  }

}
@@ -843,10 +870,7 @@ static void bta_dm_read_dis_cmpl(const RawAddress& addr, 
#endif



static void bta_dm_service_discovery_cmpl() {

  // TODO: we shouldn't change search state, just service discovery state, but

  // both state machines are now joined. This bug will be fixed in upcoming

  // patches.

  bta_dm_search_set_state(BTA_DM_SEARCH_IDLE);

  bta_dm_discovery_set_state(BTA_DM_DISCOVER_IDLE);



  uint16_t conn_id = bta_dm_search_cb.conn_id;
@@ -1027,7 +1051,7 @@ static void bta_dm_execute_queued_request() { 
        std::make_unique<tBTA_DM_MSG>(tBTA_DM_API_DISCOVER{pending_discovery}));

  } else if (bta_dm_search_cb.p_pending_search) {

    log::info("Start pending search");

    post_disc_evt(BTA_DM_API_SEARCH_EVT,

    post_search_evt(BTA_DM_API_SEARCH_EVT,

                    std::move(bta_dm_search_cb.p_pending_search));

    bta_dm_search_cb.p_pending_search.reset();

  }
@@ -1087,7 +1111,6 @@ static void bta_dm_search_cancel_notify() { 
      }

      break;

    case BTA_DM_SEARCH_IDLE:

    case BTA_DM_DISCOVER_ACTIVE:

      // Nothing to do

      break;

  }
@@ -1188,7 +1211,7 @@ static void bta_dm_discover_next_device(void) { 
    bta_dm_discover_name(

        bta_dm_search_cb.p_btm_inq_info->results.remote_bd_addr);

  } else {

    post_disc_evt(BTA_DM_SEARCH_CMPL_EVT, nullptr);

    post_search_evt(BTA_DM_SEARCH_CMPL_EVT, nullptr);

  }

}
@@ -1271,10 +1294,6 @@ static void bta_dm_discover_name(const RawAddress& remote_bd_addr) { 
        (!bta_dm_search_cb.p_btm_inq_info->appl_knows_rem_name)))) {

    if (bta_dm_read_remote_device_name(bta_dm_search_cb.peer_bdaddr,

                                       transport)) {

      if (bta_dm_search_get_state() != BTA_DM_DISCOVER_ACTIVE) {

        log::debug("Reset transport state for next discovery");

        bta_dm_search_cb.transport = BT_TRANSPORT_AUTO;

      }

      BTM_LogHistory(kBtmLogTag, bta_dm_search_cb.peer_bdaddr,

                     "Read remote name",

                     base::StringPrintf("Transport:%s",
@@ -1380,7 +1399,7 @@ static void bta_dm_discover_services(const RawAddress& remote_bd_addr) { 
  svc_result.services = bta_dm_search_cb.services_found;

  svc_result.bd_addr = bta_dm_search_cb.peer_bdaddr;



  bta_dm_search_sm_execute(BTA_DM_DISCOVERY_RESULT_EVT, std::move(msg));

  bta_dm_disc_sm_execute(BTA_DM_DISCOVERY_RESULT_EVT, std::move(msg));

}



/*******************************************************************************
@@ -1576,7 +1595,7 @@ static void bta_dm_remname_cback(const tBTM_REMOTE_DEV_NAME* p_remote_name) { 
  rmt_name_msg.hci_status = p_remote_name->hci_status;

  bd_name_copy(rmt_name_msg.bd_name, p_remote_name->remote_bd_name);



  post_disc_evt(BTA_DM_REMT_NAME_EVT, std::move(msg));

  post_search_evt(BTA_DM_REMT_NAME_EVT, std::move(msg));

}



/*******************************************************************************
@@ -1813,7 +1832,7 @@ static void bta_dm_gattc_register(void) { 
}



static void gatt_close_timer_cb(void*) {

  bta_dm_search_sm_execute(BTA_DM_DISC_CLOSE_TOUT_EVT, nullptr);

  bta_dm_disc_sm_execute(BTA_DM_DISC_CLOSE_TOUT_EVT, nullptr);

}



/*******************************************************************************
@@ -1838,7 +1857,7 @@ static void bta_dm_gatt_disc_complete(uint16_t conn_id, tGATT_STATUS status) { 
  svc_result.bd_addr = bta_dm_search_cb.peer_bdaddr;

  svc_result.device_type |= BT_DEVICE_TYPE_BLE;



  bta_dm_search_sm_execute(BTA_DM_DISCOVERY_RESULT_EVT, std::move(msg));

  bta_dm_disc_sm_execute(BTA_DM_DISCOVERY_RESULT_EVT, std::move(msg));



  if (conn_id != GATT_INVALID_CONN_ID) {

    bta_dm_search_cb.pending_close_bda = bta_dm_search_cb.peer_bdaddr;
@@ -1849,7 +1868,7 @@ static void bta_dm_gatt_disc_complete(uint16_t conn_id, tGATT_STATUS status) { 
      alarm_set_on_mloop(bta_dm_search_cb.gatt_close_timer,

                         BTA_DM_GATT_CLOSE_DELAY_TOUT, gatt_close_timer_cb, 0);

    } else {

      bta_dm_search_sm_execute(BTA_DM_DISC_CLOSE_TOUT_EVT, nullptr);

      bta_dm_disc_sm_execute(BTA_DM_DISC_CLOSE_TOUT_EVT, nullptr);

    }

  } else {

    bta_dm_search_cb.conn_id = GATT_INVALID_CONN_ID;
@@ -1857,7 +1876,7 @@ static void bta_dm_gatt_disc_complete(uint16_t conn_id, tGATT_STATUS status) { 
    if (IS_FLAG_ENABLED(bta_dm_disc_stuck_in_cancelling_fix)) {

      log::info(

          "Discovery complete for invalid conn ID. Will pick up next job");

      bta_dm_search_set_state(BTA_DM_SEARCH_IDLE);

      bta_dm_discovery_set_state(BTA_DM_DISCOVER_IDLE);

      bta_dm_free_sdp_db();

      bta_dm_execute_queued_request();

    }
@@ -1938,7 +1957,7 @@ static void btm_dm_start_gatt_discovery(const RawAddress& bd_addr) { 
 ******************************************************************************/

static void bta_dm_proc_open_evt(tBTA_GATTC_OPEN* p_data) {

  log::verbose("DM Search state= {} search_cb.peer_dbaddr:{} connected_bda={}",

               bta_dm_search_get_state(), bta_dm_search_cb.peer_bdaddr,

               bta_dm_discovery_get_state(), bta_dm_search_cb.peer_bdaddr,

               p_data->remote_bda);



  log::debug("BTA_GATTC_OPEN_EVT conn_id = {} client_if={} status = {}",
@@ -1978,15 +1997,9 @@ static void bta_dm_gattc_callback(tBTA_GATTC_EVT event, tBTA_GATTC* p_data) { 
      break;



    case BTA_GATTC_SEARCH_CMPL_EVT:

      switch (bta_dm_search_get_state()) {

        case BTA_DM_SEARCH_IDLE:

          break;

        case BTA_DM_SEARCH_ACTIVE:

        case BTA_DM_SEARCH_CANCELLING:

        case BTA_DM_DISCOVER_ACTIVE:

      if (bta_dm_discovery_get_state() == BTA_DM_DISCOVER_ACTIVE) {

        bta_dm_gatt_disc_complete(p_data->search_cmpl.conn_id,

                                  p_data->search_cmpl.status);

          break;

      }

      disc_gatt_history_.Push(base::StringPrintf(

          "%-32s conn_id:%hu status:%s", "GATTC_EventCallback",
@@ -2001,13 +2014,7 @@ static void bta_dm_gattc_callback(tBTA_GATTC_EVT event, tBTA_GATTC* p_data) { 
        bta_dm_search_cb.conn_id = GATT_INVALID_CONN_ID;

      }



      switch (bta_dm_search_get_state()) {

        case BTA_DM_SEARCH_IDLE:

        case BTA_DM_SEARCH_ACTIVE:

          break;



        case BTA_DM_SEARCH_CANCELLING:

        case BTA_DM_DISCOVER_ACTIVE:

      if (bta_dm_discovery_get_state() == BTA_DM_DISCOVER_ACTIVE) {

        /* in case of disconnect before search is completed */

        if (p_data->close.remote_bda == bta_dm_search_cb.peer_bdaddr) {

          bta_dm_gatt_disc_complete((uint16_t)GATT_INVALID_CONN_ID,
@@ -2079,8 +2086,8 @@ std::string EpochMillisToString(long long time_ms) { 
}  // namespace



struct tSEARCH_STATE_HISTORY {

  const tBTA_DM_STATE state;

  const tBTA_DM_EVT event;

  const tBTA_DM_DEVICE_SEARCH_STATE state;

  const tBTA_DM_DEV_SEARCH_EVT event;

  std::string ToString() const {

    return base::StringPrintf("state:%25s event:%s",

                              bta_dm_state_text(state).c_str(),
@@ -2101,7 +2108,7 @@ bluetooth::common::TimestampedCircularBuffer<tSEARCH_STATE_HISTORY> 
 * Returns          void

 *

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

static void bta_dm_search_sm_execute(tBTA_DM_EVT event,

static void bta_dm_search_sm_execute(tBTA_DM_DEV_SEARCH_EVT event,

                                     std::unique_ptr<tBTA_DM_MSG> msg) {

  log::info("state:{}, event:{}[0x{:x}]",

            bta_dm_state_text(bta_dm_search_get_state()),
@@ -2121,23 +2128,10 @@ static void bta_dm_search_sm_execute(tBTA_DM_EVT event, 


          bta_dm_search_start(std::get<tBTA_DM_API_SEARCH>(*msg));

          break;

        case BTA_DM_API_DISCOVER_EVT:

          bta_dm_search_set_state(BTA_DM_DISCOVER_ACTIVE);

          log::assert_that(std::holds_alternative<tBTA_DM_API_DISCOVER>(*msg),

                           "bad message type: {}", msg->index());



          bta_dm_discover(std::get<tBTA_DM_API_DISCOVER>(*msg));

          break;

        case BTA_DM_API_SEARCH_CANCEL_EVT:

          bta_dm_search_clear_queue();

          bta_dm_search_cancel_notify();

          break;

        case BTA_DM_SDP_RESULT_EVT:

          bta_dm_free_sdp_db();

          break;

        case BTA_DM_DISC_CLOSE_TOUT_EVT:

          bta_dm_close_gatt_conn();

          break;

        default:

          log::info("Received unexpected event {}[0x{:x}] in state {}",

                    bta_dm_event_text(event), event,
@@ -2155,21 +2149,6 @@ static void bta_dm_search_sm_execute(tBTA_DM_EVT event, 
        case BTA_DM_SEARCH_CMPL_EVT:

          bta_dm_search_cmpl();

          break;

        case BTA_DM_DISCOVERY_RESULT_EVT:

          log::assert_that(std::holds_alternative<tBTA_DM_SVC_RES>(*msg),

                           "bad message type: {}", msg->index());



          bta_dm_disc_result(std::get<tBTA_DM_SVC_RES>(*msg));

          break;

        case BTA_DM_DISC_CLOSE_TOUT_EVT:

          bta_dm_close_gatt_conn();

          break;

        case BTA_DM_API_DISCOVER_EVT:

          log::assert_that(std::holds_alternative<tBTA_DM_API_DISCOVER>(*msg),

                           "bad message type: {}", msg->index());



          bta_dm_queue_disc(std::get<tBTA_DM_API_DISCOVER>(*msg));

          break;

        case BTA_DM_API_SEARCH_CANCEL_EVT:

          bta_dm_search_clear_queue();

          bta_dm_search_set_state(BTA_DM_SEARCH_CANCELLING);
@@ -2189,84 +2168,99 @@ static void bta_dm_search_sm_execute(tBTA_DM_EVT event, 


          bta_dm_queue_search(std::get<tBTA_DM_API_SEARCH>(*msg));

          break;

        case BTA_DM_API_DISCOVER_EVT:

          log::assert_that(std::holds_alternative<tBTA_DM_API_DISCOVER>(*msg),

                           "bad message type: {}", msg->index());



          bta_dm_queue_disc(std::get<tBTA_DM_API_DISCOVER>(*msg));

          break;

        case BTA_DM_API_SEARCH_CANCEL_EVT:

          bta_dm_search_clear_queue();

          bta_dm_search_cancel_notify();

          break;

        case BTA_DM_SDP_RESULT_EVT:

        case BTA_DM_REMT_NAME_EVT:

        case BTA_DM_SEARCH_CMPL_EVT:

        case BTA_DM_DISCOVERY_RESULT_EVT:

          bta_dm_search_set_state(BTA_DM_SEARCH_IDLE);

          bta_dm_free_sdp_db();

          bta_dm_search_cancel_notify();

          bta_dm_execute_queued_request();

          break;

        case BTA_DM_DISC_CLOSE_TOUT_EVT:

          bta_dm_close_gatt_conn();

          break;

        default:

          log::info("Received unexpected event {}[0x{:x}] in state {}",

                    bta_dm_event_text(event), event,

                    bta_dm_state_text(bta_dm_search_get_state()));

      }

      break;

    case BTA_DM_DISCOVER_ACTIVE:

  }

}



struct tDISCOVERY_STATE_HISTORY {

  const tBTA_DM_SERVICE_DISCOVERY_STATE state;

  const tBTA_DM_DISC_EVT event;

  std::string ToString() const {

    return base::StringPrintf("state:%25s event:%s",

                              bta_dm_state_text(state).c_str(),

                              bta_dm_event_text(event).c_str());

  }

};



bluetooth::common::TimestampedCircularBuffer<tDISCOVERY_STATE_HISTORY>

    discovery_state_history_(kSearchStateHistorySize);



static void bta_dm_disc_sm_execute(tBTA_DM_DISC_EVT event,

                                   std::unique_ptr<tBTA_DM_MSG> msg) {

  log::info("state:{}, event:{}[0x{:x}]",

            bta_dm_state_text(bta_dm_discovery_get_state()),

            bta_dm_event_text(event), event);

  discovery_state_history_.Push({

      .state = bta_dm_discovery_get_state(),

      .event = event,

  });



  switch (bta_dm_discovery_get_state()) {

    case BTA_DM_DISCOVER_IDLE:

      switch (event) {

        case BTA_DM_REMT_NAME_EVT:

          log::assert_that(std::holds_alternative<tBTA_DM_REMOTE_NAME>(*msg),

        case BTA_DM_API_DISCOVER_EVT:

          bta_dm_discovery_set_state(BTA_DM_DISCOVER_ACTIVE);

          log::assert_that(std::holds_alternative<tBTA_DM_API_DISCOVER>(*msg),

                           "bad message type: {}", msg->index());



          bta_dm_remote_name_cmpl(std::get<tBTA_DM_REMOTE_NAME>(*msg));

          bta_dm_discover(std::get<tBTA_DM_API_DISCOVER>(*msg));

          break;

        case BTA_DM_SDP_RESULT_EVT:

          bta_dm_free_sdp_db();

          break;

        case BTA_DM_DISC_CLOSE_TOUT_EVT:

          bta_dm_close_gatt_conn();

          break;

        default:

          log::info("Received unexpected event {}[0x{:x}] in state {}",

                    bta_dm_event_text(event), event,

                    bta_dm_state_text(bta_dm_discovery_get_state()));

      }

      break;



    case BTA_DM_DISCOVER_ACTIVE:

      switch (event) {

        case BTA_DM_SDP_RESULT_EVT:

          log::assert_that(std::holds_alternative<tBTA_DM_SDP_RESULT>(*msg),

                           "bad message type: {}", msg->index());



          bta_dm_sdp_result(std::get<tBTA_DM_SDP_RESULT>(*msg));

          break;

        case BTA_DM_SEARCH_CMPL_EVT:

          bta_dm_search_cmpl();

          break;

        case BTA_DM_DISCOVERY_RESULT_EVT:

          log::assert_that(std::holds_alternative<tBTA_DM_SVC_RES>(*msg),

                           "bad message type: {}", msg->index());



          bta_dm_disc_result(std::get<tBTA_DM_SVC_RES>(*msg));

          break;

        case BTA_DM_API_SEARCH_EVT:

          log::assert_that(std::holds_alternative<tBTA_DM_API_SEARCH>(*msg),

                           "bad message type: {}", msg->index());



          bta_dm_queue_search(std::get<tBTA_DM_API_SEARCH>(*msg));

          break;

        case BTA_DM_API_DISCOVER_EVT:

          log::assert_that(std::holds_alternative<tBTA_DM_API_DISCOVER>(*msg),

                           "bad message type: {}", msg->index());



          bta_dm_queue_disc(std::get<tBTA_DM_API_DISCOVER>(*msg));

          break;

        case BTA_DM_API_SEARCH_CANCEL_EVT:

          bta_dm_search_clear_queue();

          if (IS_FLAG_ENABLED(

                  continue_service_discovery_when_cancel_device_discovery)) {

            bta_dm_search_set_state(BTA_DM_SEARCH_CANCELLING);

          }

          bta_dm_search_cancel_notify();

          break;

        case BTA_DM_DISC_CLOSE_TOUT_EVT:

          bta_dm_close_gatt_conn();

          break;

        default:

          log::info("Received unexpected event {}[0x{:x}] in state {}",

                    bta_dm_event_text(event), event,

                    bta_dm_state_text(bta_dm_search_get_state()));

                    bta_dm_state_text(bta_dm_discovery_get_state()));

      }

      break;

  }
@@ -2274,7 +2268,8 @@ static void bta_dm_search_sm_execute(tBTA_DM_EVT event, 


static void bta_dm_disc_init_search_cb(tBTA_DM_SEARCH_CB& bta_dm_search_cb) {

  bta_dm_search_cb = {};

  bta_dm_search_cb.state = BTA_DM_SEARCH_IDLE;

  bta_dm_search_cb.search_state = BTA_DM_SEARCH_IDLE;

  bta_dm_search_cb.service_discovery_state = BTA_DM_DISCOVER_IDLE;

  bta_dm_search_cb.conn_id = GATT_INVALID_CONN_ID;

  bta_dm_search_cb.transport = BT_TRANSPORT_AUTO;

}
@@ -2358,7 +2353,7 @@ void bta_dm_disc_start_service_discovery(service_discovery_callbacks cbacks, 
                                                            transport);

    return;

  }

  bta_dm_search_sm_execute(

  bta_dm_disc_sm_execute(

      BTA_DM_API_DISCOVER_EVT,

      std::make_unique<tBTA_DM_MSG>(tBTA_DM_API_DISCOVER{

          .bd_addr = bd_addr, .cbacks = cbacks, .transport = transport}));
@@ -2378,6 +2373,17 @@ void DumpsysBtaDmDisc(int fd) { 
  }

  LOG_DUMPSYS(fd, " current bta_dm_search_state:%s",

              bta_dm_state_text(bta_dm_search_get_state()).c_str());



  {

    auto copy = discovery_state_history_.Pull();

    LOG_DUMPSYS(fd, " last %zu discovery state transitions", copy.size());

    for (const auto& it : copy) {

      LOG_DUMPSYS(fd, "   %s %s", EpochMillisToString(it.timestamp).c_str(),

                  it.entry.ToString().c_str());

    }

    LOG_DUMPSYS(fd, " current bta_dm_discovery_state:%s",

                bta_dm_state_text(bta_dm_discovery_get_state()).c_str());

  }

}

#undef DUMPSYS_TAG

system/bta/dm/bta_dm_disc_int.h

+46 −17
Original line number Diff line number Diff line
@@ -38,28 +38,35 @@ typedef enum : uint16_t { 
  /* DM search API events */

  BTA_DM_API_SEARCH_EVT,

  BTA_DM_API_SEARCH_CANCEL_EVT,

  BTA_DM_API_DISCOVER_EVT,

  BTA_DM_INQUIRY_CMPL_EVT,

  BTA_DM_REMT_NAME_EVT,

  BTA_DM_SDP_RESULT_EVT,

  BTA_DM_SEARCH_CMPL_EVT,

} tBTA_DM_DEV_SEARCH_EVT;



typedef enum : uint16_t {

  /* service discovery events */

  BTA_DM_API_DISCOVER_EVT,

  BTA_DM_SDP_RESULT_EVT,

  BTA_DM_DISCOVERY_RESULT_EVT,

  BTA_DM_DISC_CLOSE_TOUT_EVT,

} tBTA_DM_EVT;

} tBTA_DM_DISC_EVT;



inline std::string bta_dm_event_text(const tBTA_DM_EVT& event) {

inline std::string bta_dm_event_text(const tBTA_DM_DEV_SEARCH_EVT& event) {

  switch (event) {

    CASE_RETURN_TEXT(BTA_DM_API_SEARCH_EVT);

    CASE_RETURN_TEXT(BTA_DM_API_SEARCH_CANCEL_EVT);

    CASE_RETURN_TEXT(BTA_DM_API_DISCOVER_EVT);

    CASE_RETURN_TEXT(BTA_DM_INQUIRY_CMPL_EVT);

    CASE_RETURN_TEXT(BTA_DM_REMT_NAME_EVT);

    CASE_RETURN_TEXT(BTA_DM_SDP_RESULT_EVT);

    CASE_RETURN_TEXT(BTA_DM_SEARCH_CMPL_EVT);

  }

}



inline std::string bta_dm_event_text(const tBTA_DM_DISC_EVT& event) {

  switch (event) {

    CASE_RETURN_TEXT(BTA_DM_API_DISCOVER_EVT);

    CASE_RETURN_TEXT(BTA_DM_SDP_RESULT_EVT);

    CASE_RETURN_TEXT(BTA_DM_DISCOVERY_RESULT_EVT);

    CASE_RETURN_TEXT(BTA_DM_DISC_CLOSE_TOUT_EVT);

    default:

      return base::StringPrintf("UNKNOWN[0x%04x]", event);

  }

}
@@ -119,22 +126,29 @@ using tBTA_DM_MSG = 


/* DM search state */

typedef enum {



  BTA_DM_SEARCH_IDLE,

  BTA_DM_SEARCH_ACTIVE,

  BTA_DM_SEARCH_CANCELLING,

  BTA_DM_DISCOVER_ACTIVE

} tBTA_DM_DEVICE_SEARCH_STATE;



} tBTA_DM_STATE;

typedef enum {

  BTA_DM_DISCOVER_IDLE,

  BTA_DM_DISCOVER_ACTIVE

} tBTA_DM_SERVICE_DISCOVERY_STATE;



inline std::string bta_dm_state_text(const tBTA_DM_STATE& state) {

inline std::string bta_dm_state_text(const tBTA_DM_DEVICE_SEARCH_STATE& state) {

  switch (state) {

    CASE_RETURN_TEXT(BTA_DM_SEARCH_IDLE);

    CASE_RETURN_TEXT(BTA_DM_SEARCH_ACTIVE);

    CASE_RETURN_TEXT(BTA_DM_SEARCH_CANCELLING);

  }

}



inline std::string bta_dm_state_text(

    const tBTA_DM_SERVICE_DISCOVERY_STATE& state) {

  switch (state) {

    CASE_RETURN_TEXT(BTA_DM_DISCOVER_IDLE);

    CASE_RETURN_TEXT(BTA_DM_DISCOVER_ACTIVE);

    default:

      return base::StringPrintf("UNKNOWN[%d]", state);

  }

}
@@ -146,7 +160,15 @@ typedef struct { 
  tBTA_SERVICE_MASK services_to_search;

  tBTA_SERVICE_MASK services_found;

  tSDP_DISCOVERY_DB* p_sdp_db;

  tBTA_DM_STATE state;

  /* This covers device search state. That is scanning through android Settings

   * to discover LE and Classic devices. Runs Name discovery on Inquiry Results

   */

  tBTA_DM_DEVICE_SEARCH_STATE search_state;

  /* This covers service discovery state - callers of BTA_DmDiscover. That is

   * initial service discovery after bonding and

   * BluetoothDevice.fetchUuidsWithSdp(). Responsible for LE GATT Service

   * Discovery and SDP */

  tBTA_DM_SERVICE_DISCOVERY_STATE service_discovery_state;

  RawAddress peer_bdaddr;

  bool name_discover_done;

  BD_NAME peer_name;
@@ -174,7 +196,14 @@ extern const uint16_t bta_service_id_to_uuid_lkup_tbl[]; 


namespace fmt {

template <>

struct formatter<tBTA_DM_EVT> : enum_formatter<tBTA_DM_EVT> {};

struct formatter<tBTA_DM_DEV_SEARCH_EVT>

    : enum_formatter<tBTA_DM_DEV_SEARCH_EVT> {};

template <>

struct formatter<tBTA_DM_DISC_EVT> : enum_formatter<tBTA_DM_DISC_EVT> {};

template <>

struct formatter<tBTA_DM_DEVICE_SEARCH_STATE>

    : enum_formatter<tBTA_DM_DEVICE_SEARCH_STATE> {};

template <>

struct formatter<tBTA_DM_STATE> : enum_formatter<tBTA_DM_STATE> {};

struct formatter<tBTA_DM_SERVICE_DISCOVERY_STATE>

    : enum_formatter<tBTA_DM_SERVICE_DISCOVERY_STATE> {};

}  // namespace fmt