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