2 * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
8 * http://www.apache.org/licenses/LICENSE-2.0
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
18 #include <gio/gunixfdlist.h>
19 #include <sys/socket.h>
21 #include "bluetooth-api.h"
22 #include "bt-internal-types.h"
23 #include "bluetooth-hid-api.h"
24 #include "bt-common.h"
25 #include "bt-request-sender.h"
26 #include "bt-event-handler.h"
28 #define HID_UUID "00001124-0000-1000-8000-00805f9b34fb"
29 #define HID_DEVICE_UUID "00001124-0000-1000-8000-00805f9b43bf"
30 #define REPORTID_MOUSE 1
31 #define BT_HID_BUFFER_LEN 100
33 /* HIDP header masks */
34 #define BT_HID_HEADER_TRANS_MASK 0xf0
35 #define BT_HID_HEADER_PARAM_MASK 0x0f
37 /* HIDP transaction types */
38 #define BT_HID_TRANS_HANDSHAKE 0x00
39 #define BT_HID_TRANS_HID_CONTROL 0x10
40 #define BT_HID_TRANS_GET_REPORT 0x40
41 #define BT_HID_TRANS_SET_REPORT 0x50
42 #define BT_HID_TRANS_GET_PROTOCOL 0x60
43 #define BT_HID_TRANS_SET_PROTOCOL 0x70
44 #define BT_HID_TRANS_GET_IDLE 0x80
45 #define BT_HID_TRANS_SET_IDLE 0x90
46 #define BT_HID_TRANS_DATA 0xa0
47 #define BT_HID_TRANS_DATC 0xb0
49 #define BT_HID_DATA_RTYPE_INPUT 0x01
50 #define BT_HID_DATA_RTYPE_OUTPUT 0x02
52 #define BT_HID_HSHK_SUCCESSFUL 0x00
53 #define BT_HID_HSHK_NOT_READY 0x01
54 #define BT_HID_HSHK_ERR_INVALID_REPORT_ID 0x02
55 #define BT_HID_HSHK_ERR_UNSUPPORTED_REQUEST 0x03
56 #define BT_HID_HSHK_ERR_INVALID_PARAMETER 0x04
57 #define BT_HID_HSHK_ERR_UNKNOWN 0x0E
58 #define BT_HID_HSHK_ERR_FATAL 0x0F
71 GIOChannel *ctrl_data_io;
72 GIOChannel *intr_data_io;
76 guint disconnect_idle_id;
77 } hid_connected_device_info_t;
82 } __attribute__((__packed__));
84 static hid_info_t *hid_info = NULL;
86 /* Variable for privilege, only for write API,
87 before we should reduce time to bt-service dbus calling
88 -1 : Don't have a permission to access API
89 0 : Initial value, not yet check
90 1 : Have a permission to access API
92 static int privilege_token_send_mouse = 0;
93 static int privilege_token_send_key = 0;
94 static int privilege_token_reply = 0;
96 static gboolean __hid_disconnect(hid_connected_device_info_t *info);
98 int _bt_hid_device_get_fd(const char *address, int *ctrl, int *intr)
101 int ret = BLUETOOTH_ERROR_NONE;
103 GVariant *result = NULL;
105 GDBusConnection *conn;
106 GDBusProxy *server_proxy;
109 GUnixFDList *out_fd_list = NULL;
110 conn = _bt_gdbus_get_system_gconn();
111 retv_if(conn == NULL, BLUETOOTH_ERROR_INTERNAL);
113 adapter_path = _bt_get_device_object_path((char *)address);
114 retv_if(adapter_path == NULL, BLUETOOTH_ERROR_INTERNAL);
115 BT_INFO_C("Device : %s", adapter_path);
116 server_proxy = g_dbus_proxy_new_sync(conn, G_DBUS_PROXY_FLAGS_NONE,
118 adapter_path, "org.bluez.Input1", NULL, NULL);
119 g_free(adapter_path);
121 if (server_proxy == NULL) {
122 BT_ERR("Failed to get the network server proxy\n");
123 return BLUETOOTH_ERROR_INTERNAL;
126 result = g_dbus_proxy_call_with_unix_fd_list_sync(server_proxy, "GetFD",
128 G_DBUS_CALL_FLAGS_NONE,
134 if (result == NULL) {
136 g_dbus_error_strip_remote_error(err);
137 BT_ERR("INPUT server register Error: %s\n", err->message);
138 if (g_strcmp0(err->message, "Already Exists") == 0)
139 ret = BLUETOOTH_ERROR_ALREADY_INITIALIZED;
141 ret = BLUETOOTH_ERROR_INTERNAL;
146 g_variant_get(result, "(hh)", &index1, &index2);
147 int fd1 = g_unix_fd_list_get(out_fd_list, index1, NULL);
148 int fd2 = g_unix_fd_list_get(out_fd_list, index2, NULL);
152 g_object_unref(out_fd_list);
153 g_variant_unref(result);
155 g_object_unref(server_proxy);
159 static hid_connected_device_info_t *__find_hid_info_with_address(const char *remote_addr)
163 for (l = hid_info->device_list; l != NULL; l = l->next) {
164 hid_connected_device_info_t *info = l->data;
165 if (g_strcmp0((const char *)info->address, (const char *)remote_addr) == 0)
171 static void __hid_connected_cb(hid_connected_device_info_t *info,
174 bluetooth_hid_request_t conn_info;
175 bt_event_info_t *event_info = NULL;
177 event_info = _bt_event_get_cb_data(BT_HID_DEVICE_EVENT);
178 if (event_info == NULL)
181 memset(&conn_info, 0x00, sizeof(bluetooth_hid_request_t));
182 if (info->intr_fd != -1 && info->ctrl_fd == -1)
183 conn_info.socket_fd = info->intr_fd;
185 conn_info.socket_fd = info->ctrl_fd;
186 _bt_convert_addr_string_to_type(conn_info.device_addr.addr, info->address);
188 if (result == BLUETOOTH_ERROR_NONE)
189 BT_INFO_C("Connected [HID Device]");
191 _bt_common_event_cb(BLUETOOTH_HID_DEVICE_CONNECTED,
193 event_info->cb, event_info->user_data);
196 static void __hid_connect_response_cb(GDBusProxy *proxy, GAsyncResult *res,
201 GError *error = NULL;
202 GVariant *ret = NULL;
203 hid_connected_device_info_t info;
208 ret = g_dbus_proxy_call_finish(proxy, res, &error);
210 g_dbus_error_strip_remote_error(error);
211 BT_ERR("Error : %s \n", error->message);
213 if (g_strcmp0(error->message, "In Progress") == 0)
214 result = BLUETOOTH_ERROR_DEVICE_BUSY;
216 result = BLUETOOTH_ERROR_INTERNAL;
221 info.address = g_malloc0(BT_ADDRESS_STRING_SIZE);
223 path = g_dbus_proxy_get_object_path(proxy);
224 _bt_convert_device_path_to_address(path, info.address);
226 __hid_connected_cb(&info, result);
228 g_free(info.address);
232 g_variant_unref(ret);
236 g_object_unref(proxy);
241 static gboolean __hid_disconnect(hid_connected_device_info_t *info)
243 bluetooth_hid_request_t disconn_info;
244 int fd = info->ctrl_fd;
245 bt_event_info_t *event_info;
247 BT_INFO_C("Disconnected [HID Device]");
248 hid_info->device_list = g_slist_remove(hid_info->device_list, info);
249 if (info->ctrl_data_id > 0) {
250 g_source_remove(info->ctrl_data_id);
251 info->ctrl_data_id = 0;
253 if (info->intr_data_id > 0) {
254 g_source_remove(info->intr_data_id);
255 info->intr_data_id = 0;
258 if (info->ctrl_data_io) {
259 g_io_channel_shutdown(info->ctrl_data_io, TRUE, NULL);
260 g_io_channel_unref(info->ctrl_data_io);
261 info->ctrl_data_io = NULL;
263 if (info->intr_data_io) {
264 g_io_channel_shutdown(info->intr_data_io, TRUE, NULL);
265 g_io_channel_unref(info->intr_data_io);
266 info->intr_data_io = NULL;
268 if (info->intr_fd >= 0) {
269 close(info->ctrl_fd);
270 close(info->intr_fd);
274 info->disconnect_idle_id = 0;
275 event_info = _bt_event_get_cb_data(BT_HID_DEVICE_EVENT);
276 if (event_info == NULL)
279 memset(&disconn_info, 0x00, sizeof(bluetooth_hid_request_t));
280 disconn_info.socket_fd = fd;
281 _bt_convert_addr_string_to_type(disconn_info.device_addr.addr , info->address);
282 _bt_common_event_cb(BLUETOOTH_HID_DEVICE_DISCONNECTED,
283 BLUETOOTH_ERROR_NONE, &disconn_info,
284 event_info->cb, event_info->user_data);
286 g_free(info->address);
293 void __free_hid_info(hid_info_t *info)
297 _bt_unregister_gdbus(info->object_id);
299 while (info->device_list) {
300 hid_connected_device_info_t *dev_info = NULL;
301 dev_info = (hid_connected_device_info_t *)info->device_list->data;
303 if (dev_info->disconnect_idle_id > 0) {
304 BT_INFO("Disconnect idle still not process remove source");
305 g_source_remove(dev_info->disconnect_idle_id);
306 dev_info->disconnect_idle_id = 0;
308 __hid_disconnect(dev_info);
316 static gboolean __is_error_by_disconnect(GError *err)
318 return !g_strcmp0(err->message, "Connection reset by peer") ||
319 !g_strcmp0(err->message, "Connection timed out") ||
320 !g_strcmp0(err->message, "Software caused connection abort");
323 static gboolean __received_cb(GIOChannel *chan, GIOCondition cond,
326 hid_connected_device_info_t *info = data;
327 GIOStatus status = G_IO_STATUS_NORMAL;
328 char buffer[BT_RFCOMM_BUFFER_LEN];
331 guint8 header, type, param;
332 bt_event_info_t *event_info;
333 retv_if(info == NULL, FALSE);
335 if (cond & (G_IO_NVAL | G_IO_HUP | G_IO_ERR)) {
336 BT_ERR_C("HID disconnected: %d", info->ctrl_fd);
337 if (info->disconnect_idle_id > 0) {
338 BT_INFO("Disconnect idle still not process remove source");
339 g_source_remove(info->disconnect_idle_id);
340 info->disconnect_idle_id = 0;
342 __hid_disconnect(info);
346 status = g_io_channel_read_chars(chan, buffer, BT_RFCOMM_BUFFER_LEN,
348 if (status == G_IO_STATUS_NORMAL) {
349 BT_INFO("Parsing Data");
350 bluetooth_hid_received_data_t data = {0};
352 type = header & BT_HID_HEADER_TRANS_MASK;
353 param = header & BT_HID_HEADER_PARAM_MASK;
354 BT_INFO("type %d , param %d", type, param);
355 BT_INFO("Data Reveived from %s" , info->address);
357 event_info = _bt_event_get_cb_data(BT_HID_DEVICE_EVENT);
358 if (event_info == NULL)
361 data.address = g_strdup(info->address);
363 case BT_HID_TRANS_HANDSHAKE:
364 BT_INFO("TRANS HANDSHAKE");
365 data.type = HTYPE_TRANS_HANDSHAKE;
366 data.buffer_size = len;
367 data.buffer = (char *) malloc(sizeof(char) * len);
369 memcpy(data.buffer, buffer, len);
372 case BT_HID_TRANS_HID_CONTROL:
373 BT_INFO("HID CONTROL");
374 data.type = HTYPE_TRANS_HID_CONTROL;
375 data.buffer_size = len;
376 data.buffer = (char *) malloc(sizeof(char) * len);
378 memcpy(data.buffer, buffer, len);
381 case BT_HID_TRANS_DATA:
382 BT_INFO("TRANS DATA");
383 data.type = HTYPE_TRANS_DATA;
384 if (param & BT_HID_DATA_RTYPE_INPUT) {
385 BT_INFO("Input Report");
386 data.param = PTYPE_DATA_RTYPE_INPUT;
387 data.buffer_size = len;
388 data.buffer = (char *) malloc(sizeof(char) * len);
390 memcpy(data.buffer, buffer, len);
392 BT_INFO("Out Report");
393 data.param = PTYPE_DATA_RTYPE_OUTPUT;
394 data.buffer_size = len;
395 data.buffer = (char *) malloc(sizeof(char) * len);
397 memcpy(data.buffer, buffer, len);
401 case BT_HID_TRANS_GET_REPORT: {
402 BT_INFO("Get Report");
403 data.type = HTYPE_TRANS_GET_REPORT;
404 if (param & BT_HID_DATA_RTYPE_INPUT) {
405 BT_INFO("Input Report");
406 data.param = PTYPE_DATA_RTYPE_INPUT;
408 BT_INFO("Output Report");
409 data.param = PTYPE_DATA_RTYPE_OUTPUT;
411 data.buffer_size = len;
412 data.buffer = (char *) malloc(sizeof(char) * len);
414 memcpy(data.buffer, buffer, len);
418 case BT_HID_TRANS_SET_REPORT: {
419 BT_INFO("Set Report");
420 data.type = HTYPE_TRANS_SET_REPORT;
421 if (param & BT_HID_DATA_RTYPE_INPUT) {
422 BT_INFO("Input Report");
423 data.param = PTYPE_DATA_RTYPE_INPUT;
425 BT_INFO("Output Report");
426 data.param = PTYPE_DATA_RTYPE_OUTPUT;
428 data.buffer_size = len;
429 data.buffer = (char *) malloc(sizeof(char) * len);
431 memcpy(data.buffer, buffer, len);
435 case BT_HID_TRANS_GET_PROTOCOL:{
436 BT_INFO("Get_PROTOCOL");
437 data.type = HTYPE_TRANS_GET_PROTOCOL;
438 data.param = PTYPE_DATA_RTYPE_INPUT;
439 data.buffer_size = len;
440 data.buffer = (char *) malloc(sizeof(char) * len);
442 memcpy(data.buffer, buffer, len);
446 case BT_HID_TRANS_SET_PROTOCOL:{
447 BT_INFO("Set_PROTOCOL");
448 data.type = HTYPE_TRANS_SET_PROTOCOL;
449 data.param = PTYPE_DATA_RTYPE_INPUT;
450 data.buffer_size = len;
451 data.buffer = (char *) malloc(sizeof(char) * len);
453 memcpy(data.buffer, buffer, len);
458 BT_INFO("unsupported HIDP control message");
459 BT_ERR("Send Handshake Message");
460 guint8 type = BT_HID_TRANS_HANDSHAKE |
461 BT_HID_HSHK_ERR_UNSUPPORTED_REQUEST;
462 data.type = HTYPE_TRANS_UNKNOWN;
463 int fd = g_io_channel_unix_get_fd(chan);
464 int bytes = write(fd, &type, sizeof(type));
465 BT_INFO("Bytes Written %d", bytes);
470 _bt_common_event_cb(BLUETOOTH_HID_DEVICE_DATA_RECEIVED,
471 BLUETOOTH_ERROR_NONE, &data,
472 event_info->cb, event_info->user_data);
477 g_free((char *)data.address);
479 BT_ERR("Error while reading data %d [%s]", status, info->address);
481 BT_ERR("IO Channel read error [%s]", err->message);
482 if (status == G_IO_STATUS_ERROR &&
483 __is_error_by_disconnect(err)) {
484 BT_DBG("cond : %d", cond);
486 __hid_disconnect(info);
490 } else if (status == G_IO_STATUS_EOF) {
491 __hid_disconnect(info);
498 int new_hid_connection(const char *path, int fd, bluetooth_device_address_t *addr)
500 hid_info_t *info = NULL;
501 hid_connected_device_info_t *dev_info = NULL;
507 _bt_convert_addr_type_to_string((char *)address, addr->addr);
508 BT_INFO("Address [%s]", address);
509 dev_info = __find_hid_info_with_address(address);
510 if (dev_info == NULL) {
511 dev_info = (hid_connected_device_info_t *)
512 g_malloc0(sizeof(hid_connected_device_info_t));
514 dev_info->intr_fd = -1;
515 dev_info->ctrl_fd = -1;
516 dev_info->intr_fd = fd;
517 dev_info->address = g_strdup(address);
518 dev_info->intr_data_io = g_io_channel_unix_new(dev_info->intr_fd);
519 g_io_channel_set_encoding(dev_info->intr_data_io, NULL, NULL);
520 g_io_channel_set_flags(dev_info->intr_data_io, G_IO_FLAG_NONBLOCK, NULL);
521 g_io_channel_set_close_on_unref(dev_info->intr_data_io, TRUE);
522 dev_info->intr_data_id = g_io_add_watch(dev_info->intr_data_io,
523 G_IO_IN | G_IO_HUP | G_IO_ERR | G_IO_NVAL,
524 __received_cb, dev_info);
525 hid_info->device_list = g_slist_append(hid_info->device_list, dev_info);
527 dev_info->ctrl_fd = fd;
528 dev_info->ctrl_data_io = g_io_channel_unix_new(dev_info->ctrl_fd);
529 g_io_channel_set_encoding(dev_info->ctrl_data_io, NULL, NULL);
530 g_io_channel_set_flags(dev_info->ctrl_data_io, G_IO_FLAG_NONBLOCK, NULL);
531 g_io_channel_set_close_on_unref(dev_info->ctrl_data_io, TRUE);
532 dev_info->ctrl_data_id = g_io_add_watch(dev_info->ctrl_data_io,
533 G_IO_IN | G_IO_HUP | G_IO_ERR | G_IO_NVAL,
534 __received_cb, dev_info);
537 if (dev_info->ctrl_fd != -1 && dev_info->intr_fd != -1)
538 __hid_connected_cb(dev_info, BLUETOOTH_ERROR_NONE);
542 static hid_info_t *__register_method()
545 hid_info_t *info = NULL;
547 path = g_strdup_printf("/org/socket/server/%d", getpid());
549 object_id = _bt_register_new_conn(path, new_hid_connection);
553 info = g_new(hid_info_t, 1);
554 info->object_id = (guint)object_id;
557 info->device_list = NULL;
562 void _bluetooth_hid_free_hid_info(void)
564 if (hid_info == NULL) {
565 BT_DBG("hid_info is already NULL");
569 __free_hid_info(hid_info);
573 BT_EXPORT_API int bluetooth_hid_device_init(hid_cb_func_ptr callback_ptr, void *user_data)
577 /* Register HID Device events */
578 BT_INFO("BT_HID_DEVICE_EVENT");
579 ret = _bt_register_event(BT_HID_DEVICE_EVENT , (void *)callback_ptr, user_data);
581 if (ret != BLUETOOTH_ERROR_NONE &&
582 ret != BLUETOOTH_ERROR_ALREADY_INITIALIZED) {
583 BT_ERR("Fail to init the event handler");
587 _bt_set_user_data(BT_HID, (void *)callback_ptr, user_data);
589 return BLUETOOTH_ERROR_NONE;
592 BT_EXPORT_API int bluetooth_hid_device_deinit(void)
596 ret = _bt_unregister_event(BT_HID_DEVICE_EVENT);
598 if (ret != BLUETOOTH_ERROR_NONE) {
599 BT_ERR("Fail to deinit the event handler");
603 _bt_set_user_data(BT_HID, NULL, NULL);
605 return BLUETOOTH_ERROR_NONE;
608 BT_EXPORT_API int bluetooth_hid_device_activate(void)
610 bt_register_profile_info_t profile_info;
611 int result = BLUETOOTH_ERROR_NONE;
613 if (_bt_check_privilege(BT_CHECK_PRIVILEGE, BT_HID_DEVICE_ACTIVATE)
614 == BLUETOOTH_ERROR_PERMISSION_DEINED) {
615 BT_ERR("Don't have a privilege to use this API");
616 return BLUETOOTH_ERROR_PERMISSION_DEINED;
619 if (hid_info != NULL)
620 return BLUETOOTH_ERROR_IN_PROGRESS;
622 hid_info = __register_method();
623 if (hid_info == NULL)
624 return BLUETOOTH_ERROR_INTERNAL;
626 hid_info->uuid = g_strdup(HID_DEVICE_UUID);
628 profile_info.authentication = TRUE;
629 profile_info.authorization = TRUE;
630 profile_info.obj_path = hid_info->path;
631 profile_info.role = g_strdup("Hid");
632 profile_info.service = hid_info->uuid;
633 profile_info.uuid = hid_info->uuid;
635 BT_INFO("uuid %s", profile_info.uuid);
636 result = _bt_register_profile(&profile_info, FALSE);
638 g_free(profile_info.role);
643 BT_EXPORT_API int bluetooth_hid_device_deactivate(void)
645 if (_bt_check_privilege(BT_CHECK_PRIVILEGE, BT_HID_DEVICE_DEACTIVATE)
646 == BLUETOOTH_ERROR_PERMISSION_DEINED) {
647 BT_ERR("Don't have a privilege to use this API");
648 return BLUETOOTH_ERROR_PERMISSION_DEINED;
651 if (hid_info == NULL)
652 return BLUETOOTH_ERROR_NOT_IN_OPERATION;
654 _bt_unregister_profile(hid_info->path);
656 _bluetooth_hid_free_hid_info();
658 return BLUETOOTH_ERROR_NONE;
661 BT_EXPORT_API int bluetooth_hid_device_connect(const char *remote_addr)
663 char device_address[BT_ADDRESS_STRING_SIZE] = {0};
664 hid_connected_device_info_t *info = NULL;
667 BT_CHECK_PARAMETER(remote_addr, return);
669 info = __find_hid_info_with_address(remote_addr);
671 BT_ERR("Connection Already Exists");
672 return BLUETOOTH_ERROR_ALREADY_CONNECT;
674 if (_bt_check_privilege(BT_CHECK_PRIVILEGE, BT_HID_DEVICE_CONNECT)
675 == BLUETOOTH_ERROR_PERMISSION_DEINED) {
676 BT_ERR("Don't have a privilege to use this API");
677 return BLUETOOTH_ERROR_PERMISSION_DEINED;
680 memcpy(device_address, remote_addr, BT_ADDRESS_STRING_SIZE);
681 ret = _bt_connect_profile(device_address, HID_DEVICE_UUID,
682 __hid_connect_response_cb, NULL);
686 BT_EXPORT_API int bluetooth_hid_device_disconnect(const char *remote_addr)
688 BT_CHECK_PARAMETER(remote_addr, return);
690 if (_bt_check_privilege(BT_CHECK_PRIVILEGE, BT_HID_DEVICE_DISCONNECT)
691 == BLUETOOTH_ERROR_PERMISSION_DEINED) {
692 BT_ERR("Don't have a privilege to use this API");
693 return BLUETOOTH_ERROR_PERMISSION_DEINED;
696 hid_connected_device_info_t *info = NULL;
698 info = __find_hid_info_with_address(remote_addr);
700 return BLUETOOTH_ERROR_INVALID_PARAM;
702 _bt_disconnect_profile((char *)remote_addr, HID_DEVICE_UUID, NULL, NULL);
704 info->disconnect_idle_id = g_idle_add((GSourceFunc)__hid_disconnect, info);
707 return BLUETOOTH_ERROR_NONE;
709 BT_EXPORT_API int bluetooth_hid_device_send_mouse_event(const char *remote_addr,
710 hid_send_mouse_event_t send_event)
714 hid_connected_device_info_t *info = NULL;
716 BT_CHECK_PARAMETER(remote_addr, return);
718 switch (privilege_token_send_mouse) {
720 result = _bt_check_privilege(BT_CHECK_PRIVILEGE, BT_HID_DEVICE_SEND_MOUSE_EVENT);
722 if (result == BLUETOOTH_ERROR_NONE) {
723 privilege_token_send_mouse = 1; /* Have a permission */
724 } else if (result == BLUETOOTH_ERROR_PERMISSION_DEINED) {
725 BT_ERR("Don't have a privilege to use this API");
726 privilege_token_send_mouse = -1; /* Don't have a permission */
727 return BLUETOOTH_ERROR_PERMISSION_DEINED;
729 /* Just break - It is not related with permission error */
733 /* Already have a privilege */
736 return BLUETOOTH_ERROR_PERMISSION_DEINED;
738 /* Invalid privilge token value */
739 return BLUETOOTH_ERROR_INTERNAL;
741 info = __find_hid_info_with_address(remote_addr);
743 BT_ERR("Connection Information not found");
744 return BLUETOOTH_ERROR_INVALID_PARAM;
748 if (info->intr_fd != -1 && info->ctrl_fd == -1)
749 socket_fd = info->intr_fd;
751 socket_fd = info->ctrl_fd;
753 written = write(socket_fd, &send_event, sizeof(send_event));
758 BT_EXPORT_API int bluetooth_hid_device_send_key_event(const char *remote_addr,
759 hid_send_key_event_t send_event)
763 hid_connected_device_info_t *info = NULL;
765 BT_CHECK_PARAMETER(remote_addr, return);
767 switch (privilege_token_send_key) {
769 result = _bt_check_privilege(BT_CHECK_PRIVILEGE, BT_HID_DEVICE_SEND_KEY_EVENT);
771 if (result == BLUETOOTH_ERROR_NONE) {
772 privilege_token_send_key = 1; /* Have a permission */
773 } else if (result == BLUETOOTH_ERROR_PERMISSION_DEINED) {
774 BT_ERR("Don't have a privilege to use this API");
775 privilege_token_send_key = -1; /* Don't have a permission */
776 return BLUETOOTH_ERROR_PERMISSION_DEINED;
778 /* Just break - It is not related with permission error */
782 /* Already have a privilege */
785 return BLUETOOTH_ERROR_PERMISSION_DEINED;
787 /* Invalid privilge token value */
788 return BLUETOOTH_ERROR_INTERNAL;
791 info = __find_hid_info_with_address(remote_addr);
793 BT_ERR("Connection Information not found");
794 return BLUETOOTH_ERROR_INVALID_PARAM;
799 if (info->intr_fd != -1 && info->ctrl_fd == -1)
800 socket_fd = info->intr_fd;
802 socket_fd = info->ctrl_fd;
804 written = write(socket_fd, &send_event, sizeof(send_event));
808 BT_EXPORT_API int bluetooth_hid_device_send_custom_event(const char *remote_addr,
809 unsigned char btcode, unsigned char report_id,
810 const char *data, unsigned int data_len)
815 hid_connected_device_info_t *info = NULL;
816 char *send_event = NULL;
818 BT_CHECK_PARAMETER(remote_addr, return);
819 BT_CHECK_PARAMETER(data, return);
821 switch (privilege_token_send_key) {
823 result = _bt_check_privilege(BT_CHECK_PRIVILEGE, BT_HID_DEVICE_SEND_CUSTOM_EVENT);
825 if (result == BLUETOOTH_ERROR_NONE) {
826 privilege_token_send_key = 1; /* Have a permission */
827 } else if (result == BLUETOOTH_ERROR_PERMISSION_DEINED) {
828 BT_ERR("Don't have a privilege to use this API");
829 privilege_token_send_key = -1; /* Don't have a permission */
830 return BLUETOOTH_ERROR_PERMISSION_DEINED;
832 /* Just break - It is not related with permission error */
836 /* Already have a privilege */
839 return BLUETOOTH_ERROR_PERMISSION_DEINED;
841 /* Invalid privilge token value */
842 return BLUETOOTH_ERROR_INTERNAL;
845 info = __find_hid_info_with_address(remote_addr);
847 BT_ERR("Connection Information not found");
848 return BLUETOOTH_ERROR_INVALID_PARAM;
851 if (info->intr_fd != -1 && info->ctrl_fd == -1)
852 socket_fd = info->intr_fd;
854 socket_fd = info->ctrl_fd;
856 send_event = g_malloc0(data_len + 2);
858 send_event[0] = (char)btcode;
859 send_event[1] = (char)report_id;
860 memcpy(send_event + 2, data, data_len);
862 written = write(socket_fd, send_event, data_len + 2);
869 BT_EXPORT_API int bluetooth_hid_device_reply_to_report(const char *remote_addr,
870 bt_hid_header_type_t htype,
871 bt_hid_param_type_t ptype,
873 unsigned int data_len)
876 struct reports output_report = { 0 };
878 hid_connected_device_info_t *info = NULL;
879 info = __find_hid_info_with_address(remote_addr);
881 BT_ERR("Connection Information not found");
882 return BLUETOOTH_ERROR_INVALID_PARAM;
885 BT_CHECK_PARAMETER(remote_addr, return);
887 switch (privilege_token_reply) {
889 result = _bt_check_privilege(BT_CHECK_PRIVILEGE, BT_HID_DEVICE_SEND_REPLY_TO_REPORT);
891 if (result == BLUETOOTH_ERROR_NONE) {
892 privilege_token_reply = 1; /* Have a permission */
893 } else if (result == BLUETOOTH_ERROR_PERMISSION_DEINED) {
894 BT_ERR("Don't have a privilege to use this API");
895 privilege_token_reply = -1; /* Don't have a permission */
896 return BLUETOOTH_ERROR_PERMISSION_DEINED;
898 /* Just break - It is not related with permission error */
902 /* Already have a privilege */
905 return BLUETOOTH_ERROR_PERMISSION_DEINED;
907 /* Invalid privilge token value */
908 return BLUETOOTH_ERROR_INTERNAL;
911 BT_INFO("htype %d ptype %d", htype, ptype);
913 case HTYPE_TRANS_GET_REPORT: {
915 case PTYPE_DATA_RTYPE_INPUT: {
916 output_report.type = BT_HID_TRANS_DATA |
917 BT_HID_DATA_RTYPE_INPUT;
918 memcpy(output_report.rep_data, data, data_len);
919 bytes = write(info->intr_fd, &output_report,
920 sizeof(output_report));
921 BT_DBG("Bytes Written %d", bytes);
925 BT_INFO("Not Supported");
930 case HTYPE_TRANS_GET_PROTOCOL: {
931 BT_DBG("Replying to Get_PROTOCOL");
932 output_report.type = BT_HID_TRANS_DATA | BT_HID_DATA_RTYPE_OUTPUT;
933 output_report.rep_data[0] = data[0];
934 bytes = write(info->intr_fd, &output_report, 2);
935 BT_DBG("Bytes Written %d", bytes);
939 case HTYPE_TRANS_SET_PROTOCOL: {
940 BT_DBG("Reply to Set_Protocol");
941 output_report.type = BT_HID_TRANS_DATA | BT_HID_DATA_RTYPE_INPUT;
942 memcpy(output_report.rep_data, data, data_len);
943 bytes = write(info->ctrl_fd, &output_report,
944 sizeof(output_report));
945 BT_DBG("Bytes Written %d", bytes);
949 case HTYPE_TRANS_HANDSHAKE: {
950 BT_DBG("Replying Handshake");
951 output_report.type = BT_HID_TRANS_HANDSHAKE | data[0];
952 memset(output_report.rep_data, 0, sizeof(output_report.rep_data));
953 bytes = write(info->intr_fd, &output_report.type,
954 sizeof(output_report.type));
955 BT_DBG("Bytes Written %d", bytes);