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

Commit 9bbd89d1 authored by Jakub Pawlowski's avatar Jakub Pawlowski
Browse files

Split service search result from name read result 

Bug: 330675788
Flag: exempt, infrastructure refactor that can't be easily isolated
Test: mma -j32
Change-Id: Ibfc02a25c8af50649984e747171692560a4dc00e
parent a01121f8

system/bta/dm/bta_dm_disc.cc

+47 −83
Original line number Diff line number Diff line
@@ -500,22 +500,10 @@ static void bta_dm_remote_name_cmpl( 
    // It's enough to send callback to just one of them.

    if (bta_dm_search_cb.p_device_search_cback != nullptr) {

      tBTA_DM_SEARCH search_data = {

          .disc_res =  // tBTA_DM_DISC_RES

          {

              .bd_addr = remote_name_msg.bd_addr,

              .bd_name = {},

              .services = {},

              .device_type = {},

              .num_uuids = 0UL,

              .p_uuid_list = nullptr,

              .result = (remote_name_msg.hci_status == HCI_SUCCESS)

                            ? BTA_SUCCESS

                            : BTA_FAILURE,

              .hci_status = remote_name_msg.hci_status,

          },

          .name_res = {.bd_addr = remote_name_msg.bd_addr, .bd_name = {}},

      };

      if (remote_name_msg.hci_status == HCI_SUCCESS) {

        bd_name_copy(search_data.disc_res.bd_name, remote_name_msg.bd_name);

        bd_name_copy(search_data.name_res.bd_name, remote_name_msg.bd_name);

      }

      bta_dm_search_cb.p_device_search_cback(BTA_DM_NAME_READ_EVT,

                                             &search_data);
@@ -763,20 +751,11 @@ static void bta_dm_sdp_result(tBTA_DM_SDP_RESULT& sdp_event) { 
                             bta_dm_search_cb.services_found,

                             bta_dm_search_cb.service_index));



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

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

      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.disc_res.result = BTA_SUCCESS;

      disc_result.result.disc_res.num_uuids = uuid_list.size();

      disc_result.result.disc_res.p_uuid_list = NULL;

      if (uuid_list.size() > 0) {

        // TODO(jpawlowski): make p_uuid_list into vector, and just copy

        // vectors, but first get rid of bta_sys_sendmsg below.

        disc_result.result.disc_res.p_uuid_list =

            (Uuid*)osi_calloc(uuid_list.size() * sizeof(Uuid));

        memcpy(disc_result.result.disc_res.p_uuid_list, uuid_list.data(),

               uuid_list.size() * sizeof(Uuid));

      }

      disc_result.result = BTA_SUCCESS;

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

      // Copy the raw_data to the discovery result structure

      if (bta_dm_search_cb.p_sdp_db != NULL &&

          bta_dm_search_cb.p_sdp_db->raw_used != 0 &&
@@ -794,20 +773,18 @@ static void bta_dm_sdp_result(tBTA_DM_SDP_RESULT& sdp_event) { 
      }

      /* Done with p_sdp_db. Free it */

      bta_dm_free_sdp_db();

      disc_result.result.disc_res.services = bta_dm_search_cb.services_found;

      disc_result.services = bta_dm_search_cb.services_found;



      // Piggy back the SCN over result field

      if (scn_found) {

        disc_result.result.disc_res.result =

        disc_result.result =

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

        disc_result.result.disc_res.services |= BTA_USER_SERVICE_MASK;

        disc_result.services |= BTA_USER_SERVICE_MASK;



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

                     bta_dm_search_cb.peer_scn);

      }

      disc_result.result.disc_res.bd_addr = bta_dm_search_cb.peer_bdaddr;

      bd_name_from_char_pointer(disc_result.result.disc_res.bd_name,

                                bta_dm_get_remname());

      disc_result.bd_addr = bta_dm_search_cb.peer_bdaddr;



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

    }
@@ -826,14 +803,12 @@ static void bta_dm_sdp_result(tBTA_DM_SDP_RESULT& sdp_event) { 
    get_btm_client_interface().security.BTM_SecDeleteRmtNameNotifyCallback(

        &bta_dm_service_search_remname_cback);



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

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

    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.disc_res.result = BTA_FAILURE;

    disc_result.result.disc_res.services = bta_dm_search_cb.services_found;

    disc_result.result.disc_res.bd_addr = bta_dm_search_cb.peer_bdaddr;

    bd_name_from_char_pointer(disc_result.result.disc_res.bd_name,

                              bta_dm_get_remname());

    disc_result.result = BTA_FAILURE;

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

  }
@@ -949,22 +924,20 @@ static void bta_dm_search_cmpl() { 
 * Returns          void

 *

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

static void bta_dm_disc_result(tBTA_DM_DISC_RESULT& disc_result) {

static void bta_dm_disc_result(tBTA_DM_SVC_RES& disc_result) {

  log::verbose("");



  /* disc_res.device_type is set only when GATT discovery is finished in

   * bta_dm_gatt_disc_complete */

  bool is_gatt_over_ble =

      ((disc_result.result.disc_res.device_type & BT_DEVICE_TYPE_BLE) != 0);

  bool is_gatt_over_ble = ((disc_result.device_type & BT_DEVICE_TYPE_BLE) != 0);



  /* if any BR/EDR service discovery has been done, report the event */

  if (!is_gatt_over_ble && (bta_dm_search_cb.services &

                            ((BTA_ALL_SERVICE_MASK | BTA_USER_SERVICE_MASK) &

                             ~BTA_BLE_SERVICE_MASK))) {

    auto& r = disc_result.result.disc_res;

    auto& r = disc_result;

    bta_dm_search_cb.service_search_cbacks.on_service_discovery_results(

        r.bd_addr, r.bd_name, r.services, r.device_type, r.num_uuids,

        r.p_uuid_list, r.result, r.hci_status);

        r.bd_addr, r.services, r.device_type, r.uuids, r.result, r.hci_status);

  }



  get_gatt_interface().BTA_GATTC_CancelOpen(0, bta_dm_search_cb.peer_bdaddr,
@@ -982,19 +955,19 @@ static void bta_dm_disc_result(tBTA_DM_DISC_RESULT& disc_result) { 
 * Returns          void

 *

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

static void bta_dm_search_result(tBTA_DM_DISC_RESULT& disc_result) {

static void bta_dm_search_result(tBTA_DM_SVC_RES& disc_result) {

  log::verbose("searching:0x{:04x}, result:0x{:04x}", bta_dm_search_cb.services,

               disc_result.result.disc_res.services);

               disc_result.services);



  /* call back if application wants name discovery or found services that

   * application is searching */

  if ((!bta_dm_search_cb.services) ||

      ((bta_dm_search_cb.services) && (disc_result.result.disc_res.services))) {

      ((bta_dm_search_cb.services) && (disc_result.services))) {

    if (bta_dm_search_cb.service_search_cbacks.on_service_discovery_results) {

      auto& r = disc_result.result.disc_res;

      auto& r = disc_result;

      bta_dm_search_cb.service_search_cbacks.on_service_discovery_results(

          r.bd_addr, r.bd_name, r.services, r.device_type, r.num_uuids,

          r.p_uuid_list, r.result, r.hci_status);

          r.bd_addr, r.services, r.device_type, r.uuids, r.result,

          r.hci_status);

    } else {

      log::warn("Received search result without valid callback");

    }
@@ -1248,12 +1221,10 @@ static void bta_dm_find_services(const RawAddress& bd_addr) { 


  /* no more services to be discovered */

  if (bta_dm_search_cb.service_index >= BTA_MAX_SERVICE_ID) {

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

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

    disc_result.result.disc_res.services = bta_dm_search_cb.services_found;

    disc_result.result.disc_res.bd_addr = bta_dm_search_cb.peer_bdaddr;

    bd_name_from_char_pointer(disc_result.result.disc_res.bd_name,

                              bta_dm_get_remname());

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

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

    disc_result.services = bta_dm_search_cb.services_found;

    disc_result.bd_addr = bta_dm_search_cb.peer_bdaddr;



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

  }
@@ -1448,15 +1419,13 @@ static void bta_dm_discover_device(const RawAddress& remote_bd_addr) { 
  }



  /* name discovery and service discovery are done for this device */

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

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

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

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



  /* initialize the data structure */

  disc_result.result.disc_res.result = BTA_SUCCESS;

  disc_result.result.disc_res.services = bta_dm_search_cb.services_found;

  disc_result.result.disc_res.bd_addr = bta_dm_search_cb.peer_bdaddr;

  bd_name_from_char_pointer(disc_result.result.disc_res.bd_name,

                            bta_dm_get_remname());

  svc_result.result = BTA_SUCCESS;

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

}
@@ -1896,20 +1865,15 @@ 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 = {}", conn_id);



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

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

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

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



  /* no more services to be discovered */

  disc_result.result.disc_res.result =

      (status == GATT_SUCCESS) ? BTA_SUCCESS : BTA_FAILURE;

  svc_result.result = (status == GATT_SUCCESS) ? BTA_SUCCESS : BTA_FAILURE;

  log::verbose("service found: 0x{:08x}", bta_dm_search_cb.services_found);

  disc_result.result.disc_res.services = bta_dm_search_cb.services_found;

  disc_result.result.disc_res.num_uuids = 0;

  disc_result.result.disc_res.p_uuid_list = NULL;

  disc_result.result.disc_res.bd_addr = bta_dm_search_cb.peer_bdaddr;

  bd_name_from_char_pointer(disc_result.result.disc_res.bd_name,

                            bta_dm_get_remname());

  disc_result.result.disc_res.device_type |= BT_DEVICE_TYPE_BLE;

  svc_result.services = bta_dm_search_cb.services_found;

  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));
@@ -2230,10 +2194,10 @@ static void bta_dm_search_sm_execute(tBTA_DM_EVT event, 
          bta_dm_search_cmpl();

          break;

        case BTA_DM_DISCOVERY_RESULT_EVT:

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

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

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



          bta_dm_search_result(std::get<tBTA_DM_DISC_RESULT>(*msg));

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

          break;

        case BTA_DM_DISC_CLOSE_TOUT_EVT:

          bta_dm_close_gatt_conn();
@@ -2309,10 +2273,10 @@ static void bta_dm_search_sm_execute(tBTA_DM_EVT event, 
          bta_dm_search_cmpl();

          break;

        case BTA_DM_DISCOVERY_RESULT_EVT:

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

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

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



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

          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),
@@ -2464,8 +2428,8 @@ void bta_dm_opportunistic_observe_results_cb(tBTM_INQ_RESULTS* p_inq, 
void bta_dm_queue_search(tBTA_DM_API_SEARCH& search) {

  ::bta_dm_queue_search(search);

}

void bta_dm_search_result(tBTA_DM_DISC_RESULT& disc_result) {

  ::bta_dm_search_result(disc_result);

void bta_dm_search_result(tBTA_DM_SVC_RES& svc_result) {

  ::bta_dm_search_result(svc_result);

}

void bta_dm_search_timer_cback(void* data) {

  ::bta_dm_search_timer_cback(data);

system/bta/dm/bta_dm_disc_int.h

+11 −2
Original line number Diff line number Diff line
@@ -25,7 +25,6 @@ 
#include "bta/sys/bta_sys.h"

#include "macros.h"

#include "stack/btm/neighbor_inquiry.h"

#include "stack/include/bt_hdr.h"

#include "stack/include/sdp_status.h"

#include "stack/sdp/sdp_discovery_db.h"

#include "types/bluetooth/uuid.h"
@@ -104,9 +103,19 @@ typedef struct { 
  bool enable;

} tBTA_DM_API_BLE_FEATURE;



typedef struct {

  RawAddress bd_addr;          /* BD address peer device. */

  tBTA_SERVICE_MASK services;  /* Services found on peer device. */

  tBT_DEVICE_TYPE device_type; /* device type in case it is BLE device */

  std::vector<bluetooth::Uuid> uuids;

  tBTA_STATUS result;

  tHCI_STATUS hci_status;

} tBTA_DM_SVC_RES;



using tBTA_DM_MSG =

    std::variant<tBTA_DM_API_SEARCH, tBTA_DM_API_DISCOVER, tBTA_DM_REMOTE_NAME,

                 tBTA_DM_DISC_RESULT, tBTA_DM_INQUIRY_CMPL, tBTA_DM_SDP_RESULT>;

                 tBTA_DM_DISC_RESULT, tBTA_DM_INQUIRY_CMPL, tBTA_DM_SDP_RESULT,

                 tBTA_DM_SVC_RES>;



/* DM search state */

typedef enum {

system/bta/include/bta_api.h

+6 −13
Original line number Diff line number Diff line
@@ -266,22 +266,16 @@ typedef struct { 
  uint8_t num_resps; /* Number of responses. */

} tBTA_DM_OBSERVE_CMPL;



/* Structure associated with BTA_DM_DISC_RES_EVT */

/* Structure associated with BTA_DM_NAME_READ_EVT */

typedef struct {

  RawAddress bd_addr;          /* BD address peer device. */

  BD_NAME bd_name;             /* Name of peer device. */

  tBTA_SERVICE_MASK services;  /* Services found on peer device. */

  tBT_DEVICE_TYPE device_type; /* device type in case it is BLE device */

  size_t num_uuids;

  bluetooth::Uuid* p_uuid_list;

  tBTA_STATUS result;

  tHCI_STATUS hci_status;

} tBTA_DM_DISC_RES;

} tBTA_DM_NAME_READ_CMPL;



/* Union of all search callback structures */

typedef union {

  tBTA_DM_INQ_RES inq_res;   /* Inquiry result for a peer device. */

  tBTA_DM_DISC_RES disc_res; /* Discovery result for a peer device. */

  tBTA_DM_NAME_READ_CMPL name_res;   /* Name read result for a peer device. */

  tBTA_DM_OBSERVE_CMPL observe_cmpl; /* Observe complete. */

} tBTA_DM_SEARCH;
@@ -298,10 +292,9 @@ typedef void(tBTA_DM_DID_RES_CBACK)(RawAddress bd_addr, uint8_t vendor_id_src, 
typedef void(tBTA_DM_NAME_READ_CBACK)(RawAddress bd_addr,

                                      tHCI_ERROR_CODE hci_status,

                                      const BD_NAME bd_name);

typedef void(tBTA_DM_DISC_CBACK)(RawAddress bd_addr, BD_NAME bd_name,

                                 tBTA_SERVICE_MASK services,

                                 tBT_DEVICE_TYPE device_type, size_t num_uuids,

                                 bluetooth::Uuid* p_uuid_list,

typedef void(tBTA_DM_DISC_CBACK)(RawAddress bd_addr, tBTA_SERVICE_MASK services,

                                 tBT_DEVICE_TYPE device_type,

                                 const std::vector<bluetooth::Uuid>& uuids,

                                 tBTA_STATUS result, tHCI_STATUS hci_status);

struct service_discovery_callbacks {

  /* legacy callback I'll tear apart and get rid of */

system/bta/test/bta_disc_test.cc

+9 −9
Original line number Diff line number Diff line
@@ -52,7 +52,7 @@ void bta_dm_opportunistic_observe_results_cb(tBTM_INQ_RESULTS* p_inq, 
                                             const uint8_t* p_eir,

                                             uint16_t eir_len);

void bta_dm_queue_search(tBTA_DM_API_SEARCH& search);

void bta_dm_search_result(tBTA_DM_DISC_RESULT& p_data);

void bta_dm_search_result(tBTA_DM_SVC_RES& p_data);

void bta_dm_search_timer_cback(void* data);

void bta_dm_service_search_remname_cback(const RawAddress& bd_addr,

                                         DEV_CLASS dc, BD_NAME bd_name);
@@ -166,8 +166,8 @@ TEST_F(BtaInitializedTest, bta_dm_read_remote_device_name) { 
}



TEST_F(BtaInitializedTest, bta_dm_search_result) {

  tBTA_DM_DISC_RESULT disc_result = {};

  bluetooth::legacy::testing::bta_dm_search_result(disc_result);

  tBTA_DM_SVC_RES svc_result = {};

  bluetooth::legacy::testing::bta_dm_search_result(svc_result);

}



TEST_F(BtaInitializedTest, bta_dm_search_timer_cback) {
@@ -222,8 +222,8 @@ TEST_F(BtaInitializedTest, 
       bta_dm_disc_start_service_discovery__BT_TRANSPORT_AUTO) {

  bta_dm_disc_start_service_discovery(

      {nullptr, nullptr, nullptr,

       [](RawAddress, BD_NAME, tBTA_SERVICE_MASK, tBT_DEVICE_TYPE, size_t,

          bluetooth::Uuid*, tBTA_STATUS, tHCI_STATUS) {}},

       [](RawAddress, tBTA_SERVICE_MASK, tBT_DEVICE_TYPE,

          const std::vector<bluetooth::Uuid>&, tBTA_STATUS, tHCI_STATUS) {}},

      kRawAddress, BT_TRANSPORT_AUTO);

}
@@ -231,8 +231,8 @@ TEST_F(BtaInitializedTest, 
       bta_dm_disc_start_service_discovery__BT_TRANSPORT_BR_EDR) {

  bta_dm_disc_start_service_discovery(

      {nullptr, nullptr, nullptr,

       [](RawAddress, BD_NAME, tBTA_SERVICE_MASK, tBT_DEVICE_TYPE, size_t,

          bluetooth::Uuid*, tBTA_STATUS, tHCI_STATUS) {}},

       [](RawAddress, tBTA_SERVICE_MASK, tBT_DEVICE_TYPE,

          const std::vector<bluetooth::Uuid>&, tBTA_STATUS, tHCI_STATUS) {}},

      kRawAddress, BT_TRANSPORT_BR_EDR);

}
@@ -240,8 +240,8 @@ TEST_F(BtaInitializedTest, 
       bta_dm_disc_start_service_discovery__BT_TRANSPORT_LE) {

  bta_dm_disc_start_service_discovery(

      {nullptr, nullptr, nullptr,

       [](RawAddress, BD_NAME, tBTA_SERVICE_MASK, tBT_DEVICE_TYPE, size_t,

          bluetooth::Uuid*, tBTA_STATUS, tHCI_STATUS) {}},

       [](RawAddress, tBTA_SERVICE_MASK, tBT_DEVICE_TYPE,

          const std::vector<bluetooth::Uuid>&, tBTA_STATUS, tHCI_STATUS) {}},

      kRawAddress, BT_TRANSPORT_LE);

}

system/btif/src/btif_dm.cc

+15 −16
Original line number Diff line number Diff line
@@ -1436,16 +1436,16 @@ static void btif_dm_search_devices_evt(tBTA_DM_SEARCH_EVT event, 
  switch (event) {

    case BTA_DM_NAME_READ_EVT: {

      /* Remote name update */

      if (strlen((const char*)p_search_data->disc_res.bd_name)) {

      if (strlen((const char*)p_search_data->name_res.bd_name)) {

        /** Fix inquiry time too long @{ */

        bt_property_t properties[3];

        /** @} */

        bt_status_t status;



        properties[0].type = BT_PROPERTY_BDNAME;

        properties[0].val = p_search_data->disc_res.bd_name;

        properties[0].len = strlen((char*)p_search_data->disc_res.bd_name);

        RawAddress& bdaddr = p_search_data->disc_res.bd_addr;

        properties[0].val = p_search_data->name_res.bd_name;

        properties[0].len = strlen((char*)p_search_data->name_res.bd_name);

        RawAddress& bdaddr = p_search_data->name_res.bd_addr;



        status =

            btif_storage_set_remote_device_property(&bdaddr, &properties[0]);
@@ -1464,7 +1464,7 @@ static void btif_dm_search_devices_evt(tBTA_DM_SEARCH_EVT event, 
          log::info("Skipping RNR callback because cod is zero addr:{} name:{}",

                    ADDRESS_TO_LOGGABLE_CSTR(bdaddr),

                    PRIVATE_NAME(reinterpret_cast<char const*>(

                        p_search_data->disc_res.bd_name)));

                        p_search_data->name_res.bd_name)));

        }

        /** @} */

      }
@@ -1742,9 +1742,9 @@ static bool btif_is_gatt_service_discovery_post_pairing(const RawAddress bd_addr 
}



static void btif_on_service_discovery_results(

    RawAddress bd_addr, BD_NAME bd_name, tBTA_SERVICE_MASK services,

    tBT_DEVICE_TYPE device_type, size_t num_uuids, bluetooth::Uuid* p_uuid_list,

    tBTA_STATUS result, tHCI_STATUS hci_status) {

    RawAddress bd_addr, tBTA_SERVICE_MASK services, tBT_DEVICE_TYPE device_type,

    const std::vector<bluetooth::Uuid>& uuids_param, tBTA_STATUS result,

    tHCI_STATUS hci_status) {

  bt_property_t prop;

  std::vector<uint8_t> property_value;

  std::set<Uuid> uuids;
@@ -1776,15 +1776,14 @@ static void btif_on_service_discovery_results( 


  prop.type = BT_PROPERTY_UUIDS;

  prop.len = 0;

  if ((result == BTA_SUCCESS) && (num_uuids > 0)) {

  if ((result == BTA_SUCCESS) && !uuids_param.empty()) {

    log::info("New UUIDs for {}:", ADDRESS_TO_LOGGABLE_CSTR(bd_addr));

    for (size_t i = 0; i < num_uuids; i++) {

      auto uuid = p_uuid_list + i;

      if (btif_should_ignore_uuid(*uuid)) {

    for (const auto& uuid : uuids_param) {

      if (btif_should_ignore_uuid(uuid)) {

        continue;

      }

      log::info("index:{} uuid:{}", i, uuid->ToString());

      uuids.insert(*uuid);

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

      uuids.insert(uuid);

    }



    Uuid existing_uuids[BT_MAX_NUM_UUIDS] = {};
@@ -1871,9 +1870,9 @@ static void btif_on_service_discovery_results( 
  BTM_LogHistory(kBtmLogTagSdp, bd_addr, "Discovered services",

                 base::StringPrintf("bta_status:%s sdp_uuids:%zu eir_uuids:%zu",

                                    bta_status_text(bta_status).c_str(),

                                    num_uuids, num_eir_uuids));

                                    uuids_param.size(), num_eir_uuids));



  if (num_uuids != 0 || num_eir_uuids != 0) {

  if (!uuids_param.empty() || num_eir_uuids != 0) {

    /* Also write this to the NVRAM */

    const bt_status_t ret =

        btif_storage_set_remote_device_property(&bd_addr, &prop);