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

Commit 5f8a16e3 authored by Jakub Pawłowski's avatar Jakub Pawłowski Committed by Gerrit Code Review
Browse files

Merge changes If7c121d9,I04fb5243 into main 

* changes:
  Add sdp_finished helper
  Move SDP related variables out of control block, into separate struct
parents dde70384 4f5c4e72

system/bta/dm/bta_dm_disc.cc

+104 −135
Original line number Diff line number Diff line
@@ -81,14 +81,14 @@ static void post_disc_evt(tBTA_DM_DISC_EVT event, 
}



static void bta_dm_gatt_disc_complete(uint16_t conn_id, tGATT_STATUS status);

static void bta_dm_find_services(const RawAddress& bd_addr);

static void bta_dm_find_services(const RawAddress& bd_addr,

                                 tBTA_DM_SDP_STATE* sdp_state);

static void bta_dm_sdp_callback(const RawAddress& bd_addr,

                                tSDP_STATUS sdp_status);

static void bta_dm_disable_disc(void);

static void bta_dm_gattc_register(void);

static void btm_dm_start_gatt_discovery(const RawAddress& bd_addr);

static void bta_dm_gattc_callback(tBTA_GATTC_EVT event, tBTA_GATTC* p_data);

static void bta_dm_free_sdp_db();

static void bta_dm_execute_queued_discovery_request();

static void bta_dm_close_gatt_conn();
@@ -265,9 +265,6 @@ const uint16_t bta_service_id_to_uuid_lkup_tbl[BTA_MAX_SERVICE_ID] = { 
    UUID_PROTOCOL_ATT                     /* BTA_GATT_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_discovery_set_state(tBTA_DM_SERVICE_DISCOVERY_STATE state) {

  bta_dm_discovery_cb.service_discovery_state = state;

}
@@ -327,7 +324,7 @@ static void store_avrcp_profile_feature(tSDP_DISC_REC* sdp_rec) { 
  }

}



static void bta_dm_store_audio_profiles_version() {

static void bta_dm_store_audio_profiles_version(tSDP_DISCOVERY_DB* p_sdp_db) {

  struct AudioProfile {

    const uint16_t servclass_uuid;

    const uint16_t btprofile_uuid;
@@ -346,7 +343,7 @@ static void bta_dm_store_audio_profiles_version() { 


  for (const auto& audio_profile : audio_profiles) {

    tSDP_DISC_REC* sdp_rec = get_legacy_stack_sdp_api()->db.SDP_FindServiceInDb(

        bta_dm_discovery_cb.p_sdp_db, audio_profile.servclass_uuid, NULL);

        p_sdp_db, audio_profile.servclass_uuid, NULL);

    if (sdp_rec == NULL) continue;



    if (get_legacy_stack_sdp_api()->record.SDP_FindAttributeInRec(
@@ -374,7 +371,22 @@ static void bta_dm_store_audio_profiles_version() { 
  }

}



static void bta_dm_sdp_result(tSDP_STATUS sdp_result);

void sdp_finished(RawAddress bda, tBTA_STATUS result,

                  tBTA_SERVICE_MASK services,

                  std::vector<bluetooth::Uuid> uuids = {},

                  std::vector<bluetooth::Uuid> gatt_uuids = {}) {

  bta_dm_disc_sm_execute(BTA_DM_DISCOVERY_RESULT_EVT,

                         std::make_unique<tBTA_DM_MSG>(tBTA_DM_SVC_RES{

                             .bd_addr = bda,

                             .services = services,

                             .uuids = uuids,

                             .gatt_uuids = gatt_uuids,

                             .result = result,

                         }));

}



static void bta_dm_sdp_result(tSDP_STATUS sdp_result,

                              tBTA_DM_SDP_STATE* sdp_state);



/* Callback from sdp with discovery status */

static void bta_dm_sdp_callback(const RawAddress& /* bd_addr */,
@@ -382,51 +394,51 @@ static void bta_dm_sdp_callback(const RawAddress& /* bd_addr */, 
  log::info("{}", bta_dm_state_text(bta_dm_discovery_get_state()));



  if (bta_dm_discovery_get_state() == BTA_DM_DISCOVER_IDLE) {

    bta_dm_free_sdp_db();

    return;

  }



  do_in_main_thread(FROM_HERE, base::BindOnce(&bta_dm_sdp_result, sdp_status));

  do_in_main_thread(FROM_HERE,

                    base::BindOnce(&bta_dm_sdp_result, sdp_status,

                                   bta_dm_discovery_cb.sdp_state.get()));

}



/* Process the discovery result from sdp */

static void bta_dm_sdp_result(tSDP_STATUS sdp_result) {

static void bta_dm_sdp_result(tSDP_STATUS sdp_result,

                              tBTA_DM_SDP_STATE* sdp_state) {

  tSDP_DISC_REC* p_sdp_rec = NULL;

  bool scn_found = false;

  uint16_t service = 0xFFFF;

  tSDP_PROTOCOL_ELEM pe;



  std::vector<Uuid> uuid_list;

  tSDP_DISCOVERY_DB* p_sdp_db = (tSDP_DISCOVERY_DB*)sdp_state->sdp_db_buffer;



  if ((sdp_result == SDP_SUCCESS) || (sdp_result == SDP_NO_RECS_MATCH) ||

      (sdp_result == SDP_DB_FULL)) {

    log::verbose("sdp_result::0x{:x}", sdp_result);

    std::vector<Uuid> gatt_uuids;



    do {

      p_sdp_rec = NULL;

      if (bta_dm_discovery_cb.service_index == (BTA_USER_SERVICE_ID + 1)) {

      if (sdp_state->service_index == (BTA_USER_SERVICE_ID + 1)) {

        if (p_sdp_rec &&

            get_legacy_stack_sdp_api()->record.SDP_FindProtocolListElemInRec(

                p_sdp_rec, UUID_PROTOCOL_RFCOMM, &pe)) {

          bta_dm_discovery_cb.peer_scn = (uint8_t)pe.params[0];

          sdp_state->peer_scn = (uint8_t)pe.params[0];

          scn_found = true;

        }

      } else {

        service =

            bta_service_id_to_uuid_lkup_tbl[bta_dm_discovery_cb.service_index -

                                            1];

        service = bta_service_id_to_uuid_lkup_tbl[sdp_state->service_index - 1];

        p_sdp_rec = get_legacy_stack_sdp_api()->db.SDP_FindServiceInDb(

            bta_dm_discovery_cb.p_sdp_db, service, p_sdp_rec);

            p_sdp_db, service, p_sdp_rec);

      }

      /* finished with BR/EDR services, now we check the result for GATT based

       * service UUID */

      if (bta_dm_discovery_cb.service_index == BTA_MAX_SERVICE_ID) {

      if (sdp_state->service_index == BTA_MAX_SERVICE_ID) {

        /* all GATT based services */

        do {

          /* find a service record, report it */

          p_sdp_rec = get_legacy_stack_sdp_api()->db.SDP_FindServiceInDb(

              bta_dm_discovery_cb.p_sdp_db, 0, p_sdp_rec);

              p_sdp_db, 0, p_sdp_rec);

          if (p_sdp_rec) {

            Uuid service_uuid;

            if (get_legacy_stack_sdp_api()->record.SDP_FindServiceUUIDInRec(
@@ -440,34 +452,32 @@ static void bta_dm_sdp_result(tSDP_STATUS sdp_result) { 
          log::info("GATT services discovered using SDP");

        }

      } else {

        if ((p_sdp_rec != NULL)) {

          if (service != UUID_SERVCLASS_PNP_INFORMATION) {

            bta_dm_discovery_cb.services_found |=

        if (p_sdp_rec != NULL && service != UUID_SERVCLASS_PNP_INFORMATION) {

          sdp_state->services_found |=

              (tBTA_SERVICE_MASK)(BTA_SERVICE_ID_TO_SERVICE_MASK(

                    bta_dm_discovery_cb.service_index - 1));

            uint16_t tmp_svc = bta_service_id_to_uuid_lkup_tbl

                [bta_dm_discovery_cb.service_index - 1];

                  sdp_state->service_index - 1));

          uint16_t tmp_svc =

              bta_service_id_to_uuid_lkup_tbl[sdp_state->service_index - 1];

          /* Add to the list of UUIDs */

          uuid_list.push_back(Uuid::From16Bit(tmp_svc));

        }

      }

      }



      if (bta_dm_discovery_cb.services_to_search == 0) {

        bta_dm_discovery_cb.service_index++;

      if (sdp_state->services_to_search == 0) {

        sdp_state->service_index++;

      } else /* regular one service per search or PNP search */

        break;



    } while (bta_dm_discovery_cb.service_index <= BTA_MAX_SERVICE_ID);

    } while (sdp_state->service_index <= BTA_MAX_SERVICE_ID);



    log::verbose("services_found = {:04x}", bta_dm_discovery_cb.services_found);

    log::verbose("services_found = {:04x}", sdp_state->services_found);



    /* Collect the 128-bit services here and put them into the list */

    p_sdp_rec = NULL;

    do {

      /* find a service record, report it */

      p_sdp_rec = get_legacy_stack_sdp_api()->db.SDP_FindServiceInDb_128bit(

          bta_dm_discovery_cb.p_sdp_db, p_sdp_rec);

          p_sdp_db, p_sdp_rec);

      if (p_sdp_rec) {

        // SDP_FindServiceUUIDInRec_128bit is used only once, refactor?

        Uuid temp_uuid;
@@ -480,14 +490,14 @@ static void bta_dm_sdp_result(tSDP_STATUS sdp_result) { 


    if (bluetooth::common::init_flags::

            dynamic_avrcp_version_enhancement_is_enabled() &&

        bta_dm_discovery_cb.services_to_search == 0) {

      bta_dm_store_audio_profiles_version();

        sdp_state->services_to_search == 0) {

      bta_dm_store_audio_profiles_version(p_sdp_db);

    }



#if TARGET_FLOSS

    tSDP_DI_GET_RECORD di_record;

    if (get_legacy_stack_sdp_api()->device_id.SDP_GetDiRecord(

            1, &di_record, bta_dm_discovery_cb.p_sdp_db) == SDP_SUCCESS) {

            1, &di_record, p_sdp_db) == SDP_SUCCESS) {

      bta_dm_discovery_cb.service_search_cbacks.on_did_received(

          bta_dm_discovery_cb.peer_bdaddr, di_record.rec.vendor_id_source,

          di_record.rec.vendor, di_record.rec.product, di_record.rec.version);
@@ -495,10 +505,8 @@ static void bta_dm_sdp_result(tSDP_STATUS sdp_result) { 
#endif



    /* if there are more services to search for */

    if (bta_dm_discovery_cb.services_to_search) {

      /* Free up the p_sdp_db before checking the next one */

      bta_dm_free_sdp_db();

      bta_dm_find_services(bta_dm_discovery_cb.peer_bdaddr);

    if (sdp_state->services_to_search) {

      bta_dm_find_services(bta_dm_discovery_cb.peer_bdaddr, sdp_state);

      return;

    }
@@ -508,46 +516,36 @@ static void bta_dm_sdp_result(tSDP_STATUS sdp_result) { 
        kBtmLogTag, bta_dm_discovery_cb.peer_bdaddr, "Discovery completed",

        base::StringPrintf("Result:%s services_found:0x%x service_index:0x%d",

                           sdp_result_text(sdp_result).c_str(),

                            bta_dm_discovery_cb.services_found,

                            bta_dm_discovery_cb.service_index));

                           sdp_state->services_found,

                           sdp_state->service_index));



    auto msg = std::make_unique<tBTA_DM_MSG>(tBTA_DM_SVC_RES{});

    auto& disc_result = std::get<tBTA_DM_SVC_RES>(*msg);



    disc_result.result = BTA_SUCCESS;

    disc_result.uuids = std::move(uuid_list);

    disc_result.gatt_uuids = std::move(gatt_uuids);

    // Copy the raw_data to the discovery result structure

    if (bta_dm_discovery_cb.p_sdp_db != NULL &&

        bta_dm_discovery_cb.p_sdp_db->raw_used != 0 &&

        bta_dm_discovery_cb.p_sdp_db->raw_data != NULL) {

    if (p_sdp_db != NULL && p_sdp_db->raw_used != 0 &&

        p_sdp_db->raw_data != NULL) {

      log::verbose("raw_data used = 0x{:x} raw_data_ptr = 0x{}",

                    bta_dm_discovery_cb.p_sdp_db->raw_used,

                    fmt::ptr(bta_dm_discovery_cb.p_sdp_db->raw_data));

                   p_sdp_db->raw_used, fmt::ptr(p_sdp_db->raw_data));



      bta_dm_discovery_cb.p_sdp_db->raw_data =

      p_sdp_db->raw_data =

          NULL;  // no need to free this - it is a global assigned.

      bta_dm_discovery_cb.p_sdp_db->raw_used = 0;

      bta_dm_discovery_cb.p_sdp_db->raw_size = 0;

      p_sdp_db->raw_used = 0;

      p_sdp_db->raw_size = 0;

    } else {

      log::verbose("raw data size is 0 or raw_data is null!!");

    }

    /* Done with p_sdp_db. Free it */

    bta_dm_free_sdp_db();

    disc_result.services = bta_dm_discovery_cb.services_found;



    tBTA_STATUS result = BTA_SUCCESS;

    auto services = sdp_state->services_found;

    // Piggy back the SCN over result field

    if (scn_found) {

      disc_result.result =

          static_cast<tBTA_STATUS>((3 + bta_dm_discovery_cb.peer_scn));

      disc_result.services |= BTA_USER_SERVICE_MASK;

      result = static_cast<tBTA_STATUS>((3 + sdp_state->peer_scn));

      services |= BTA_USER_SERVICE_MASK;



      log::verbose("Piggy back the SCN over result field  SCN={}",

                    bta_dm_discovery_cb.peer_scn);

                   sdp_state->peer_scn);

    }

    disc_result.bd_addr = bta_dm_discovery_cb.peer_bdaddr;



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

    sdp_finished(bta_dm_discovery_cb.peer_bdaddr, result, services, uuid_list,

                 gatt_uuids);

  } else {

    BTM_LogHistory(

        kBtmLogTag, bta_dm_discovery_cb.peer_bdaddr, "Discovery failed",
@@ -555,17 +553,8 @@ static void bta_dm_sdp_result(tSDP_STATUS sdp_result) { 
    log::error("SDP connection failed {}", sdp_status_text(sdp_result));



    /* not able to connect go to next device */

    if (bta_dm_discovery_cb.p_sdp_db)

      osi_free_and_reset((void**)&bta_dm_discovery_cb.p_sdp_db);



    auto msg = std::make_unique<tBTA_DM_MSG>(tBTA_DM_SVC_RES{});

    auto& disc_result = std::get<tBTA_DM_SVC_RES>(*msg);



    disc_result.result = BTA_FAILURE;

    disc_result.services = bta_dm_discovery_cb.services_found;

    disc_result.bd_addr = bta_dm_discovery_cb.peer_bdaddr;



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

    sdp_finished(bta_dm_discovery_cb.peer_bdaddr, BTA_FAILURE,

                 sdp_state->services_found);

  }

}
@@ -630,19 +619,6 @@ static void bta_dm_disc_result(tBTA_DM_SVC_RES& disc_result) { 
  bta_dm_execute_queued_discovery_request();

}



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

 *

 * Function         bta_dm_free_sdp_db

 *

 * Description      Frees SDP data base

 *

 * Returns          void

 *

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

static void bta_dm_free_sdp_db() {

  osi_free_and_reset((void**)&bta_dm_discovery_cb.p_sdp_db);

}



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

 *

 * Function         bta_dm_queue_disc
@@ -660,6 +636,7 @@ static void bta_dm_queue_disc(tBTA_DM_API_DISCOVER& discovery) { 


static void bta_dm_execute_queued_discovery_request() {

  if (bta_dm_discovery_cb.pending_discovery_queue.empty()) {

    bta_dm_discovery_cb.sdp_state.reset();

    log::info("No more service discovery queued");

    return;

  }
@@ -682,56 +659,50 @@ static void bta_dm_execute_queued_discovery_request() { 
 * Returns          void

 *

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

static void bta_dm_find_services(const RawAddress& bd_addr) {

  while (bta_dm_discovery_cb.service_index < BTA_MAX_SERVICE_ID) {

    if (bta_dm_discovery_cb.services_to_search &

static void bta_dm_find_services(const RawAddress& bd_addr,

                                 tBTA_DM_SDP_STATE* sdp_state) {

  while (sdp_state->service_index < BTA_MAX_SERVICE_ID) {

    if (sdp_state->services_to_search &

        (tBTA_SERVICE_MASK)(BTA_SERVICE_ID_TO_SERVICE_MASK(

            bta_dm_discovery_cb.service_index))) {

            sdp_state->service_index))) {

      break;

    }

    bta_dm_discovery_cb.service_index++;

    sdp_state->service_index++;

  }



  /* no more services to be discovered */

  if (bta_dm_discovery_cb.service_index >= BTA_MAX_SERVICE_ID) {

  if (sdp_state->service_index >= BTA_MAX_SERVICE_ID) {

    log::info("SDP - no more services to discover");

    bta_dm_disc_sm_execute(BTA_DM_DISCOVERY_RESULT_EVT,

                           std::make_unique<tBTA_DM_MSG>(tBTA_DM_SVC_RES{

                               .bd_addr = bta_dm_discovery_cb.peer_bdaddr,

                               .services = bta_dm_discovery_cb.services_found,

                               .result = BTA_SUCCESS}));

    sdp_finished(bd_addr, BTA_SUCCESS, sdp_state->services_found);

    return;

  }



  /* try to search all services by search based on L2CAP UUID */

  log::info("services_to_search={:08x}",

            bta_dm_discovery_cb.services_to_search);

  log::info("services_to_search={:08x}", sdp_state->services_to_search);

  Uuid uuid = Uuid::kEmpty;

  if (bta_dm_discovery_cb.services_to_search & BTA_RES_SERVICE_MASK) {

  if (sdp_state->services_to_search & BTA_RES_SERVICE_MASK) {

    uuid = Uuid::From16Bit(bta_service_id_to_uuid_lkup_tbl[0]);

    bta_dm_discovery_cb.services_to_search &= ~BTA_RES_SERVICE_MASK;

    sdp_state->services_to_search &= ~BTA_RES_SERVICE_MASK;

  } else {

    uuid = Uuid::From16Bit(UUID_PROTOCOL_L2CAP);

    bta_dm_discovery_cb.services_to_search = 0;

    sdp_state->services_to_search = 0;

  }



  bta_dm_discovery_cb.p_sdp_db =

      (tSDP_DISCOVERY_DB*)osi_malloc(BTA_DM_SDP_DB_SIZE);

  tSDP_DISCOVERY_DB* p_sdp_db = (tSDP_DISCOVERY_DB*)sdp_state->sdp_db_buffer;



  log::info("search UUID = {}", uuid.ToString());

  if (!get_legacy_stack_sdp_api()->service.SDP_InitDiscoveryDb(

          bta_dm_discovery_cb.p_sdp_db, BTA_DM_SDP_DB_SIZE, 1, &uuid, 0,

          NULL)) {

          p_sdp_db, BTA_DM_SDP_DB_SIZE, 1, &uuid, 0, NULL)) {

    log::warn("Unable to initialize SDP service discovery db peer:{}", bd_addr);

  }



  memset(g_disc_raw_data_buf, 0, sizeof(g_disc_raw_data_buf));

  bta_dm_discovery_cb.p_sdp_db->raw_data = g_disc_raw_data_buf;

  sdp_state->g_disc_raw_data_buf = {};

  p_sdp_db->raw_data = sdp_state->g_disc_raw_data_buf.data();



  bta_dm_discovery_cb.p_sdp_db->raw_size = MAX_DISC_RAW_DATA_BUF;

  p_sdp_db->raw_size = MAX_DISC_RAW_DATA_BUF;



  if (!get_legacy_stack_sdp_api()->service.SDP_ServiceSearchAttributeRequest(

          bd_addr, bta_dm_discovery_cb.p_sdp_db, &bta_dm_sdp_callback)) {

          bd_addr, p_sdp_db, &bta_dm_sdp_callback)) {

    /*

     * If discovery is not successful with this device, then

     * proceed with the next one.
@@ -739,13 +710,8 @@ static void bta_dm_find_services(const RawAddress& bd_addr) { 
    log::warn("Unable to start SDP service search attribute request peer:{}",

              bd_addr);



    osi_free_and_reset((void**)&bta_dm_discovery_cb.p_sdp_db);

    bta_dm_discovery_cb.service_index = BTA_MAX_SERVICE_ID;

    bta_dm_disc_sm_execute(BTA_DM_DISCOVERY_RESULT_EVT,

                           std::make_unique<tBTA_DM_MSG>(tBTA_DM_SVC_RES{

                               .bd_addr = bta_dm_discovery_cb.peer_bdaddr,

                               .services = bta_dm_discovery_cb.services_found,

                               .result = BTA_SUCCESS}));

    sdp_state->service_index = BTA_MAX_SERVICE_ID;

    sdp_finished(bd_addr, BTA_SUCCESS, sdp_state->services_found);

    return;

  }
@@ -755,7 +721,8 @@ static void bta_dm_find_services(const RawAddress& bd_addr) { 
      BTA_SdpSearch(bd_addr, Uuid::From16Bit(UUID_SERVCLASS_PBAP_PCE));

    }

  }

  bta_dm_discovery_cb.service_index++;

  // TODO: this change must happen on same sdp_state that's Bound

  sdp_state->service_index++;

}



/*******************************************************************************
@@ -801,9 +768,6 @@ static void bta_dm_discover_services(tBTA_DM_API_DISCOVER& discover) { 
            bt_transport_text(transport));



  bta_dm_discovery_cb.service_search_cbacks = discover.cbacks;

  bta_dm_discovery_cb.services_to_search = BTA_ALL_SERVICE_MASK;

  bta_dm_discovery_cb.service_index = 0;

  bta_dm_discovery_cb.services_found = 0;



  bta_dm_discovery_cb.peer_bdaddr = bd_addr;
@@ -834,7 +798,13 @@ static void bta_dm_discover_services(tBTA_DM_API_DISCOVER& discover) { 
  // transport == BT_TRANSPORT_BR_EDR



  log::info("starting SDP discovery on {}", bd_addr);

  bta_dm_find_services(bd_addr);

  bta_dm_discovery_cb.sdp_state =

      std::make_unique<tBTA_DM_SDP_STATE>(tBTA_DM_SDP_STATE{

          .services_to_search = BTA_ALL_SERVICE_MASK,

          .services_found = 0,

          .service_index = 0,

      });

  bta_dm_find_services(bd_addr, bta_dm_discovery_cb.sdp_state.get());

}



#ifndef BTA_DM_GATT_CLOSE_DELAY_TOUT
@@ -892,8 +862,7 @@ static void gatt_close_timer_cb(void*) { 
 *

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

static void bta_dm_gatt_disc_complete(uint16_t conn_id, tGATT_STATUS status) {

  log::verbose("conn_id = {},  service found: 0x{:08x}", conn_id,

               bta_dm_discovery_cb.services_found);

  log::verbose("conn_id = {}", conn_id);



  std::vector<Uuid> gatt_services;
@@ -920,7 +889,6 @@ static void bta_dm_gatt_disc_complete(uint16_t conn_id, tGATT_STATUS status) { 
      BTA_DM_DISCOVERY_RESULT_EVT,

      std::make_unique<tBTA_DM_MSG>(tBTA_DM_SVC_RES{

          .bd_addr = bta_dm_discovery_cb.peer_bdaddr,

          .services = bta_dm_discovery_cb.services_found,

          .is_gatt_over_ble = true,

          .gatt_uuids = std::move(gatt_services),

          .result = (status == GATT_SUCCESS) ? BTA_SUCCESS : BTA_FAILURE}));
@@ -1116,8 +1084,8 @@ tBT_TRANSPORT bta_dm_determine_discovery_transport(const RawAddress& bd_addr) { 
  return ::bta_dm_determine_discovery_transport(bd_addr);

}



void bta_dm_sdp_result(tSDP_STATUS sdp_status) {

  ::bta_dm_sdp_result(sdp_status);

void bta_dm_sdp_result(tSDP_STATUS sdp_status, tBTA_DM_SDP_STATE* state) {

  ::bta_dm_sdp_result(sdp_status, state);

}



}  // namespace testing
@@ -1291,8 +1259,9 @@ tBTA_DM_SERVICE_DISCOVERY_CB& bta_dm_discovery_cb() { 
  return ::bta_dm_discovery_cb;

}



void bta_dm_find_services(const RawAddress& bd_addr) {

  ::bta_dm_find_services(bd_addr);

void bta_dm_find_services(const RawAddress& bd_addr,

                          tBTA_DM_SDP_STATE* sdp_state) {

  ::bta_dm_find_services(bd_addr, sdp_state);

}



void store_avrcp_profile_feature(tSDP_DISC_REC* sdp_rec) {

system/bta/dm/bta_dm_disc_int.h

+16 −6
Original line number Diff line number Diff line
@@ -81,6 +81,21 @@ inline std::string bta_dm_state_text( 
  }

}



#define MAX_DISC_RAW_DATA_BUF (4096)



typedef struct {

  tBTA_SERVICE_MASK services_to_search;

  tBTA_SERVICE_MASK services_found;



  uint8_t service_index;

  uint8_t peer_scn;



  std::array<uint8_t, MAX_DISC_RAW_DATA_BUF> g_disc_raw_data_buf;



  /* sdp_db must be together with sdp_db_buffer*/

  uint8_t sdp_db_buffer[BTA_DM_SDP_DB_SIZE];

} tBTA_DM_SDP_STATE;



typedef struct {

  service_discovery_callbacks service_search_cbacks;

  tGATT_IF client_if;
@@ -92,12 +107,7 @@ typedef struct { 
   * BluetoothDevice.fetchUuidsWithSdp(). Responsible for LE GATT Service

   * Discovery and SDP */

  tBTA_DM_SERVICE_DISCOVERY_STATE service_discovery_state;

  tBTA_SERVICE_MASK services_to_search;

  tBTA_SERVICE_MASK services_found;



  tSDP_DISCOVERY_DB* p_sdp_db;

  uint8_t service_index;

  uint8_t peer_scn;

  std::unique_ptr<tBTA_DM_SDP_STATE> sdp_state;



  uint16_t conn_id;

  alarm_t* gatt_close_timer;    /* GATT channel close delay timer */

system/bta/test/bta_disc_test.cc

+9 −2
Original line number Diff line number Diff line
@@ -22,6 +22,7 @@ 
#include "bta/dm/bta_dm_device_search.h"

#include "bta/dm/bta_dm_device_search_int.h"

#include "bta/dm/bta_dm_disc.h"

#include "bta/dm/bta_dm_disc_int.h"

#include "bta/test/bta_test_fixtures.h"

#include "stack/btm/neighbor_inquiry.h"

#include "stack/include/gatt_api.h"
@@ -42,7 +43,7 @@ bool bta_dm_read_remote_device_name(const RawAddress& bd_addr, 
                                    tBT_TRANSPORT transport);

tBTA_DM_SEARCH_CB& bta_dm_disc_search_cb();

void bta_dm_discover_next_device();

void bta_dm_find_services(const RawAddress& bd_addr);

void bta_dm_find_services(const RawAddress& bd_addr, tBTA_DM_SDP_STATE* state);

void bta_dm_inq_cmpl();

void bta_dm_inq_cmpl_cb(void* p_result);

void bta_dm_observe_cmpl_cb(void* p_result);
@@ -111,7 +112,13 @@ TEST_F(BtaInitializedTest, bta_dm_discover_next_device) { 
}



TEST_F(BtaInitializedTest, bta_dm_find_services) {

  bluetooth::legacy::testing::bta_dm_find_services(kRawAddress);

  std::unique_ptr<tBTA_DM_SDP_STATE> state =

      std::make_unique<tBTA_DM_SDP_STATE>(tBTA_DM_SDP_STATE{

          .services_to_search = BTA_ALL_SERVICE_MASK,

          .services_found = 0,

          .service_index = 0,

      });

  bluetooth::legacy::testing::bta_dm_find_services(kRawAddress, state.get());

}



TEST_F(BtaInitializedTest, bta_dm_inq_cmpl) {

system/bta/test/bta_sdp_test.cc

+5 −15
Original line number Diff line number Diff line
@@ -19,7 +19,6 @@ 


#include "bta/dm/bta_dm_disc_int.h"

#include "bta/test/bta_test_fixtures.h"

#include "osi/include/allocator.h"



void BTA_dm_on_hw_on();

void BTA_dm_on_hw_off();
@@ -33,7 +32,7 @@ namespace legacy { 
namespace testing {



tBTA_DM_SERVICE_DISCOVERY_CB& bta_dm_discovery_cb();

void bta_dm_sdp_result(tSDP_STATUS sdp_status);

void bta_dm_sdp_result(tSDP_STATUS sdp_status, tBTA_DM_SDP_STATE* state);



}  // namespace testing

}  // namespace legacy
@@ -51,22 +50,13 @@ class BtaSdpRegisteredTest : public BtaSdpTest { 
  void SetUp() override { BtaSdpTest::SetUp(); }



  void TearDown() override { BtaSdpTest::TearDown(); }



  tBTA_SYS_REG bta_sys_reg = {

      .evt_hdlr = [](const BT_HDR_RIGID* p_msg) -> bool {

        osi_free((void*)p_msg);

        return false;

      },

      .disable = []() {},

  };

};



TEST_F(BtaSdpTest, nop) {}



TEST_F(BtaSdpRegisteredTest, bta_dm_sdp_result_SDP_SUCCESS) {

  tBTA_DM_SERVICE_DISCOVERY_CB& discovery_cb =

      bluetooth::legacy::testing::bta_dm_discovery_cb();

  discovery_cb.service_index = BTA_MAX_SERVICE_ID;



  bluetooth::legacy::testing::bta_dm_sdp_result(SDP_SUCCESS);

  std::unique_ptr<tBTA_DM_SDP_STATE> state =

      std::make_unique<tBTA_DM_SDP_STATE>(

          tBTA_DM_SDP_STATE{.service_index = BTA_MAX_SERVICE_ID});

  bluetooth::legacy::testing::bta_dm_sdp_result(SDP_SUCCESS, state.get());

}