1 /******************************************************************************
2 *
3 * Copyright 2002-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 #ifndef BTA_HH_API_H
19 #define BTA_HH_API_H
20
21 #include <bluetooth/log.h>
22
23 #include <cstdint>
24 #include <string>
25
26 #include "internal_include/bt_target.h"
27 #include "macros.h"
28 #include "stack/include/bt_hdr.h"
29 #include "stack/include/hiddefs.h"
30 #include "stack/include/l2cap_types.h"
31 #include "types/ble_address_with_type.h"
32 #include "types/bluetooth/uuid.h"
33
34 /*****************************************************************************
35 * Constants and Type Definitions
36 ****************************************************************************/
37 #ifndef BTA_HH_DEBUG
38 #define BTA_HH_DEBUG TRUE
39 #endif
40
41 #ifndef BTA_HH_SSR_MAX_LATENCY_DEF
42 #define BTA_HH_SSR_MAX_LATENCY_DEF 800 /* 500 ms*/
43 #endif
44
45 #ifndef BTA_HH_SSR_MIN_TOUT_DEF
46 #define BTA_HH_SSR_MIN_TOUT_DEF 2
47 #endif
48
49 /* BTA HID Host callback events */
50 #define BTA_HH_EMPTY_EVT 0 /* No op */
51 #define BTA_HH_ENABLE_EVT 1 /* HH enabled */
52 #define BTA_HH_DISABLE_EVT 2 /* HH disabled */
53 #define BTA_HH_OPEN_EVT 3 /* connection opened */
54 #define BTA_HH_CLOSE_EVT 4 /* connection closed */
55 #define BTA_HH_GET_RPT_EVT 5 /* BTA_HhGetReport callback */
56 #define BTA_HH_SET_RPT_EVT 6 /* BTA_HhSetReport callback */
57 #define BTA_HH_GET_PROTO_EVT 7 /* BTA_GetProtoMode callback */
58 #define BTA_HH_SET_PROTO_EVT 8 /* BTA_HhSetProtoMode callback */
59 #define BTA_HH_GET_IDLE_EVT 9 /* BTA_HhGetIdle comes callback */
60 #define BTA_HH_SET_IDLE_EVT 10 /* BTA_HhSetIdle finish callback */
61 #define BTA_HH_GET_DSCP_EVT 11 /* Get report descriptor */
62 #define BTA_HH_ADD_DEV_EVT 12 /* Add Device callback */
63 #define BTA_HH_RMV_DEV_EVT 13 /* remove device finished */
64 #define BTA_HH_VC_UNPLUG_EVT 14 /* virtually unplugged */
65 #define BTA_HH_DATA_EVT 15
66 #define BTA_HH_API_ERR_EVT 16 /* API error is caught */
67 #define BTA_HH_UPDATE_SCPP_EVT 17 /* update scan paramter complete */
68
69 typedef uint16_t tBTA_HH_EVT;
70
71 /* application ID(none-zero) for each type of device */
72 #define BTA_HH_APP_ID_MI 1
73 #define BTA_HH_APP_ID_KB 2
74 #define BTA_HH_APP_ID_RMC 3
75 #define BTA_HH_APP_ID_3DSG 4
76 #define BTA_HH_APP_ID_JOY 5
77 #define BTA_HH_APP_ID_GPAD 6
78 #define BTA_HH_APP_ID_LE 0xff
79
80 /* defined the minimum offset */
81 #define BTA_HH_MIN_OFFSET (L2CAP_MIN_OFFSET + 1)
82
83 /* HID_HOST_MAX_DEVICES can not exceed 15 for th design of BTA HH */
84 #define BTA_HH_IDX_INVALID 0xff
85 #define BTA_HH_MAX_KNOWN HID_HOST_MAX_DEVICES
86
87 /* GATT_MAX_PHY_CHANNEL can not exceed 14 for the design of BTA HH */
88 #if GATT_MAX_PHY_CHANNEL > 14
89 #define BTA_HH_LE_MAX_KNOWN 14
90 #else
91 #define BTA_HH_LE_MAX_KNOWN GATT_MAX_PHY_CHANNEL
92 #endif
93
94 #define BTA_HH_MAX_DEVICE (HID_HOST_MAX_DEVICES + BTA_HH_LE_MAX_KNOWN)
95 /* invalid device handle */
96 #define BTA_HH_INVALID_HANDLE 0xff
97
98 /* type of protocol mode */
99 #define BTA_HH_PROTO_RPT_MODE (0x00)
100 #define BTA_HH_PROTO_BOOT_MODE (0x01)
101 #define BTA_HH_PROTO_UNKNOWN (0xff)
102 typedef uint8_t tBTA_HH_PROTO_MODE;
103
104 enum { BTA_HH_KEYBD_RPT_ID = 1, BTA_HH_MOUSE_RPT_ID };
105 typedef uint8_t tBTA_HH_BOOT_RPT_ID;
106
107 /* type of devices, bit mask */
108 #define BTA_HH_DEVT_UNKNOWN 0x00
109 #define BTA_HH_DEVT_JOS 0x01 /* joy stick */
110 #define BTA_HH_DEVT_GPD 0x02 /* game pad */
111 #define BTA_HH_DEVT_RMC 0x03 /* remote control */
112 #define BTA_HH_DEVT_SED 0x04 /* sensing device */
113 #define BTA_HH_DEVT_DGT 0x05 /* Digitizer tablet */
114 #define BTA_HH_DEVT_CDR 0x06 /* card reader */
115 #define BTA_HH_DEVT_KBD 0x10 /* keyboard */
116 #define BTA_HH_DEVT_MIC 0x20 /* pointing device */
117 #define BTA_HH_DEVT_COM 0x30 /* Combo keyboard/pointing */
118 #define BTA_HH_DEVT_OTHER 0x80
119 typedef uint8_t tBTA_HH_DEVT;
120
121 typedef enum : uint8_t {
122 BTA_HH_OK = 0,
123 BTA_HH_HS_HID_NOT_READY, /* handshake error : device not ready */
124 BTA_HH_HS_INVALID_RPT_ID, /* handshake error : invalid report ID */
125 BTA_HH_HS_TRANS_NOT_SPT, /* handshake error : transaction not spt */
126 BTA_HH_HS_INVALID_PARAM, /* handshake error : invalid paremter */
127 BTA_HH_HS_ERROR, /* handshake error : unspecified HS error */
128 BTA_HH_ERR, /* general BTA HH error */
129 BTA_HH_ERR_SDP, /* SDP error */
130 BTA_HH_ERR_PROTO, /* SET_Protocol error,
131 only used in BTA_HH_OPEN_EVT callback */
132
133 BTA_HH_ERR_DB_FULL, /* device database full error, used in
134 BTA_HH_OPEN_EVT/BTA_HH_ADD_DEV_EVT */
135 BTA_HH_ERR_TOD_UNSPT, /* type of device not supported */
136 BTA_HH_ERR_NO_RES, /* out of system resources */
137 BTA_HH_ERR_AUTH_FAILED, /* authentication fail */
138 BTA_HH_ERR_HDL,
139 BTA_HH_ERR_SEC,
140 BTA_HH_HS_SERVICE_CHANGED /* GATT service changed on the peer */
141 } tBTA_HH_STATUS;
142
to_bta_hh_status(uint32_t status)143 inline tBTA_HH_STATUS to_bta_hh_status(uint32_t status) {
144 return static_cast<tBTA_HH_STATUS>(status);
145 }
146
bta_hh_status_text(const tBTA_HH_STATUS & status)147 inline std::string bta_hh_status_text(const tBTA_HH_STATUS& status) {
148 switch (status) {
149 CASE_RETURN_STRING(BTA_HH_OK);
150 CASE_RETURN_STRING(BTA_HH_HS_HID_NOT_READY);
151 CASE_RETURN_STRING(BTA_HH_HS_INVALID_RPT_ID);
152 CASE_RETURN_STRING(BTA_HH_HS_TRANS_NOT_SPT);
153 CASE_RETURN_STRING(BTA_HH_HS_INVALID_PARAM);
154 CASE_RETURN_STRING(BTA_HH_HS_ERROR);
155 CASE_RETURN_STRING(BTA_HH_ERR);
156 CASE_RETURN_STRING(BTA_HH_ERR_SDP);
157 CASE_RETURN_STRING(BTA_HH_ERR_PROTO);
158 CASE_RETURN_STRING(BTA_HH_ERR_DB_FULL);
159 CASE_RETURN_STRING(BTA_HH_ERR_TOD_UNSPT);
160 CASE_RETURN_STRING(BTA_HH_ERR_NO_RES);
161 CASE_RETURN_STRING(BTA_HH_ERR_AUTH_FAILED);
162 CASE_RETURN_STRING(BTA_HH_ERR_HDL);
163 CASE_RETURN_STRING(BTA_HH_ERR_SEC);
164 CASE_RETURN_STRING(BTA_HH_HS_SERVICE_CHANGED);
165 }
166 RETURN_UNKNOWN_TYPE_STRING(tBTA_HH_STATUS, status);
167 }
168
bta_hh_event_text(uint16_t event)169 inline std::string bta_hh_event_text(uint16_t event) {
170 switch (event) {
171 CASE_RETURN_STRING(BTA_HH_EMPTY_EVT);
172 CASE_RETURN_STRING(BTA_HH_ENABLE_EVT);
173 CASE_RETURN_STRING(BTA_HH_DISABLE_EVT);
174 CASE_RETURN_STRING(BTA_HH_OPEN_EVT);
175 CASE_RETURN_STRING(BTA_HH_CLOSE_EVT);
176 CASE_RETURN_STRING(BTA_HH_GET_DSCP_EVT);
177 CASE_RETURN_STRING(BTA_HH_GET_PROTO_EVT);
178 CASE_RETURN_STRING(BTA_HH_GET_RPT_EVT);
179 CASE_RETURN_STRING(BTA_HH_GET_IDLE_EVT);
180 CASE_RETURN_STRING(BTA_HH_SET_PROTO_EVT);
181 CASE_RETURN_STRING(BTA_HH_SET_RPT_EVT);
182 CASE_RETURN_STRING(BTA_HH_SET_IDLE_EVT);
183 CASE_RETURN_STRING(BTA_HH_VC_UNPLUG_EVT);
184 CASE_RETURN_STRING(BTA_HH_ADD_DEV_EVT);
185 CASE_RETURN_STRING(BTA_HH_RMV_DEV_EVT);
186 CASE_RETURN_STRING(BTA_HH_API_ERR_EVT);
187 }
188 RETURN_UNKNOWN_TYPE_STRING(bta_hh_event, event);
189 }
190
191 typedef uint16_t tBTA_HH_ATTR_MASK;
192
193 /* supported type of device and corresponding application ID */
194 typedef struct {
195 tBTA_HH_DEVT tod; /* type of device */
196 uint8_t app_id; /* corresponding application ID */
197 } tBTA_HH_SPT_TOD;
198
199 /* configuration struct */
200 typedef struct {
201 uint8_t max_devt_spt; /* max number of types of devices spt */
202 tBTA_HH_SPT_TOD* p_devt_list; /* supported types of device list */
203 uint16_t sdp_db_size;
204 } tBTA_HH_CFG;
205
206 enum {
207 BTA_HH_RPTT_RESRV, /* reserved */
208 BTA_HH_RPTT_INPUT, /* input report */
209 BTA_HH_RPTT_OUTPUT, /* output report */
210 BTA_HH_RPTT_FEATURE /* feature report */
211 };
212 typedef uint8_t tBTA_HH_RPT_TYPE;
213
214 /* HID_CONTROL operation code used in BTA_HhSendCtrl()
215 */
216 enum {
217 BTA_HH_CTRL_NOP = 0 + HID_PAR_CONTROL_NOP, /* mapping from BTE */
218 BTA_HH_CTRL_HARD_RESET, /* hard reset */
219 BTA_HH_CTRL_SOFT_RESET, /* soft reset */
220 BTA_HH_CTRL_SUSPEND, /* enter suspend */
221 BTA_HH_CTRL_EXIT_SUSPEND, /* exit suspend */
222 BTA_HH_CTRL_VIRTUAL_CABLE_UNPLUG /* virtual unplug */
223 };
224 typedef uint8_t tBTA_HH_TRANS_CTRL_TYPE;
225
226 typedef tHID_DEV_DSCP_INFO tBTA_HH_DEV_DESCR;
227
228 #define BTA_HH_SSR_PARAM_INVALID HID_SSR_PARAM_INVALID
229
230 /* id DI is not existing in remote device, vendor_id in tBTA_HH_DEV_DSCP_INFO
231 * will be set to 0xffff */
232 #define BTA_HH_VENDOR_ID_INVALID 0xffff
233
234 /* report descriptor information */
235 typedef struct {
236 uint16_t vendor_id; /* vendor ID */
237 uint16_t product_id; /* product ID */
238 uint16_t version; /* version */
239 uint16_t ssr_max_latency; /* SSR max latency, BTA_HH_SSR_PARAM_INVALID if
240 unknown */
241 uint16_t ssr_min_tout; /* SSR min timeout, BTA_HH_SSR_PARAM_INVALID if unknown */
242 uint8_t ctry_code; /*Country Code.*/
243 #define BTA_HH_LE_REMOTE_WAKE 0x01
244 #define BTA_HH_LE_NORMAL_CONN 0x02
245
246 uint8_t flag;
247 tBTA_HH_DEV_DESCR descriptor;
248 uint8_t hid_handle;
249
ToString__anon832b3ed21808250 std::string ToString() const {
251 return std::format("{:04x}::{:04x}::{:04x}", vendor_id, product_id, version);
252 }
253 } tBTA_HH_DEV_DSCP_INFO;
254
255 /* callback event data for BTA_HH_OPEN_EVT */
256 typedef struct {
257 tAclLinkSpec link_spec; /* HID device ACL link specification */
258 tBTA_HH_STATUS status; /* operation status */
259 uint8_t handle; /* device handle */
260 bool scps_supported; /* scan parameter service supported */
261 uint8_t sub_class; /* Cod sub class */
262 uint16_t attr_mask; /* attribute mask */
263 uint8_t app_id;
264 } tBTA_HH_CONN;
265
266 typedef tBTA_HH_CONN tBTA_HH_DEV_INFO;
267
268 /* callback event data */
269 typedef struct {
270 tBTA_HH_STATUS status; /* operation status */
271 uint8_t handle; /* device handle */
272 } tBTA_HH_CBDATA;
273
274 enum {
275 BTA_HH_MOD_CTRL_KEY,
276 BTA_HH_MOD_SHFT_KEY,
277 BTA_HH_MOD_ALT_KEY,
278 BTA_HH_MOD_GUI_KEY,
279 BTA_HH_MOD_MAX_KEY
280 };
281
282 /* parsed boot mode keyboard report */
283 typedef struct {
284 uint8_t this_char[6]; /* virtual key code */
285 bool mod_key[BTA_HH_MOD_MAX_KEY];
286 /* ctrl, shift, Alt, GUI */
287 /* modifier key: is Shift key pressed */
288 /* modifier key: is Ctrl key pressed */
289 /* modifier key: is Alt key pressed */
290 /* modifier key: GUI up/down */
291 bool caps_lock; /* is caps locked */
292 bool num_lock; /* is Num key pressed */
293 } tBTA_HH_KEYBD_RPT;
294
295 /* parsed boot mode mouse report */
296 typedef struct {
297 uint8_t mouse_button; /* mouse button is clicked */
298 int8_t delta_x; /* displacement x */
299 int8_t delta_y; /* displacement y */
300 } tBTA_HH_MICE_RPT;
301
302 /* parsed Boot report */
303 typedef struct {
304 tBTA_HH_BOOT_RPT_ID dev_type; /* type of device report */
305 union {
306 tBTA_HH_KEYBD_RPT keybd_rpt; /* keyboard report */
307 tBTA_HH_MICE_RPT mice_rpt; /* mouse report */
308 } data_rpt;
309 } tBTA_HH_BOOT_RPT;
310
311 /* handshake data */
312 typedef struct {
313 tBTA_HH_STATUS status; /* handshake status */
314 uint8_t handle; /* device handle */
315 union {
316 tBTA_HH_PROTO_MODE proto_mode; /* GET_PROTO_EVT :protocol mode */
317 BT_HDR* p_rpt_data; /* GET_RPT_EVT : report data */
318 uint8_t idle_rate; /* GET_IDLE_EVT : idle rate */
319 } rsp_data;
320 } tBTA_HH_HSDATA;
321
322 /* union of data associated with HD callback */
323 typedef union {
324 tBTA_HH_DEV_INFO dev_info; /* BTA_HH_ADD_DEV_EVT, BTA_HH_RMV_DEV_EVT */
325 tBTA_HH_CONN conn; /* BTA_HH_OPEN_EVT */
326 tBTA_HH_CBDATA dev_status; /* BTA_HH_CLOSE_EVT,
327 BTA_HH_SET_PROTO_EVT
328 BTA_HH_SET_RPT_EVT
329 BTA_HH_SET_IDLE_EVT
330 BTA_HH_UPDATE_SCPP_EVT */
331
332 tBTA_HH_STATUS status; /* BTA_HH_ENABLE_EVT */
333 tBTA_HH_DEV_DSCP_INFO dscp_info; /* BTA_HH_GET_DSCP_EVT */
334 tBTA_HH_HSDATA hs_data; /* GET_ transaction callback
335 BTA_HH_GET_RPT_EVT
336 BTA_HH_GET_PROTO_EVT
337 BTA_HH_GET_IDLE_EVT */
338 } tBTA_HH;
339
340 /**
341 * Android Headtracker Service UUIDs
342 */
343 #define ANDROID_HEADTRACKER_SERVICE_UUID_STRING "109b862f-50e3-45cc-8ea1-ac62de4846d1"
344 #define ANDROID_HEADTRACKER_VERSION_CHARAC_UUID_STRING "b4eb9919-a910-46a2-a9dd-fec2525196fd"
345 #define ANDROID_HEADTRACKER_CONTROL_CHARAC_UUID_STRING "8584cbb5-2d58-45a3-ab9d-583e0958b067"
346 #define ANDROID_HEADTRACKER_REPORT_CHARAC_UUID_STRING "e66dd173-b2ae-4f5a-ae16-0162af8038ae"
347
348 extern const bluetooth::Uuid ANDROID_HEADTRACKER_SERVICE_UUID;
349 extern const bluetooth::Uuid ANDROID_HEADTRACKER_VERSION_CHARAC_UUID;
350 extern const bluetooth::Uuid ANDROID_HEADTRACKER_CONTROL_CHARAC_UUID;
351 extern const bluetooth::Uuid ANDROID_HEADTRACKER_REPORT_CHARAC_UUID;
352
353 /* BTA HH callback function */
354 typedef void(tBTA_HH_CBACK)(tBTA_HH_EVT event, tBTA_HH* p_data);
355
356 /*****************************************************************************
357 * External Function Declarations
358 ****************************************************************************/
359
360 /*******************************************************************************
361 *
362 * Function BTA_HhEnable
363 *
364 * Description This function enable HID host and registers HID-Host with
365 * lower layers.
366 *
367 * Returns void
368 *
369 ******************************************************************************/
370 void BTA_HhEnable(tBTA_HH_CBACK* p_cback, bool enable_hid, bool enable_hogp);
371
372 /*******************************************************************************
373 *
374 * Function BTA_HhDisable
375 *
376 * Description This function is called when the host is about power down.
377 *
378 * Returns void
379 *
380 ******************************************************************************/
381 void BTA_HhDisable(void);
382
383 /*******************************************************************************
384 *
385 * Function BTA_HhOpen
386 *
387 * Description This function is called to start an inquiry and read SDP
388 * record of responding devices; connect to a device if only
389 * one active HID device is found.
390 *
391 * Returns void
392 *
393 ******************************************************************************/
394 void BTA_HhOpen(const tAclLinkSpec& link_spec, bool direct);
395
396 /*******************************************************************************
397 *
398 * Function BTA_HhClose
399 *
400 * Description This function disconnects the device.
401 *
402 * Returns void
403 *
404 ******************************************************************************/
405 void BTA_HhClose(uint8_t dev_handle);
406
407 /*******************************************************************************
408 *
409 * Function BTA_HhSetProtoMode
410 *
411 * Description This function set the protocol mode at specified HID handle
412 *
413 * Returns void
414 *
415 ******************************************************************************/
416 void BTA_HhSetProtoMode(uint8_t handle, tBTA_HH_PROTO_MODE t_type);
417
418 /*******************************************************************************
419 *
420 * Function BTA_HhGetProtoMode
421 *
422 * Description This function get the protocol mode of a specified HID
423 * device.
424 *
425 * Returns void
426 *
427 ******************************************************************************/
428 void BTA_HhGetProtoMode(uint8_t dev_handle);
429 /*******************************************************************************
430 *
431 * Function BTA_HhSetReport
432 *
433 * Description send SET_REPORT to device.
434 *
435 * Returns void
436 *
437 ******************************************************************************/
438 void BTA_HhSetReport(uint8_t dev_handle, tBTA_HH_RPT_TYPE r_type, BT_HDR* p_data);
439
440 /*******************************************************************************
441 *
442 * Function BTA_HhGetReport
443 *
444 * Description Send a GET_REPORT to HID device.
445 *
446 * Returns void
447 *
448 ******************************************************************************/
449 void BTA_HhGetReport(uint8_t dev_handle, tBTA_HH_RPT_TYPE r_type, uint8_t rpt_id,
450 uint16_t buf_size);
451 /*******************************************************************************
452 *
453 * Function BTA_HhSetIdle
454 *
455 * Description send SET_IDLE to device.
456 *
457 * Returns void
458 *
459 ******************************************************************************/
460 void BTA_HhSetIdle(uint8_t dev_handle, uint16_t idle_rate);
461
462 /*******************************************************************************
463 *
464 * Function BTA_HhGetIdle
465 *
466 * Description Send a GET_IDLE to HID device.
467 *
468 * Returns void
469 *
470 ******************************************************************************/
471 void BTA_HhGetIdle(uint8_t dev_handle);
472
473 /*******************************************************************************
474 *
475 * Function BTA_HhSendCtrl
476 *
477 * Description Send HID_CONTROL request to a HID device.
478 *
479 * Returns void
480 *
481 ******************************************************************************/
482 void BTA_HhSendCtrl(uint8_t dev_handle, tBTA_HH_TRANS_CTRL_TYPE c_type);
483
484 /*******************************************************************************
485 *
486 * Function BTA_HhSetIdle
487 *
488 * Description send SET_IDLE to device.
489 *
490 * Returns void
491 *
492 ******************************************************************************/
493 void BTA_HhSetIdle(uint8_t dev_handle, uint16_t idle_rate);
494
495 /*******************************************************************************
496 *
497 * Function BTA_HhGetIdle
498 *
499 * Description Send a GET_IDLE from HID device.
500 *
501 * Returns void
502 *
503 ******************************************************************************/
504 void BTA_HhGetIdle(uint8_t dev_handle);
505
506 /*******************************************************************************
507 *
508 * Function BTA_HhSendData
509 *
510 * Description Send DATA transaction to a HID device.
511 *
512 * Returns void
513 *
514 ******************************************************************************/
515 void BTA_HhSendData(uint8_t dev_handle, const tAclLinkSpec& link_spec, BT_HDR* p_buf);
516
517 /*******************************************************************************
518 *
519 * Function BTA_HhGetDscpInfo
520 *
521 * Description Get report descriptor of the device
522 *
523 * Returns void
524 *
525 ******************************************************************************/
526 void BTA_HhGetDscpInfo(uint8_t dev_handle);
527
528 /*******************************************************************************
529 * Function BTA_HhAddDev
530 *
531 * Description Add a virtually cabled device into HID-Host device list
532 * to manage and assign a device handle for future API call,
533 * host applciation call this API at start-up to initialize its
534 * virtually cabled devices.
535 *
536 * Returns void
537 *
538 ******************************************************************************/
539 void BTA_HhAddDev(const tAclLinkSpec& link_spec, tBTA_HH_ATTR_MASK attr_mask, uint8_t sub_class,
540 uint8_t app_id, tBTA_HH_DEV_DSCP_INFO dscp_info);
541 /*******************************************************************************
542 *
543 * Function BTA_HhRemoveDev
544 *
545 * Description Remove a device from the HID host devices list.
546 *
547 * Returns void
548 *
549 ******************************************************************************/
550 void BTA_HhRemoveDev(uint8_t dev_handle);
551
552 /*******************************************************************************
553 *
554 * Function BTA_HhDump
555 *
556 * Description Dump BTA HH control block
557 *
558 * Returns void
559 *
560 ******************************************************************************/
561 void BTA_HhDump(int fd);
562
563 namespace std {
564 template <>
565 struct formatter<tBTA_HH_STATUS> : enum_formatter<tBTA_HH_STATUS> {};
566 } // namespace std
567 #endif /* BTA_HH_API_H */
568