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

Commit b00828c5 authored by Jakub Pawlowski's avatar Jakub Pawlowski
Browse files

Move SDP related variables out of control block, into separate struct 

This is preparation to move SDP performing code to separate file, where
it can be properly unit tested.

As part of this change, some global static buffers, and memory that was
alloced for keeping SDP database is moved to SDP state struct.

Bug: 330675788
Test: mma -j68
Flag: exempt, trivial
Change-Id: I04fb524396eca2613710195cd6521f9720bde40e
parent a9575989

system/bta/dm/bta_dm_disc.cc

+85 −111
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,8 @@ static void bta_dm_store_audio_profiles_version() { 
  }

}



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



/* Callback from sdp with discovery status */

static void bta_dm_sdp_callback(const RawAddress& /* bd_addr */,
@@ -382,51 +380,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 +438,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 +476,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 +491,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,8 +502,8 @@ 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);
@@ -518,32 +512,27 @@ static void bta_dm_sdp_result(tSDP_STATUS sdp_result) { 
    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;

    disc_result.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.result = static_cast<tBTA_STATUS>((3 + sdp_state->peer_scn));

      disc_result.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;
@@ -555,14 +544,11 @@ 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.services = sdp_state->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));
@@ -630,19 +616,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 +633,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 +656,54 @@ 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,

                               .services = sdp_state->services_found,

                               .result = BTA_SUCCESS}));

    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,12 +711,11 @@ 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;

    sdp_state->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,

                               .services = sdp_state->services_found,

                               .result = BTA_SUCCESS}));

    return;

  }
@@ -755,7 +726,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 +773,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 +803,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 +867,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 +894,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 +1089,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 +1264,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 −6
Original line number Diff line number Diff line
@@ -33,7 +33,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
@@ -64,9 +64,8 @@ class BtaSdpRegisteredTest : public BtaSdpTest { 
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());

}