bta/dm/bta_dm_int.h

   1 /******************************************************************************
   2  *
   3  *  Copyright 2003-2012 Broadcom Corporation
   4  *
   5  *  Licensed under the Apache License, Version 2.0 (the "License");
   6  *  you may not use this file except in compliance with the License.
   7  *  You may obtain a copy of the License at:
   8  *
   9  *  http://www.apache.org/licenses/LICENSE-2.0
  10  *
  11  *  Unless required by applicable law or agreed to in writing, software
  12  *  distributed under the License is distributed on an "AS IS" BASIS,
  13  *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14  *  See the License for the specific language governing permissions and
  15  *  limitations under the License.
  16  *
  17  ******************************************************************************/
  18
  19 /******************************************************************************
  20  *
  21  *  This is the private interface file for the BTA device manager.
  22  *
  23  ******************************************************************************/
  24 #ifndef BTA_DM_INT_H
  25 #define BTA_DM_INT_H
  26
  27 #include <base/strings/stringprintf.h>
  28 #include <memory>
  29 #include <string>
  30 #include "bt_target.h"
  31 #include "bta/include/bta_gatt_api.h"
  32 #include "bta/sys/bta_sys.h"
  33 #include "main/shim/dumpsys.h"
  34
  35 #ifndef CASE_RETURN_TEXT
  36 #define CASE_RETURN_TEXT(code) \
  37   case code:                   \
  38     return #code
  39 #endif
  40
  41 /*****************************************************************************
  42  *  Constants and data types
  43  ****************************************************************************/
  44
  45 #define BTA_COPY_DEVICE_CLASS(coddst, codsrc)          \
  46   {                                                    \
  47     ((uint8_t*)(coddst))[0] = ((uint8_t*)(codsrc))[0]; \
  48     ((uint8_t*)(coddst))[1] = ((uint8_t*)(codsrc))[1]; \
  49     ((uint8_t*)(coddst))[2] = ((uint8_t*)(codsrc))[2]; \
  50   }
  51
  52 #define BTA_DM_MSG_LEN 50
  53
  54 #define BTA_SERVICE_ID_TO_SERVICE_MASK(id) (1 << (id))
  55
  56 /* DM search events */
  57 enum {
  58   /* DM search API events */
  59   BTA_DM_API_SEARCH_EVT = BTA_SYS_EVT_START(BTA_ID_DM_SEARCH),
  60   BTA_DM_API_DISCOVER_EVT,
  61   BTA_DM_INQUIRY_CMPL_EVT,
  62   BTA_DM_REMT_NAME_EVT,
  63   BTA_DM_SDP_RESULT_EVT,
  64   BTA_DM_SEARCH_CMPL_EVT,
  65   BTA_DM_DISCOVERY_RESULT_EVT,
  66   BTA_DM_DISC_CLOSE_TOUT_EVT
  67 };
  68
  69 /* data type for BTA_DM_API_SEARCH_EVT */
  70 typedef struct {
  71   BT_HDR hdr;
  72   tBTA_SERVICE_MASK services;
  73   tBTA_DM_SEARCH_CBACK* p_cback;
  74 } tBTA_DM_API_SEARCH;
  75
  76 /* data type for BTA_DM_API_DISCOVER_EVT */
  77 typedef struct {
  78   BT_HDR hdr;
  79   RawAddress bd_addr;
  80   tBTA_DM_SEARCH_CBACK* p_cback;
  81   tBT_TRANSPORT transport;
  82 } tBTA_DM_API_DISCOVER;
  83
  84 typedef struct {
  85   RawAddress bd_addr;
  86   bool accept;
  87   uint8_t pin_len;
  88   uint8_t p_pin[PIN_CODE_LEN];
  89 } tBTA_DM_API_PIN_REPLY;
  90
  91 typedef struct {
  92   BT_HDR hdr;
  93   RawAddress bd_addr;
  94   tBTM_IO_CAP io_cap;
  95   tBTM_OOB_DATA oob_data;
  96   tBTM_AUTH_REQ auth_req;
  97 } tBTA_DM_CI_IO_REQ;
  98
  99 typedef struct {
 100   RawAddress bd_addr;
 101   Octet16 c;
 102   Octet16 r;
 103   bool accept;
 104 } tBTA_DM_CI_RMT_OOB;
 105
 106 /* data type for BTA_DM_REMT_NAME_EVT */
 107 typedef struct {
 108   BT_HDR hdr;
 109   tBTA_DM_SEARCH result;
 110 } tBTA_DM_REM_NAME;
 111
 112 /* data type for tBTA_DM_DISC_RESULT */
 113 typedef struct {
 114   BT_HDR hdr;
 115   tBTA_DM_SEARCH result;
 116 } tBTA_DM_DISC_RESULT;
 117
 118 /* data type for BTA_DM_INQUIRY_CMPL_EVT */
 119 typedef struct {
 120   BT_HDR hdr;
 121   uint8_t num;
 122 } tBTA_DM_INQUIRY_CMPL;
 123
 124 /* data type for BTA_DM_SDP_RESULT_EVT */
 125 typedef struct {
 126   BT_HDR hdr;
 127   uint16_t sdp_result;
 128 } tBTA_DM_SDP_RESULT;
 129
 130 typedef struct {
 131   RawAddress bd_addr;
 132   DEV_CLASS dc;
 133   LinkKey link_key;
 134   uint8_t key_type;
 135   bool link_key_known;
 136   bool dc_known;
 137   BD_NAME bd_name;
 138   uint8_t pin_length;
 139 } tBTA_DM_API_ADD_DEVICE;
 140
 141 typedef struct {
 142   BT_HDR hdr;
 143   bool enable;
 144 } tBTA_DM_API_BLE_FEATURE;
 145
 146 /* union of all data types */
 147 typedef union {
 148   /* GKI event buffer header */
 149   BT_HDR hdr;
 150
 151   tBTA_DM_API_SEARCH search;
 152
 153   tBTA_DM_API_DISCOVER discover;
 154
 155   tBTA_DM_REM_NAME rem_name;
 156
 157   tBTA_DM_DISC_RESULT disc_result;
 158
 159   tBTA_DM_INQUIRY_CMPL inq_cmpl;
 160
 161   tBTA_DM_SDP_RESULT sdp_event;
 162
 163 } tBTA_DM_MSG;
 164
 165 #define BTA_DM_NUM_PEER_DEVICE 7
 166
 167 typedef enum : uint8_t {
 168   BTA_DM_NOT_CONNECTED = 0,
 169   BTA_DM_CONNECTED = 1,
 170   BTA_DM_UNPAIRING = 2,
 171 } tBTA_DM_CONN_STATE;
 172
 173 inline std::string bta_conn_state_text(tBTA_DM_CONN_STATE state) {
 174   switch (state) {
 175     CASE_RETURN_TEXT(BTA_DM_NOT_CONNECTED);
 176     CASE_RETURN_TEXT(BTA_DM_CONNECTED);
 177     CASE_RETURN_TEXT(BTA_DM_UNPAIRING);
 178     default:
 179       return std::string("UNKNOWN");
 180   }
 181 }
 182
 183 typedef enum : uint8_t {
 184   BTA_DM_DI_NONE = 0x00,      /* nothing special */
 185   BTA_DM_DI_SET_SNIFF = 0x01, /* set this bit if call BTM_SetPowerMode(sniff) */
 186   BTA_DM_DI_INT_SNIFF = 0x02, /* set this bit if call BTM_SetPowerMode(sniff) &
 187                                  enter sniff mode */
 188   BTA_DM_DI_ACP_SNIFF = 0x04, /* set this bit if peer init sniff */
 189   BTA_DM_DI_UNUSED = 0x08,
 190   BTA_DM_DI_USE_SSR = 0x10, /* set this bit if ssr is supported for this link */
 191   BTA_DM_DI_AV_ACTIVE = 0x20, /* set this bit if AV is active for this link */
 192 } tBTA_DM_DEV_INFO_BITMASK;
 193 typedef uint8_t tBTA_DM_DEV_INFO;
 194
 195 inline std::string device_info_text(tBTA_DM_DEV_INFO info) {
 196   const char* const device_info_text[] = {
 197       ":set_sniff", ":int_sniff", ":acp_sniff",
 198       ":unused",    ":use_ssr",   ":av_active",
 199   };
 200
 201   std::string s = base::StringPrintf("0x%02x", info);
 202   if (info == BTA_DM_DI_NONE) return s + std::string(":none");
 203   for (size_t i = 0; i < sizeof(device_info_text) / sizeof(device_info_text[0]);
 204        i++) {
 205     if (info & (1u << i)) s += std::string(device_info_text[i]);
 206   }
 207   return s;
 208 }
 209
 210 /* set power mode request type */
 211 #define BTA_DM_PM_RESTART 1
 212 #define BTA_DM_PM_NEW_REQ 2
 213 #define BTA_DM_PM_EXECUTE 3
 214 typedef uint8_t tBTA_DM_PM_REQ;
 215
 216 struct sBTA_DM_PEER_DEVICE {
 217   RawAddress peer_bdaddr;
 218   tBTA_DM_CONN_STATE conn_state;
 219   tBTA_PREF_ROLES pref_role;
 220   bool in_use;
 221
 222  private:
 223   friend void bta_dm_acl_up(const RawAddress& bd_addr, tBT_TRANSPORT transport);
 224   friend void bta_dm_pm_btm_status(const RawAddress& bd_addr,
 225                                    tBTM_PM_STATUS status, uint16_t value,
 226                                    tHCI_STATUS hci_status);
 227   friend void bta_dm_pm_sniff(struct sBTA_DM_PEER_DEVICE* p_peer_dev,
 228                               uint8_t index);
 229   friend void bta_dm_rm_cback(tBTA_SYS_CONN_STATUS status, uint8_t id,
 230                               uint8_t app_id, const RawAddress& peer_addr);
 231   friend void handle_remote_features_complete(const RawAddress& bd_addr);
 232   tBTA_DM_DEV_INFO info;
 233
 234  public:
 235   tBTA_DM_DEV_INFO Info() const { return info; }
 236
 237   tBTA_DM_ENCRYPT_CBACK* p_encrypt_cback;
 238   tBTM_PM_STATUS prev_low; /* previous low power mode used */
 239   tBTA_DM_PM_ACTION pm_mode_attempted;
 240   tBTA_DM_PM_ACTION pm_mode_failed;
 241   bool remove_dev_pending;
 242   tBT_TRANSPORT transport;
 243 };
 244 typedef struct sBTA_DM_PEER_DEVICE tBTA_DM_PEER_DEVICE;
 245
 246 /* structure to store list of
 247   active connections */
 248 typedef struct {
 249   tBTA_DM_PEER_DEVICE peer_device[BTA_DM_NUM_PEER_DEVICE];
 250   uint8_t count;
 251   uint8_t le_count;
 252 } tBTA_DM_ACTIVE_LINK;
 253
 254 typedef struct {
 255   RawAddress peer_bdaddr;
 256   tBTA_SYS_ID id;
 257   uint8_t app_id;
 258   tBTA_SYS_CONN_STATUS state;
 259   bool new_request;
 260
 261   std::string ToString() const {
 262     return base::StringPrintf(
 263         "peer:%s sys_name:%s app_id:%hhu state:%s new:request:%s",
 264         PRIVATE_ADDRESS(peer_bdaddr), BtaIdSysText(id).c_str(), app_id,
 265         bta_sys_conn_status_text(state).c_str(), logbool(new_request).c_str());
 266   }
 267
 268 } tBTA_DM_SRVCS;
 269
 270 #ifndef BTA_DM_NUM_CONN_SRVS
 271 #define BTA_DM_NUM_CONN_SRVS 30
 272 #endif
 273
 274 typedef struct {
 275   uint8_t count;
 276   tBTA_DM_SRVCS conn_srvc[BTA_DM_NUM_CONN_SRVS];
 277
 278 } tBTA_DM_CONNECTED_SRVCS;
 279
 280 typedef struct {
 281 #define BTA_DM_PM_SNIFF_TIMER_IDX 0
 282 #define BTA_DM_PM_PARK_TIMER_IDX 1
 283 #define BTA_DM_PM_SUSPEND_TIMER_IDX 2
 284 #define BTA_DM_PM_MODE_TIMER_MAX 3
 285   /*
 286    * Keep three different timers for PARK, SNIFF and SUSPEND if TBFC is
 287    * supported.
 288    */
 289   alarm_t* timer[BTA_DM_PM_MODE_TIMER_MAX];
 290
 291   uint8_t srvc_id[BTA_DM_PM_MODE_TIMER_MAX];
 292   uint8_t pm_action[BTA_DM_PM_MODE_TIMER_MAX];
 293   uint8_t active; /* number of active timer */
 294
 295   RawAddress peer_bdaddr;
 296   bool in_use;
 297 } tBTA_PM_TIMER;
 298
 299 extern tBTA_DM_CONNECTED_SRVCS bta_dm_conn_srvcs;
 300
 301 #define BTA_DM_NUM_PM_TIMER 7
 302
 303 /* DM control block */
 304 typedef struct {
 305   bool is_bta_dm_active;
 306   tBTA_DM_ACTIVE_LINK device_list;
 307   tBTA_DM_SEC_CBACK* p_sec_cback;
 308   tBTA_BLE_ENERGY_INFO_CBACK* p_energy_info_cback;
 309   uint16_t state;
 310   bool disabling;
 311   alarm_t* disable_timer;
 312   uint32_t wbt_sdp_handle; /* WIDCOMM Extensions SDP record handle */
 313   uint8_t wbt_scn;         /* WIDCOMM Extensions SCN */
 314   uint8_t num_central_only;
 315   uint8_t pm_id;
 316   tBTA_PM_TIMER pm_timer[BTA_DM_NUM_PM_TIMER];
 317   uint8_t cur_av_count;   /* current AV connecions */
 318   bool disable_pair_mode; /* disable pair mode or not */
 319   bool conn_paired_only;  /* allow connectable to paired device only or not */
 320   tBTA_DM_API_SEARCH search_msg;
 321
 322   /* Storage for pin code request parameters */
 323   RawAddress pin_bd_addr;
 324   DEV_CLASS pin_dev_class;
 325   tBTA_DM_SEC_EVT pin_evt;
 326   tBTM_IO_CAP loc_io_caps;    /* IO Capabilities of local device */
 327   tBTM_IO_CAP rmt_io_caps;    /* IO Capabilities of remote device */
 328   tBTM_AUTH_REQ loc_auth_req; /* Authentication required for local device */
 329   tBTM_AUTH_REQ rmt_auth_req;
 330   uint32_t num_val; /* the numeric value for comparison. If just_works, do not
 331                        show this number to UI */
 332   bool just_works;  /* true, if "Just Works" association model */
 333 #if (BTA_EIR_CANNED_UUID_LIST != TRUE)
 334   /* store UUID list for EIR */
 335   uint32_t eir_uuid[BTM_EIR_SERVICE_ARRAY_SIZE];
 336 #if (BTA_EIR_SERVER_NUM_CUSTOM_UUID > 0)
 337   tBTA_CUSTOM_UUID bta_custom_uuid[BTA_EIR_SERVER_NUM_CUSTOM_UUID];
 338 #endif
 339
 340 #endif
 341
 342   tBTA_DM_ENCRYPT_CBACK* p_encrypt_cback;
 343   alarm_t* switch_delay_timer;
 344
 345 } tBTA_DM_CB;
 346
 347 /* DM search control block */
 348 typedef struct {
 349   tBTA_DM_SEARCH_CBACK* p_search_cback;
 350   tBTM_INQ_INFO* p_btm_inq_info;
 351   tBTA_SERVICE_MASK services;
 352   tBTA_SERVICE_MASK services_to_search;
 353   tBTA_SERVICE_MASK services_found;
 354   tSDP_DISCOVERY_DB* p_sdp_db;
 355   uint16_t state;
 356   RawAddress peer_bdaddr;
 357   bool name_discover_done;
 358   BD_NAME peer_name;
 359   alarm_t* search_timer;
 360   uint8_t service_index;
 361   tBTA_DM_MSG* p_pending_search;
 362   tBTA_DM_MSG* p_pending_discovery;
 363   bool wait_disc;
 364   bool sdp_results;
 365   bluetooth::Uuid uuid;
 366   uint8_t peer_scn;
 367   tBT_TRANSPORT transport;
 368   tBTA_DM_SEARCH_CBACK* p_scan_cback;
 369   tGATT_IF client_if;
 370   uint8_t uuid_to_search;
 371   bool gatt_disc_active;
 372   uint16_t conn_id;
 373   alarm_t* gatt_close_timer; /* GATT channel close delay timer */
 374   RawAddress pending_close_bda; /* pending GATT channel remote device address */
 375
 376 } tBTA_DM_SEARCH_CB;
 377
 378 /* DI control block */
 379 typedef struct {
 380   uint8_t di_num;                     /* total local DI record number */
 381   uint32_t di_handle[BTA_DI_NUM_MAX]; /* local DI record handle, the first one
 382                                          is primary record */
 383 } tBTA_DM_DI_CB;
 384
 385 /* DM search state */
 386 enum {
 387
 388   BTA_DM_SEARCH_IDLE,
 389   BTA_DM_SEARCH_ACTIVE,
 390   BTA_DM_SEARCH_CANCELLING,
 391   BTA_DM_DISCOVER_ACTIVE
 392
 393 };
 394
 395 typedef struct {
 396   DEV_CLASS dev_class; /* local device class */
 397   uint16_t page_timeout; /* timeout for page in slots */
 398   uint16_t link_timeout; /* link supervision timeout in slots */
 399   bool avoid_scatter; /* true to avoid scatternet when av is streaming (be the
 400                          central) */
 401
 402 } tBTA_DM_CFG;
 403
 404 extern const uint32_t bta_service_id_to_btm_srv_id_lkup_tbl[];
 405
 406 typedef struct {
 407   uint8_t id;
 408   uint8_t app_id;
 409   uint8_t cfg;
 410
 411 } tBTA_DM_RM;
 412
 413 extern const tBTA_DM_CFG* p_bta_dm_cfg;
 414 extern const tBTA_DM_RM* p_bta_dm_rm_cfg;
 415
 416 typedef struct {
 417   uint8_t id;
 418   uint8_t app_id;
 419   uint8_t spec_idx; /* index of spec table to use */
 420
 421 } tBTA_DM_PM_CFG;
 422
 423 typedef struct {
 424   tBTA_DM_PM_ACTION power_mode;
 425   uint16_t timeout;
 426
 427 } tBTA_DM_PM_ACTN;
 428
 429 typedef struct {
 430   uint8_t allow_mask; /* mask of sniff/hold/park modes to allow */
 431   uint8_t ssr; /* set SSR on conn open/unpark */
 432   tBTA_DM_PM_ACTN actn_tbl[BTA_DM_PM_NUM_EVTS][2];
 433
 434 } tBTA_DM_PM_SPEC;
 435
 436 typedef struct {
 437   uint16_t max_lat;
 438   uint16_t min_rmt_to;
 439   uint16_t min_loc_to;
 440   const char* name{nullptr};
 441 } tBTA_DM_SSR_SPEC;
 442
 443 typedef struct {
 444   uint16_t manufacturer;
 445   uint16_t lmp_sub_version;
 446   uint8_t lmp_version;
 447 } tBTA_DM_LMP_VER_INFO;
 448
 449 extern const uint16_t bta_service_id_to_uuid_lkup_tbl[];
 450
 451 extern const tBTA_DM_PM_CFG* p_bta_dm_pm_cfg;
 452 extern const tBTA_DM_PM_SPEC* p_bta_dm_pm_spec;
 453 extern const tBTM_PM_PWR_MD* p_bta_dm_pm_md;
 454 extern tBTA_DM_SSR_SPEC* p_bta_dm_ssr_spec;
 455
 456 /* update dynamic BRCM Aware EIR data */
 457 extern const tBTA_DM_EIR_CONF bta_dm_eir_cfg;
 458 extern const tBTA_DM_EIR_CONF* p_bta_dm_eir_cfg;
 459
 460 /* DM control block */
 461 extern tBTA_DM_CB bta_dm_cb;
 462
 463 /* DM search control block */
 464 extern tBTA_DM_SEARCH_CB bta_dm_search_cb;
 465
 466 /* DI control block */
 467 extern tBTA_DM_DI_CB bta_dm_di_cb;
 468
 469 extern bool bta_dm_search_sm_execute(BT_HDR* p_msg);
 470 extern void bta_dm_search_sm_disable(void);
 471
 472 extern void bta_dm_enable(tBTA_DM_SEC_CBACK*);
 473 extern void bta_dm_disable();
 474 extern void bta_dm_init_cb(void);
 475 extern void bta_dm_set_dev_name(const std::vector<uint8_t>&);
 476 extern void bta_dm_set_visibility(tBTA_DM_DISC, tBTA_DM_CONN);
 477 extern void bta_dm_set_scan_config(tBTA_DM_MSG* p_data);
 478 extern void bta_dm_vendor_spec_command(tBTA_DM_MSG* p_data);
 479 extern void bta_dm_bond(const RawAddress&, tBLE_ADDR_TYPE, tBT_TRANSPORT, int);
 480 extern void bta_dm_bond_cancel(const RawAddress&);
 481 extern void bta_dm_pin_reply(std::unique_ptr<tBTA_DM_API_PIN_REPLY> msg);
 482 extern void bta_dm_add_device(std::unique_ptr<tBTA_DM_API_ADD_DEVICE> msg);
 483 extern void bta_dm_remove_device(const RawAddress& bd_addr);
 484 extern void bta_dm_close_acl(const RawAddress&, bool, tBT_TRANSPORT);
 485
 486 extern void bta_dm_pm_btm_status(const RawAddress&, tBTM_PM_STATUS, uint16_t,
 487                                  tHCI_STATUS);
 488 extern void bta_dm_pm_timer(const RawAddress&, tBTA_DM_PM_ACTION);
 489 extern void bta_dm_add_ampkey(tBTA_DM_MSG* p_data);
 490
 491 extern void bta_dm_add_blekey(const RawAddress& bd_addr,
 492                               tBTA_LE_KEY_VALUE blekey,
 493                               tBTM_LE_KEY_TYPE key_type);
 494 extern void bta_dm_add_ble_device(const RawAddress& bd_addr,
 495                                   tBLE_ADDR_TYPE addr_type,
 496                                   tBT_DEVICE_TYPE dev_type);
 497 extern void bta_dm_ble_passkey_reply(const RawAddress& bd_addr, bool accept,
 498                                      uint32_t passkey);
 499 extern void bta_dm_ble_confirm_reply(const RawAddress&, bool);
 500 extern void bta_dm_ble_set_conn_params(const RawAddress&, uint16_t, uint16_t,
 501                                        uint16_t, uint16_t);
 502 extern void bta_dm_close_gatt_conn(tBTA_DM_MSG* p_data);
 503 extern void bta_dm_ble_observe(bool, uint8_t, tBTA_DM_SEARCH_CBACK*);
 504 extern void bta_dm_ble_update_conn_params(const RawAddress&, uint16_t, uint16_t,
 505                                           uint16_t, uint16_t, uint16_t,
 506                                           uint16_t);
 507 extern void bta_dm_ble_config_local_privacy(bool);
 508
 509 extern void bta_dm_ble_set_data_length(const RawAddress& bd_addr);
 510
 511 extern void bta_dm_ble_get_energy_info(tBTA_BLE_ENERGY_INFO_CBACK*);
 512
 513 extern void bta_dm_set_encryption(const RawAddress&, tBT_TRANSPORT,
 514                                   tBTA_DM_ENCRYPT_CBACK*, tBTM_BLE_SEC_ACT);
 515 extern void bta_dm_confirm(const RawAddress&, bool);
 516
 517 extern void bta_dm_ci_rmt_oob_act(std::unique_ptr<tBTA_DM_CI_RMT_OOB> msg);
 518
 519 extern void bta_dm_init_pm(void);
 520 extern void bta_dm_disable_pm(void);
 521
 522 extern uint8_t bta_dm_get_av_count(void);
 523 extern void bta_dm_search_start(tBTA_DM_MSG* p_data);
 524 extern void bta_dm_search_cancel();
 525 extern void bta_dm_discover(tBTA_DM_MSG* p_data);
 526 extern void bta_dm_inq_cmpl(uint8_t num);
 527 extern void bta_dm_rmt_name(tBTA_DM_MSG* p_data);
 528 extern void bta_dm_sdp_result(tBTA_DM_MSG* p_data);
 529 extern void bta_dm_search_cmpl();
 530 extern void bta_dm_free_sdp_db();
 531 extern void bta_dm_disc_result(tBTA_DM_MSG* p_data);
 532 extern void bta_dm_search_result(tBTA_DM_MSG* p_data);
 533 extern void bta_dm_discovery_cmpl(tBTA_DM_MSG* p_data);
 534 extern void bta_dm_queue_search(tBTA_DM_MSG* p_data);
 535 extern void bta_dm_queue_disc(tBTA_DM_MSG* p_data);
 536 extern void bta_dm_search_clear_queue();
 537 extern void bta_dm_search_cancel_cmpl();
 538 extern void bta_dm_search_cancel_notify();
 539 extern void bta_dm_disc_rmt_name(tBTA_DM_MSG* p_data);
 540 extern tBTA_DM_PEER_DEVICE* bta_dm_find_peer_device(
 541     const RawAddress& peer_addr);
 542
 543 uint8_t bta_dm_search_get_state();
 544 void bta_dm_search_set_state(uint8_t state);
 545
 546 void bta_dm_eir_update_uuid(uint16_t uuid16, bool adding);
 547 void bta_dm_eir_update_cust_uuid(const tBTA_CUSTOM_UUID &curr, bool adding);
 548
 549 #undef CASE_RETURN_TEXT
 550 #endif /* BTA_DM_INT_H */