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

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

bta_dm_disc: move SDP related code to bta_dm_disc_sdp.cc 

Bug: 340188796
Test: mma -j68
Flag: exempt, trivial
Change-Id: I6a1da0c210d7caa2f0de966f036bfb5f69934813
parent 24969a81

system/bta/Android.bp

+1 −0
Original line number Diff line number Diff line
@@ -42,6 +42,7 @@ filegroup { 
        "dm/bta_dm_device_search.cc",

        "dm/bta_dm_disc.cc",

        "dm/bta_dm_disc_legacy.cc",

        "dm/bta_dm_disc_sdp.cc",

        "dm/bta_dm_gatt_client.cc",

        "dm/bta_dm_main.cc",

        "dm/bta_dm_pm.cc",

system/bta/BUILD.gn

+1 −0
Original line number Diff line number Diff line
@@ -46,6 +46,7 @@ static_library("bta") { 
    "dm/bta_dm_device_search.cc",

    "dm/bta_dm_disc.cc",

    "dm/bta_dm_disc_legacy.cc",

    "dm/bta_dm_disc_sdp.cc",

    "dm/bta_dm_gatt_client.cc",

    "dm/bta_dm_main.cc",

    "dm/bta_dm_pm.cc",

system/bta/dm/bta_dm_disc.cc

+7 −357
Original line number Diff line number Diff line
@@ -32,8 +32,6 @@ 
#include "bta/dm/bta_dm_disc_int.h"

#include "bta/dm/bta_dm_disc_legacy.h"

#include "bta/include/bta_gatt_api.h"

#include "bta/include/bta_sdp_api.h"

#include "btif/include/btif_config.h"

#include "com_android_bluetooth_flags.h"

#include "common/circular_buffer.h"

#include "common/init_flags.h"
@@ -51,14 +49,10 @@ 
#include "stack/include/hidh_api.h"

#include "stack/include/main_thread.h"

#include "stack/include/sdp_status.h"

#include "stack/sdp/sdpint.h"  // is_sdp_pbap_pce_disabled

#include "storage/config_keys.h"

#include "types/raw_address.h"



#ifdef TARGET_FLOSS

#include "stack/include/srvc_api.h"

void bta_dm_sdp_received_di(const RawAddress& bd_addr,

                            tSDP_DI_GET_RECORD& di_record);

#endif



using bluetooth::Uuid;
@@ -83,9 +77,6 @@ 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(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);
@@ -233,39 +224,6 @@ void bta_dm_disc_gattc_register() { 
  bta_dm_gattc_register();

}



const uint16_t bta_service_id_to_uuid_lkup_tbl[BTA_MAX_SERVICE_ID] = {

    UUID_SERVCLASS_PNP_INFORMATION,       /* Reserved */

    UUID_SERVCLASS_SERIAL_PORT,           /* BTA_SPP_SERVICE_ID */

    UUID_SERVCLASS_DIALUP_NETWORKING,     /* BTA_DUN_SERVICE_ID */

    UUID_SERVCLASS_AUDIO_SOURCE,          /* BTA_A2DP_SOURCE_SERVICE_ID */

    UUID_SERVCLASS_LAN_ACCESS_USING_PPP,  /* BTA_LAP_SERVICE_ID */

    UUID_SERVCLASS_HEADSET,               /* BTA_HSP_HS_SERVICE_ID */

    UUID_SERVCLASS_HF_HANDSFREE,          /* BTA_HFP_HS_SERVICE_ID */

    UUID_SERVCLASS_OBEX_OBJECT_PUSH,      /* BTA_OPP_SERVICE_ID */

    UUID_SERVCLASS_OBEX_FILE_TRANSFER,    /* BTA_FTP_SERVICE_ID */

    UUID_SERVCLASS_CORDLESS_TELEPHONY,    /* BTA_CTP_SERVICE_ID */

    UUID_SERVCLASS_INTERCOM,              /* BTA_ICP_SERVICE_ID */

    UUID_SERVCLASS_IRMC_SYNC,             /* BTA_SYNC_SERVICE_ID */

    UUID_SERVCLASS_DIRECT_PRINTING,       /* BTA_BPP_SERVICE_ID */

    UUID_SERVCLASS_IMAGING_RESPONDER,     /* BTA_BIP_SERVICE_ID */

    UUID_SERVCLASS_PANU,                  /* BTA_PANU_SERVICE_ID */

    UUID_SERVCLASS_NAP,                   /* BTA_NAP_SERVICE_ID */

    UUID_SERVCLASS_GN,                    /* BTA_GN_SERVICE_ID */

    UUID_SERVCLASS_SAP,                   /* BTA_SAP_SERVICE_ID */

    UUID_SERVCLASS_AUDIO_SINK,            /* BTA_A2DP_SERVICE_ID */

    UUID_SERVCLASS_AV_REMOTE_CONTROL,     /* BTA_AVRCP_SERVICE_ID */

    UUID_SERVCLASS_HUMAN_INTERFACE,       /* BTA_HID_SERVICE_ID */

    UUID_SERVCLASS_VIDEO_SINK,            /* BTA_VDP_SERVICE_ID */

    UUID_SERVCLASS_PBAP_PSE,              /* BTA_PBAP_SERVICE_ID */

    UUID_SERVCLASS_HEADSET_AUDIO_GATEWAY, /* BTA_HSP_SERVICE_ID */

    UUID_SERVCLASS_AG_HANDSFREE,          /* BTA_HFP_SERVICE_ID */

    UUID_SERVCLASS_MESSAGE_ACCESS,        /* BTA_MAP_SERVICE_ID */

    UUID_SERVCLASS_MESSAGE_NOTIFICATION,  /* BTA_MN_SERVICE_ID */

    UUID_SERVCLASS_HDP_PROFILE,           /* BTA_HDP_SERVICE_ID */

    UUID_SERVCLASS_PBAP_PCE,              /* BTA_PCE_SERVICE_ID */

    UUID_PROTOCOL_ATT                     /* BTA_GATT_SERVICE_ID */

};



static void bta_dm_discovery_set_state(tBTA_DM_SERVICE_DISCOVERY_STATE state) {

  bta_dm_discovery_cb.service_discovery_state = state;

}
@@ -301,81 +259,10 @@ static void bta_dm_disable_disc(void) { 
  }

}



static void store_avrcp_profile_feature(tSDP_DISC_REC* sdp_rec) {

  tSDP_DISC_ATTR* p_attr =

      get_legacy_stack_sdp_api()->record.SDP_FindAttributeInRec(

          sdp_rec, ATTR_ID_SUPPORTED_FEATURES);

  if (p_attr == NULL) {

    return;

  }



  uint16_t avrcp_features = p_attr->attr_value.v.u16;

  if (avrcp_features == 0) {

    return;

  }



  if (btif_config_set_bin(sdp_rec->remote_bd_addr.ToString().c_str(),

                          BTIF_STORAGE_KEY_AV_REM_CTRL_FEATURES,

                          (const uint8_t*)&avrcp_features,

                          sizeof(avrcp_features))) {

    log::info("Saving avrcp_features: 0x{:x}", avrcp_features);

  } else {

    log::info("Failed to store avrcp_features 0x{:x} for {}", avrcp_features,

              sdp_rec->remote_bd_addr);

  }

}



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;

    const char* profile_key;

    void (*store_audio_profile_feature)(tSDP_DISC_REC*);

  };



  std::array<AudioProfile, 1> audio_profiles = {{

      {

          .servclass_uuid = UUID_SERVCLASS_AV_REMOTE_CONTROL,

          .btprofile_uuid = UUID_SERVCLASS_AV_REMOTE_CONTROL,

          .profile_key = BTIF_STORAGE_KEY_AVRCP_CONTROLLER_VERSION,

          .store_audio_profile_feature = store_avrcp_profile_feature,

      },

  }};



  for (const auto& audio_profile : audio_profiles) {

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

        p_sdp_db, audio_profile.servclass_uuid, NULL);

    if (sdp_rec == NULL) continue;



    if (get_legacy_stack_sdp_api()->record.SDP_FindAttributeInRec(

            sdp_rec, ATTR_ID_BT_PROFILE_DESC_LIST) == NULL)

      continue;



    uint16_t profile_version = 0;

    /* get profile version (if failure, version parameter is not updated) */

    if (!get_legacy_stack_sdp_api()->record.SDP_FindProfileVersionInRec(

            sdp_rec, audio_profile.btprofile_uuid, &profile_version)) {

      log::warn("Unable to find SDP profile version in record peer:{}",

                sdp_rec->remote_bd_addr);

    }

    if (profile_version != 0) {

      if (btif_config_set_bin(sdp_rec->remote_bd_addr.ToString().c_str(),

                              audio_profile.profile_key,

                              (const uint8_t*)&profile_version,

                              sizeof(profile_version))) {

      } else {

        log::info("Failed to store peer profile version for {}",

                  sdp_rec->remote_bd_addr);

      }

    }

    audio_profile.store_audio_profile_feature(sdp_rec);

  }

}



void sdp_finished(RawAddress bda, tBTA_STATUS result,

void bta_dm_sdp_finished(RawAddress bda, tBTA_STATUS result,

                         tBTA_SERVICE_MASK services,

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

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

                         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,
@@ -386,11 +273,8 @@ void sdp_finished(RawAddress bda, tBTA_STATUS 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 */,

void bta_dm_sdp_callback(const RawAddress& /* bd_addr */,

                         tSDP_STATUS sdp_status) {

  log::info("{}", bta_dm_state_text(bta_dm_discovery_get_state()));
@@ -403,157 +287,6 @@ static void bta_dm_sdp_callback(const RawAddress& /* bd_addr */, 
                                   bta_dm_discovery_cb.sdp_state.get()));

}



/* Process the discovery result from sdp */

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 (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)) {

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

          scn_found = true;

        }

      } else {

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

        p_sdp_rec = get_legacy_stack_sdp_api()->db.SDP_FindServiceInDb(

            p_sdp_db, service, p_sdp_rec);

      }

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

       * service UUID */

      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(

              p_sdp_db, 0, p_sdp_rec);

          if (p_sdp_rec) {

            Uuid service_uuid;

            if (get_legacy_stack_sdp_api()->record.SDP_FindServiceUUIDInRec(

                    p_sdp_rec, &service_uuid)) {

              gatt_uuids.push_back(service_uuid);

            }

          }

        } while (p_sdp_rec);



        if (!gatt_uuids.empty()) {

          log::info("GATT services discovered using SDP");

        }

      } else {

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

          sdp_state->services_found |=

              (tBTA_SERVICE_MASK)(BTA_SERVICE_ID_TO_SERVICE_MASK(

                  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 (sdp_state->services_to_search == 0) {

        sdp_state->service_index++;

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

        break;



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



    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(

          p_sdp_db, p_sdp_rec);

      if (p_sdp_rec) {

        // SDP_FindServiceUUIDInRec_128bit is used only once, refactor?

        Uuid temp_uuid;

        if (get_legacy_stack_sdp_api()->record.SDP_FindServiceUUIDInRec_128bit(

                p_sdp_rec, &temp_uuid)) {

          uuid_list.push_back(temp_uuid);

        }

      }

    } while (p_sdp_rec);



    if (bluetooth::common::init_flags::

            dynamic_avrcp_version_enhancement_is_enabled() &&

        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, p_sdp_db) == SDP_SUCCESS) {

      bta_dm_sdp_received_di(sdp_state->bd_addr, di_record);

    }

#endif



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

    if (sdp_state->services_to_search) {

      bta_dm_find_services(sdp_state);

      return;

    }



    /* callbacks */

    /* start next bd_addr if necessary */

    BTM_LogHistory(kBtmLogTag, sdp_state->bd_addr, "Discovery completed",

                   base::StringPrintf(

                       "Result:%s services_found:0x%x service_index:0x%d",

                       sdp_result_text(sdp_result).c_str(),

                       sdp_state->services_found, sdp_state->service_index));



    // Copy the raw_data to the discovery result structure

    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{}",

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



      p_sdp_db->raw_data =

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

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

    }



    tBTA_STATUS result = BTA_SUCCESS;

    auto services = sdp_state->services_found;

    // Piggy back the SCN over result field

    if (scn_found) {

      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={}",

                   sdp_state->peer_scn);

    }



    sdp_finished(sdp_state->bd_addr, result, services, uuid_list, gatt_uuids);

  } else {

    BTM_LogHistory(

        kBtmLogTag, sdp_state->bd_addr, "Discovery failed",

        base::StringPrintf("Result:%s", sdp_result_text(sdp_result).c_str()));

    log::error("SDP connection failed {}", sdp_status_text(sdp_result));



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

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

  }

}



/** Callback of peer's DIS reply. This is only called for floss */

#if TARGET_FLOSS

void bta_dm_sdp_received_di(const RawAddress& bd_addr,
@@ -653,81 +386,6 @@ static void bta_dm_execute_queued_discovery_request() { 
      std::make_unique<tBTA_DM_MSG>(tBTA_DM_API_DISCOVER{pending_discovery}));

}



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

 *

 * Function         bta_dm_find_services

 *

 * Description      Starts discovery on a device

 *

 * Returns          void

 *

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

static void bta_dm_find_services(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(

            sdp_state->service_index))) {

      break;

    }

    sdp_state->service_index++;

  }



  /* no more services to be discovered */

  if (sdp_state->service_index >= BTA_MAX_SERVICE_ID) {

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

    sdp_finished(sdp_state->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}", sdp_state->services_to_search);

  Uuid uuid = Uuid::kEmpty;

  if (sdp_state->services_to_search & BTA_RES_SERVICE_MASK) {

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

    sdp_state->services_to_search &= ~BTA_RES_SERVICE_MASK;

  } else {

    uuid = Uuid::From16Bit(UUID_PROTOCOL_L2CAP);

    sdp_state->services_to_search = 0;

  }



  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(

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

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

              sdp_state->bd_addr);

  }



  sdp_state->g_disc_raw_data_buf = {};

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



  p_sdp_db->raw_size = MAX_DISC_RAW_DATA_BUF;



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

          sdp_state->bd_addr, p_sdp_db, &bta_dm_sdp_callback)) {

    /*

     * If discovery is not successful with this device, then

     * proceed with the next one.

     */

    log::warn("Unable to start SDP service search attribute request peer:{}",

              sdp_state->bd_addr);



    sdp_state->service_index = BTA_MAX_SERVICE_ID;

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

    return;

  }



  if (uuid == Uuid::From16Bit(UUID_PROTOCOL_L2CAP)) {

    if (!is_sdp_pbap_pce_disabled(sdp_state->bd_addr)) {

      log::debug("SDP search for PBAP Client");

      BTA_SdpSearch(sdp_state->bd_addr,

                    Uuid::From16Bit(UUID_SERVCLASS_PBAP_PCE));

    }

  }

  sdp_state->service_index++;

}



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

 *

 * Function         bta_dm_determine_discovery_transport
@@ -808,7 +466,7 @@ static void bta_dm_discover_services(tBTA_DM_API_DISCOVER& discover) { 
          .services_found = 0,

          .service_index = 0,

      });

  bta_dm_find_services(bta_dm_discovery_cb.sdp_state.get());

  bta_dm_sdp_find_services(bta_dm_discovery_cb.sdp_state.get());

}



#ifndef BTA_DM_GATT_CLOSE_DELAY_TOUT
@@ -1263,14 +921,6 @@ tBTA_DM_SERVICE_DISCOVERY_CB& bta_dm_discovery_cb() { 
  return ::bta_dm_discovery_cb;

}



void bta_dm_find_services(tBTA_DM_SDP_STATE* sdp_state) {

  ::bta_dm_find_services(sdp_state);

}



void store_avrcp_profile_feature(tSDP_DISC_REC* sdp_rec) {

  ::store_avrcp_profile_feature(sdp_rec);

}



}  // namespace testing

}  // namespace legacy

}  // namespace bluetooth

system/bta/dm/bta_dm_disc_int.h

+13 −0
Original line number Diff line number Diff line
@@ -118,6 +118,19 @@ typedef struct { 
extern const uint32_t bta_service_id_to_btm_srv_id_lkup_tbl[];

extern const uint16_t bta_service_id_to_uuid_lkup_tbl[];



void bta_dm_sdp_find_services(tBTA_DM_SDP_STATE* sdp_state);

void bta_dm_sdp_result(tSDP_STATUS sdp_result, tBTA_DM_SDP_STATE* sdp_state);

void bta_dm_sdp_finished(RawAddress bda, tBTA_STATUS result,

                         tBTA_SERVICE_MASK services,

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

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

void bta_dm_sdp_callback(const RawAddress& bd_addr, tSDP_STATUS sdp_status);



#ifdef TARGET_FLOSS

void bta_dm_sdp_received_di(const RawAddress& bd_addr,

                            tSDP_DI_GET_RECORD& di_record);

#endif



namespace fmt {

template <>

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

system/bta/dm/bta_dm_disc_sdp.cc

0 → 100644
+403 −0

File added.

Preview size limit exceeded, changes collapsed.