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

Commit 55e2aad9 authored by Treehugger Robot's avatar Treehugger Robot Committed by Automerger Merge Worker
Browse files

Merge "Split service search result from name read result" into main am: c4befe7d am: 637a3610 

Original change: https://android-review.googlesource.com/c/platform/packages/modules/Bluetooth/+/3019667



Change-Id: I4754892554a3f3bfd07bb7d22254c5737b856ef5
Signed-off-by: default avatarAutomerger Merge Worker <android-build-automerger-merge-worker@system.gserviceaccount.com>
parents 46c6d32c 637a3610

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
@@ -267,22 +267,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;
@@ -299,10 +293,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);