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 __received_cb(GIOChannel *chan, GIOCondition cond,
319 hid_connected_device_info_t *info = data;
320 GIOStatus status = G_IO_STATUS_NORMAL;
324 guint8 header, type, param;
325 bt_event_info_t *event_info;
326 retv_if(info == NULL, FALSE);
328 if (cond & (G_IO_NVAL | G_IO_HUP | G_IO_ERR)) {
329 BT_ERR_C("HID disconnected: %d", info->ctrl_fd);
330 if (info->disconnect_idle_id > 0) {
331 BT_INFO("Disconnect idle still not process remove source");
332 g_source_remove(info->disconnect_idle_id);
333 info->disconnect_idle_id = 0;
335 __hid_disconnect(info);
338 status = g_io_channel_read_chars(chan, buffer, BT_RFCOMM_BUFFER_LEN,
340 if (status == G_IO_STATUS_NORMAL) {
341 BT_INFO("Parsing Data");
342 bluetooth_hid_received_data_t data = {0};
344 type = header & BT_HID_HEADER_TRANS_MASK;
345 param = header & BT_HID_HEADER_PARAM_MASK;
346 BT_INFO("type %d , param %d", type, param);
347 BT_INFO("Data Reveived from %s" , info->address);
349 event_info = _bt_event_get_cb_data(BT_HID_DEVICE_EVENT);
350 if (event_info == NULL)
353 data.address = g_strdup(info->address);
355 case BT_HID_TRANS_HANDSHAKE:
356 BT_INFO("TRANS HANDSHAKE");
357 data.type = HTYPE_TRANS_HANDSHAKE;
358 data.buffer_size = len;
359 data.buffer = (char *) malloc(sizeof(char) * len);
361 memcpy(data.buffer, buffer, len);
363 case BT_HID_TRANS_HID_CONTROL:
364 BT_INFO("HID CONTROL");
365 data.type = HTYPE_TRANS_HID_CONTROL;
366 data.buffer_size = len;
367 data.buffer = (char *) malloc(sizeof(char) * len);
369 memcpy(data.buffer, buffer, len);
371 case BT_HID_TRANS_DATA:
372 BT_INFO("TRANS DATA");
373 data.type = HTYPE_TRANS_DATA;
374 if (param & BT_HID_DATA_RTYPE_INPUT) {
375 BT_INFO("Input Report");
376 data.param = PTYPE_DATA_RTYPE_INPUT;
377 data.buffer_size = len;
378 data.buffer = (char *) malloc(sizeof(char) * len);
380 memcpy(data.buffer, buffer, len);
382 BT_INFO("Out Report");
383 data.param = PTYPE_DATA_RTYPE_OUTPUT;
384 data.buffer_size = len;
385 data.buffer = (char *) malloc(sizeof(char) * len);
387 memcpy(data.buffer, buffer, len);
390 case BT_HID_TRANS_GET_REPORT: {
391 BT_INFO("Get Report");
392 data.type = HTYPE_TRANS_GET_REPORT;
393 if (param & BT_HID_DATA_RTYPE_INPUT) {
394 BT_INFO("Input Report");
395 data.param = PTYPE_DATA_RTYPE_INPUT;
397 BT_INFO("Output Report");
398 data.param = PTYPE_DATA_RTYPE_OUTPUT;
400 data.buffer_size = len;
401 data.buffer = (char *) malloc(sizeof(char) * len);
403 memcpy(data.buffer, buffer, len);
406 case BT_HID_TRANS_SET_REPORT: {
407 BT_INFO("Set Report");
408 data.type = HTYPE_TRANS_SET_REPORT;
409 if (param & BT_HID_DATA_RTYPE_INPUT) {
410 BT_INFO("Input Report");
411 data.param = PTYPE_DATA_RTYPE_INPUT;
413 BT_INFO("Output Report");
414 data.param = PTYPE_DATA_RTYPE_OUTPUT;
416 data.buffer_size = len;
417 data.buffer = (char *) malloc(sizeof(char) * len);
419 memcpy(data.buffer, buffer, len);
422 case BT_HID_TRANS_GET_PROTOCOL:{
423 BT_INFO("Get_PROTOCOL");
424 data.type = HTYPE_TRANS_GET_PROTOCOL;
425 data.param = PTYPE_DATA_RTYPE_INPUT;
426 data.buffer_size = len;
427 data.buffer = (char *) malloc(sizeof(char) * len);
429 memcpy(data.buffer, buffer, len);
432 case BT_HID_TRANS_SET_PROTOCOL:{
433 BT_INFO("Set_PROTOCOL");
434 data.type = HTYPE_TRANS_SET_PROTOCOL;
435 data.param = PTYPE_DATA_RTYPE_INPUT;
436 data.buffer_size = len;
437 data.buffer = (char *) malloc(sizeof(char) * len);
439 memcpy(data.buffer, buffer, len);
443 BT_INFO("unsupported HIDP control message");
444 BT_ERR("Send Handshake Message");
445 guint8 type = BT_HID_TRANS_HANDSHAKE |
446 BT_HID_HSHK_ERR_UNSUPPORTED_REQUEST;
447 data.type = HTYPE_TRANS_UNKNOWN;
448 int fd = g_io_channel_unix_get_fd(chan);
449 int bytes = write(fd, &type, sizeof(type));
450 BT_INFO("Bytes Written %d", bytes);
455 _bt_common_event_cb(BLUETOOTH_HID_DEVICE_DATA_RECEIVED,
456 BLUETOOTH_ERROR_NONE, &data,
457 event_info->cb, event_info->user_data);
461 g_free((char *)data.address);
463 BT_INFO("Error while reading data");
468 int new_hid_connection(const char *path, int fd, bluetooth_device_address_t *addr)
470 hid_info_t *info = NULL;
471 hid_connected_device_info_t *dev_info = NULL;
477 _bt_convert_addr_type_to_string((char *)address, addr->addr);
478 BT_INFO("Address [%s]", address);
479 dev_info = __find_hid_info_with_address(address);
480 if (dev_info == NULL) {
481 dev_info = (hid_connected_device_info_t *)
482 g_malloc0(sizeof(hid_connected_device_info_t));
483 if (dev_info == NULL) {
484 BT_ERR("Fail to allocation memory");
488 dev_info->intr_fd = -1;
489 dev_info->ctrl_fd = -1;
490 dev_info->intr_fd = fd;
491 dev_info->address = g_strdup(address);
492 dev_info->intr_data_io = g_io_channel_unix_new(dev_info->intr_fd);
493 g_io_channel_set_encoding(dev_info->intr_data_io, NULL, NULL);
494 g_io_channel_set_flags(dev_info->intr_data_io, G_IO_FLAG_NONBLOCK, NULL);
495 g_io_channel_set_close_on_unref(dev_info->intr_data_io, TRUE);
496 dev_info->intr_data_id = g_io_add_watch(dev_info->intr_data_io,
497 G_IO_IN | G_IO_HUP | G_IO_ERR | G_IO_NVAL,
498 __received_cb, dev_info);
499 hid_info->device_list = g_slist_append(hid_info->device_list, dev_info);
501 dev_info->ctrl_fd = fd;
502 dev_info->ctrl_data_io = g_io_channel_unix_new(dev_info->ctrl_fd);
503 g_io_channel_set_encoding(dev_info->ctrl_data_io, NULL, NULL);
504 g_io_channel_set_flags(dev_info->ctrl_data_io, G_IO_FLAG_NONBLOCK, NULL);
505 g_io_channel_set_close_on_unref(dev_info->ctrl_data_io, TRUE);
506 dev_info->ctrl_data_id = g_io_add_watch(dev_info->ctrl_data_io,
507 G_IO_IN | G_IO_HUP | G_IO_ERR | G_IO_NVAL,
508 __received_cb, dev_info);
510 if (dev_info->ctrl_fd != -1 && dev_info->intr_fd != -1) {
511 __hid_connected_cb(dev_info, BLUETOOTH_ERROR_NONE);
516 static hid_info_t *__register_method()
519 hid_info_t *info = NULL;
521 path = g_strdup_printf("/org/socket/server/%d", getpid());
523 object_id = _bt_register_new_conn(path, new_hid_connection);
527 info = g_new(hid_info_t, 1);
528 info->object_id = (guint)object_id;
531 info->device_list = NULL;
536 BT_EXPORT_API int bluetooth_hid_device_init(hid_cb_func_ptr callback_ptr, void *user_data)
540 /* Register HID Device events */
541 BT_INFO("BT_HID_DEVICE_EVENT");
542 ret = _bt_register_event(BT_HID_DEVICE_EVENT , (void *)callback_ptr, user_data);
544 if (ret != BLUETOOTH_ERROR_NONE &&
545 ret != BLUETOOTH_ERROR_ALREADY_INITIALIZED) {
546 BT_ERR("Fail to init the event handler");
550 _bt_set_user_data(BT_HID, (void *)callback_ptr, user_data);
552 return BLUETOOTH_ERROR_NONE;
555 BT_EXPORT_API int bluetooth_hid_device_deinit(void)
559 ret = _bt_unregister_event(BT_HID_DEVICE_EVENT);
561 if (ret != BLUETOOTH_ERROR_NONE) {
562 BT_ERR("Fail to deinit the event handler");
566 _bt_set_user_data(BT_HID, NULL, NULL);
568 return BLUETOOTH_ERROR_NONE;
571 BT_EXPORT_API int bluetooth_hid_device_activate(void)
573 bt_register_profile_info_t profile_info;
574 int result = BLUETOOTH_ERROR_NONE;
576 if (_bt_check_privilege(BT_CHECK_PRIVILEGE, BT_HID_DEVICE_ACTIVATE)
577 == BLUETOOTH_ERROR_PERMISSION_DEINED) {
578 BT_ERR("Don't have a privilege to use this API");
579 return BLUETOOTH_ERROR_PERMISSION_DEINED;
582 if (hid_info != NULL)
583 return BLUETOOTH_ERROR_IN_PROGRESS;
585 hid_info = __register_method();
586 if (hid_info == NULL)
587 return BLUETOOTH_ERROR_INTERNAL;
589 hid_info->uuid = g_strdup(HID_DEVICE_UUID);
591 profile_info.authentication = TRUE;
592 profile_info.authorization = TRUE;
593 profile_info.obj_path = hid_info->path;
594 profile_info.role = g_strdup("Hid");
595 profile_info.service = hid_info->uuid;
596 profile_info.uuid = hid_info->uuid;
598 BT_INFO("uuid %s", profile_info.uuid);
599 result = _bt_register_profile_platform(&profile_info, FALSE);
604 BT_EXPORT_API int bluetooth_hid_device_deactivate(void)
606 if (_bt_check_privilege(BT_CHECK_PRIVILEGE, BT_HID_DEVICE_DEACTIVATE)
607 == BLUETOOTH_ERROR_PERMISSION_DEINED) {
608 BT_ERR("Don't have a privilege to use this API");
609 return BLUETOOTH_ERROR_PERMISSION_DEINED;
612 if (hid_info == NULL)
613 return BLUETOOTH_ERROR_NOT_IN_OPERATION;
615 _bt_unregister_profile(hid_info->path);
617 __free_hid_info(hid_info);
619 return BLUETOOTH_ERROR_NONE;
622 BT_EXPORT_API int bluetooth_hid_device_connect(const char *remote_addr)
624 char device_address[BT_ADDRESS_STRING_SIZE] = {0};
625 hid_connected_device_info_t *info = NULL;
628 BT_CHECK_PARAMETER(remote_addr, return);
630 info = __find_hid_info_with_address(remote_addr);
632 BT_ERR("Connection Already Exists");
633 return BLUETOOTH_ERROR_ALREADY_CONNECT;
635 if (_bt_check_privilege(BT_CHECK_PRIVILEGE, BT_HID_DEVICE_CONNECT)
636 == BLUETOOTH_ERROR_PERMISSION_DEINED) {
637 BT_ERR("Don't have a privilege to use this API");
638 return BLUETOOTH_ERROR_PERMISSION_DEINED;
641 memcpy(device_address, remote_addr, BT_ADDRESS_STRING_SIZE);
642 ret = _bt_connect_profile(device_address, HID_DEVICE_UUID,
643 __hid_connect_response_cb, NULL);
647 BT_EXPORT_API int bluetooth_hid_device_disconnect(const char *remote_addr)
649 if (_bt_check_privilege(BT_CHECK_PRIVILEGE, BT_HID_DEVICE_DISCONNECT)
650 == BLUETOOTH_ERROR_PERMISSION_DEINED) {
651 BT_ERR("Don't have a privilege to use this API");
652 return BLUETOOTH_ERROR_PERMISSION_DEINED;
655 hid_connected_device_info_t *info = NULL;
657 info = __find_hid_info_with_address(remote_addr);
659 return BLUETOOTH_ERROR_INVALID_PARAM;
661 _bt_disconnect_profile((char *)remote_addr, HID_DEVICE_UUID, NULL, NULL);
663 info->disconnect_idle_id = g_idle_add((GSourceFunc)__hid_disconnect, info);
666 return BLUETOOTH_ERROR_NONE;
668 BT_EXPORT_API int bluetooth_hid_device_send_mouse_event(const char *remote_addr,
669 hid_send_mouse_event_t send_event)
673 hid_connected_device_info_t *info = NULL;
675 switch (privilege_token_send_mouse) {
677 result = _bt_check_privilege(BT_CHECK_PRIVILEGE, BT_HID_DEVICE_SEND_MOUSE_EVENT);
679 if (result == BLUETOOTH_ERROR_NONE) {
680 privilege_token_send_mouse = 1; /* Have a permission */
681 } else if (result == BLUETOOTH_ERROR_PERMISSION_DEINED) {
682 BT_ERR("Don't have a privilege to use this API");
683 privilege_token_send_mouse = -1; /* Don't have a permission */
684 return BLUETOOTH_ERROR_PERMISSION_DEINED;
686 /* Just break - It is not related with permission error */
690 /* Already have a privilege */
693 return BLUETOOTH_ERROR_PERMISSION_DEINED;
695 /* Invalid privilge token value */
696 return BLUETOOTH_ERROR_INTERNAL;
698 info = __find_hid_info_with_address(remote_addr);
700 BT_ERR("Connection Information not found");
701 return BLUETOOTH_ERROR_INVALID_PARAM;
705 if (info->intr_fd != -1 && info->ctrl_fd == -1)
706 socket_fd = info->intr_fd;
708 socket_fd = info->ctrl_fd;
710 written = write(socket_fd, &send_event, sizeof(send_event));
715 BT_EXPORT_API int bluetooth_hid_device_send_key_event(const char *remote_addr,
716 hid_send_key_event_t send_event)
720 hid_connected_device_info_t *info = NULL;
722 switch (privilege_token_send_key) {
724 result = _bt_check_privilege(BT_CHECK_PRIVILEGE, BT_HID_DEVICE_SEND_KEY_EVENT);
726 if (result == BLUETOOTH_ERROR_NONE) {
727 privilege_token_send_key = 1; /* Have a permission */
728 } else if (result == BLUETOOTH_ERROR_PERMISSION_DEINED) {
729 BT_ERR("Don't have a privilege to use this API");
730 privilege_token_send_key = -1; /* Don't have a permission */
731 return BLUETOOTH_ERROR_PERMISSION_DEINED;
733 /* Just break - It is not related with permission error */
737 /* Already have a privilege */
740 return BLUETOOTH_ERROR_PERMISSION_DEINED;
742 /* Invalid privilge token value */
743 return BLUETOOTH_ERROR_INTERNAL;
746 info = __find_hid_info_with_address(remote_addr);
748 BT_ERR("Connection Information not found");
749 return BLUETOOTH_ERROR_INVALID_PARAM;
754 if (info->intr_fd != -1 && info->ctrl_fd == -1)
755 socket_fd = info->intr_fd;
757 socket_fd = info->ctrl_fd;
759 written = write(socket_fd, &send_event, sizeof(send_event));
763 BT_EXPORT_API int bluetooth_hid_device_send_custom_event(const char *remote_addr,
764 unsigned char btcode, unsigned char report_id,
765 const char *data, unsigned int data_len)
770 hid_connected_device_info_t *info = NULL;
771 char *send_event = NULL;
773 BT_CHECK_PARAMETER(remote_addr, return);
774 BT_CHECK_PARAMETER(data, return);
776 switch (privilege_token_send_key) {
778 result = _bt_check_privilege(BT_CHECK_PRIVILEGE, BT_HID_DEVICE_SEND_CUSTOM_EVENT);
780 if (result == BLUETOOTH_ERROR_NONE) {
781 privilege_token_send_key = 1; /* Have a permission */
782 } else if (result == BLUETOOTH_ERROR_PERMISSION_DEINED) {
783 BT_ERR("Don't have a privilege to use this API");
784 privilege_token_send_key = -1; /* Don't have a permission */
785 return BLUETOOTH_ERROR_PERMISSION_DEINED;
787 /* Just break - It is not related with permission error */
791 /* Already have a privilege */
794 return BLUETOOTH_ERROR_PERMISSION_DEINED;
796 /* Invalid privilge token value */
797 return BLUETOOTH_ERROR_INTERNAL;
800 info = __find_hid_info_with_address(remote_addr);
802 BT_ERR("Connection Information not found");
803 return BLUETOOTH_ERROR_INVALID_PARAM;
806 if (info->intr_fd != -1 && info->ctrl_fd == -1)
807 socket_fd = info->intr_fd;
809 socket_fd = info->ctrl_fd;
811 send_event = (char*)g_malloc0(data_len + 2);
812 if (send_event == NULL)
813 return BLUETOOTH_ERROR_OUT_OF_MEMORY;
815 send_event[0] = (char)btcode;
816 send_event[1] = (char)report_id;
817 memcpy(send_event + 2, data, data_len);
819 written = write(socket_fd, send_event, data_len + 2);
826 BT_EXPORT_API int bluetooth_hid_device_reply_to_report(const char *remote_addr,
827 bt_hid_header_type_t htype,
828 bt_hid_param_type_t ptype,
830 unsigned int data_len)
833 struct reports output_report = { 0 };
835 hid_connected_device_info_t *info = NULL;
836 info = __find_hid_info_with_address(remote_addr);
838 BT_ERR("Connection Information not found");
839 return BLUETOOTH_ERROR_INVALID_PARAM;
842 switch (privilege_token_reply) {
844 result = _bt_check_privilege(BT_CHECK_PRIVILEGE, BT_HID_DEVICE_SEND_REPLY_TO_REPORT);
846 if (result == BLUETOOTH_ERROR_NONE) {
847 privilege_token_reply = 1; /* Have a permission */
848 } else if (result == BLUETOOTH_ERROR_PERMISSION_DEINED) {
849 BT_ERR("Don't have a privilege to use this API");
850 privilege_token_reply = -1; /* Don't have a permission */
851 return BLUETOOTH_ERROR_PERMISSION_DEINED;
853 /* Just break - It is not related with permission error */
857 /* Already have a privilege */
860 return BLUETOOTH_ERROR_PERMISSION_DEINED;
862 /* Invalid privilge token value */
863 return BLUETOOTH_ERROR_INTERNAL;
866 BT_INFO("htype %d ptype %d", htype, ptype);
868 case HTYPE_TRANS_GET_REPORT: {
870 case PTYPE_DATA_RTYPE_INPUT: {
871 output_report.type = BT_HID_TRANS_DATA |
872 BT_HID_DATA_RTYPE_INPUT;
873 memcpy(output_report.rep_data, data, data_len);
874 bytes = write(info->intr_fd, &output_report,
875 sizeof(output_report));
876 BT_DBG("Bytes Written %d", bytes);
880 BT_INFO("Not Supported");
884 case HTYPE_TRANS_GET_PROTOCOL: {
885 BT_DBG("Replying to Get_PROTOCOL");
886 output_report.type = BT_HID_TRANS_DATA | BT_HID_DATA_RTYPE_OUTPUT;
887 output_report.rep_data[0] = data[0];
888 bytes = write(info->intr_fd, &output_report, 2);
889 BT_DBG("Bytes Written %d", bytes);
892 case HTYPE_TRANS_SET_PROTOCOL: {
893 BT_DBG("Reply to Set_Protocol");
894 output_report.type = BT_HID_TRANS_DATA | BT_HID_DATA_RTYPE_INPUT;
895 memcpy(output_report.rep_data, data, data_len);
896 bytes = write(info->ctrl_fd, &output_report,
897 sizeof(output_report));
898 BT_DBG("Bytes Written %d", bytes);
901 case HTYPE_TRANS_HANDSHAKE: {
902 BT_DBG("Replying Handshake");
903 output_report.type = BT_HID_TRANS_HANDSHAKE | data[0];
904 memset(output_report.rep_data, 0, sizeof(output_report.rep_data));
905 bytes = write(info->intr_fd, &output_report.type,
906 sizeof(output_report.type));
907 BT_DBG("Bytes Written %d", bytes);