bt-api/bt-hid-device.c

   1 /*
   2  * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
   3  *
   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
   7  *
   8  *              http://www.apache.org/licenses/LICENSE-2.0
   9  *
  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.
  15  *
  16  */
  17 #include <gio/gio.h>
  18 #include <gio/gunixfdlist.h>
  19 #include <sys/socket.h>
  20
  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"
  27
  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
  32
  33 /* HIDP header masks */
  34 #define BT_HID_HEADER_TRANS_MASK                        0xf0
  35 #define BT_HID_HEADER_PARAM_MASK                        0x0f
  36
  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
  48
  49 #define BT_HID_DATA_RTYPE_INPUT                 0x01
  50 #define BT_HID_DATA_RTYPE_OUTPUT                        0x02
  51
  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
  59
  60 #define BT_HID_SERVICE_NAME "org.bluez.hid_agent"
  61 #define BT_HID_AGENT_OBJECT_PATH "/org/bluez/hid_agent"
  62 #define BT_HID_SERVICE_INTERFACE "org.tizen.HidApp"
  63
  64 typedef struct {
  65         int ctrl_fd;
  66         int intr_fd;
  67         GIOChannel *ctrl_data_io;
  68         GIOChannel *intr_data_io;
  69         guint ctrl_data_id;
  70         guint intr_data_id;
  71         char *address;
  72         guint disconnect_idle_id;
  73 } hid_connected_device_info_t;
  74
  75 struct reports {
  76         guint8 type;
  77         guint8 rep_data[20];
  78 } __attribute__((__packed__));
  79
  80 static GSList *device_list;
  81
  82 /* Variable for privilege, only for write API,
  83   before we should reduce time to bt-service dbus calling
  84   -1 : Don't have a permission to access API
  85   0 : Initial value, not yet check
  86   1 : Have a permission to access API
  87 */
  88 static int privilege_token_send_mouse = 0;
  89 static int privilege_token_send_key = 0;
  90 static int privilege_token_reply = 0;
  91
  92 static GVariant* __bt_hid_agent_dbus_send(const char *path,
  93                                 const char *interface,  const char *method,
  94                                 GError **err, GVariant *parameters)
  95 {
  96         GVariant *reply = NULL;
  97         GDBusProxy *proxy = NULL;
  98         GDBusConnection *conn = NULL;
  99
 100         conn = _bt_get_system_private_conn();
 101         retv_if(conn == NULL, NULL);
 102
 103         proxy = g_dbus_proxy_new_sync(conn, G_DBUS_PROXY_FLAGS_DO_NOT_LOAD_PROPERTIES,
 104                 NULL, BT_HID_SERVICE_NAME, path, interface, NULL, err);
 105         if (proxy == NULL) {
 106                 BT_ERR("Unable to allocate new proxy");
 107                 return NULL;
 108         }
 109
 110         reply = g_dbus_proxy_call_sync(proxy, method, parameters,
 111                                 G_DBUS_CALL_FLAGS_NONE, -1, NULL, err);
 112
 113         g_object_unref(proxy);
 114         return reply;
 115 }
 116
 117 static hid_connected_device_info_t *__find_hid_info_with_address(const char *remote_addr)
 118 {
 119         GSList *l;
 120
 121         for (l = device_list; l != NULL; l = l->next) {
 122                 hid_connected_device_info_t *info = l->data;
 123                 if (strcasecmp((const char *)info->address, (const char *)remote_addr) == 0)
 124                         return info;
 125         }
 126         return NULL;
 127 }
 128
 129 static void __hid_connected_cb(hid_connected_device_info_t *info,
 130                         int result)
 131 {
 132         bluetooth_device_address_t bd_addr;
 133         bt_event_info_t *event_info = NULL;
 134
 135         event_info = _bt_event_get_cb_data(BT_HID_DEVICE_EVENT);
 136         if (event_info == NULL)
 137                 return;
 138
 139         memset(&bd_addr, 0x00, sizeof(bluetooth_device_address_t));
 140         _bt_convert_addr_string_to_type(bd_addr.addr, info->address);
 141
 142         if (result == BLUETOOTH_ERROR_NONE)
 143                 BT_INFO_C("Connected [HID Device]");
 144
 145         _bt_common_event_cb(BLUETOOTH_HID_DEVICE_CONNECTED,
 146                         result, &bd_addr,
 147                         event_info->cb, event_info->user_data);
 148 }
 149
 150 static void __hid_connect_response_cb(GDBusProxy *proxy, GAsyncResult *res,
 151                         gpointer user_data)
 152
 153 {
 154         int result;
 155         GError *error = NULL;
 156         GVariant *ret = NULL;
 157         hid_connected_device_info_t info;
 158         const char *path;
 159
 160         BT_DBG("+");
 161
 162         ret = g_dbus_proxy_call_finish(proxy, res, &error);
 163         if (ret == NULL) {
 164                 g_dbus_error_strip_remote_error(error);
 165                 BT_ERR("Error : %s \n", error->message);
 166
 167                 info.ctrl_fd = -1;
 168                 info.intr_fd = -1;
 169
 170                 info.address = g_malloc0(BT_ADDRESS_STRING_SIZE);
 171
 172                 path = g_dbus_proxy_get_object_path(proxy);
 173                 _bt_convert_device_path_to_address(path, info.address);
 174
 175                 if (g_strcmp0(error->message, "Already Connected") == 0) {
 176                         bluetooth_device_address_t dev_address = { {0} };
 177                         int ctrl = -1, intr = -1;
 178
 179                         _bt_convert_addr_string_to_type(dev_address.addr,
 180                                                         info.address);
 181                         _bt_hid_device_get_fd(info.address, &ctrl, &intr);
 182                         if (ctrl != -1 && intr != -1)
 183                                 _bt_hid_new_connection(&dev_address, ctrl, intr);
 184                         else
 185                                 BT_ERR("fd is invalid.(ctrl=%d, intr=%d)", ctrl, intr);
 186                 } else {
 187                         if (g_strcmp0(error->message, "In Progress") == 0)
 188                                 result = BLUETOOTH_ERROR_IN_PROGRESS;
 189                         else
 190                                 result = BLUETOOTH_ERROR_INTERNAL;
 191
 192                         __hid_connected_cb(&info, result);
 193                 }
 194
 195                 g_free(info.address);
 196                 g_error_free(error);
 197         } else {
 198                 g_variant_unref(ret);
 199         }
 200
 201         if (proxy)
 202                 g_object_unref(proxy);
 203
 204         BT_DBG("-");
 205 }
 206
 207 static gboolean __hid_disconnect(hid_connected_device_info_t *info)
 208 {
 209         bluetooth_device_address_t bd_addr;
 210         bt_event_info_t *event_info;
 211
 212         BT_INFO_C("Disconnected [HID Device]");
 213         device_list = g_slist_remove(device_list, info);
 214         if (info->ctrl_data_id > 0) {
 215                 g_source_remove(info->ctrl_data_id);
 216                 info->ctrl_data_id = 0;
 217         }
 218         if (info->intr_data_id > 0) {
 219                 g_source_remove(info->intr_data_id);
 220                 info->intr_data_id = 0;
 221         }
 222
 223         if (info->ctrl_data_io) {
 224                 g_io_channel_shutdown(info->ctrl_data_io, TRUE, NULL);
 225                 g_io_channel_unref(info->ctrl_data_io);
 226                 info->ctrl_data_io = NULL;
 227         }
 228         if (info->intr_data_io) {
 229                 g_io_channel_shutdown(info->intr_data_io, TRUE, NULL);
 230                 g_io_channel_unref(info->intr_data_io);
 231                 info->intr_data_io = NULL;
 232         }
 233         if (info->intr_fd >= 0) {
 234                 close(info->ctrl_fd);
 235                 close(info->intr_fd);
 236                 info->intr_fd = -1;
 237                 info->ctrl_fd = -1;
 238         }
 239         info->disconnect_idle_id = 0;
 240         event_info = _bt_event_get_cb_data(BT_HID_DEVICE_EVENT);
 241         if (event_info != NULL) {
 242                 memset(&bd_addr, 0x00, sizeof(bluetooth_device_address_t));
 243                 _bt_convert_addr_string_to_type(bd_addr.addr , info->address);
 244                 _bt_common_event_cb(BLUETOOTH_HID_DEVICE_DISCONNECTED,
 245                                 BLUETOOTH_ERROR_NONE, &bd_addr,
 246                                 event_info->cb, event_info->user_data);
 247         }
 248
 249         g_free(info->address);
 250         g_free(info);
 251
 252         return FALSE;
 253 }
 254
 255 static gboolean __is_error_by_disconnect(GError *err)
 256 {
 257         return !g_strcmp0(err->message, "Connection reset by peer") ||
 258                         !g_strcmp0(err->message, "Connection timed out") ||
 259                         !g_strcmp0(err->message, "Software caused connection abort");
 260 }
 261
 262 static gboolean __received_cb(GIOChannel *chan, GIOCondition cond,
 263                                                                 gpointer data)
 264 {
 265         hid_connected_device_info_t *info = data;
 266         GIOStatus status = G_IO_STATUS_NORMAL;
 267         char buffer[BT_RFCOMM_BUFFER_LEN];
 268         gsize len = 0;
 269         GError *err = NULL;
 270         guint8  header, type, param;
 271         bt_event_info_t *event_info;
 272         retv_if(info == NULL, FALSE);
 273
 274         if (cond & (G_IO_NVAL | G_IO_HUP | G_IO_ERR)) {
 275                 BT_ERR_C("HID  disconnected: %d", info->ctrl_fd);
 276                         if (info->disconnect_idle_id > 0) {
 277                                 BT_INFO("Disconnect idle still not process remove source");
 278                                 g_source_remove(info->disconnect_idle_id);
 279                                 info->disconnect_idle_id = 0;
 280                         }
 281                 __hid_disconnect(info);
 282                 return FALSE;
 283         }
 284
 285         status = g_io_channel_read_chars(chan, buffer, BT_RFCOMM_BUFFER_LEN,
 286                         &len, &err);
 287         if (status == G_IO_STATUS_NORMAL) {
 288                 BT_INFO("Parsing Data");
 289                 bluetooth_hid_received_data_t recv_data = {0};
 290                 header = buffer[0];
 291                 type = header & BT_HID_HEADER_TRANS_MASK;
 292                 param = header & BT_HID_HEADER_PARAM_MASK;
 293                 BT_INFO("type %d , param %d", type, param);
 294                 BT_INFO("Data Reveived from %s" , info->address);
 295
 296                 event_info = _bt_event_get_cb_data(BT_HID_DEVICE_EVENT);
 297                 if (event_info == NULL)
 298                         return FALSE;
 299
 300                 recv_data.address = g_strdup(info->address);
 301                 switch (type) {
 302                 case BT_HID_TRANS_HANDSHAKE:
 303                         BT_INFO("TRANS HANDSHAKE");
 304                         recv_data.type = HTYPE_TRANS_HANDSHAKE;
 305                         recv_data.buffer_size = len;
 306                         recv_data.buffer = (char *)g_malloc0(sizeof(char) * len);
 307                         memcpy(recv_data.buffer, buffer, len);
 308                 break;
 309
 310                 case BT_HID_TRANS_HID_CONTROL:
 311                         BT_INFO("HID CONTROL");
 312                         recv_data.type = HTYPE_TRANS_HID_CONTROL;
 313                         recv_data.buffer_size = len;
 314                         recv_data.buffer = (char *)g_malloc0(sizeof(char) * len);
 315                         memcpy(recv_data.buffer, buffer, len);
 316                 break;
 317
 318                 case BT_HID_TRANS_DATA:
 319                         BT_INFO("TRANS DATA");
 320                         recv_data.type = HTYPE_TRANS_DATA;
 321                         if (param & BT_HID_DATA_RTYPE_INPUT) {
 322                                 BT_INFO("Input Report");
 323                                 recv_data.param = PTYPE_DATA_RTYPE_INPUT;
 324                                 recv_data.buffer_size = len;
 325                                 recv_data.buffer = (char *)g_malloc0(sizeof(char) * len);
 326                                 memcpy(recv_data.buffer, buffer, len);
 327                         } else {
 328                                 BT_INFO("Out Report");
 329                                 recv_data.param = PTYPE_DATA_RTYPE_OUTPUT;
 330                                 recv_data.buffer_size = len;
 331                                 recv_data.buffer = (char *)g_malloc0(sizeof(char) * len);
 332                                 memcpy(recv_data.buffer, buffer, len);
 333                         }
 334                 break;
 335
 336                 case BT_HID_TRANS_GET_REPORT: {
 337                         BT_INFO("Get Report");
 338                         recv_data.type = HTYPE_TRANS_GET_REPORT;
 339                         if (param & BT_HID_DATA_RTYPE_INPUT) {
 340                                 BT_INFO("Input Report");
 341                                 recv_data.param = PTYPE_DATA_RTYPE_INPUT;
 342                         } else {
 343                                 BT_INFO("Output Report");
 344                                 recv_data.param = PTYPE_DATA_RTYPE_OUTPUT;
 345                         }
 346                         recv_data.buffer_size = len;
 347                         recv_data.buffer = (char *)g_malloc0(sizeof(char) * len);
 348                         memcpy(recv_data.buffer, buffer, len);
 349                         break;
 350                 }
 351
 352                 case BT_HID_TRANS_SET_REPORT: {
 353                         BT_INFO("Set Report");
 354                         recv_data.type = HTYPE_TRANS_SET_REPORT;
 355                         if (param & BT_HID_DATA_RTYPE_INPUT) {
 356                                 BT_INFO("Input Report");
 357                                 recv_data.param = PTYPE_DATA_RTYPE_INPUT;
 358                         } else {
 359                                 BT_INFO("Output Report");
 360                                 recv_data.param = PTYPE_DATA_RTYPE_OUTPUT;
 361                         }
 362                         recv_data.buffer_size = len;
 363                         recv_data.buffer = (char *)g_malloc0(sizeof(char) * len);
 364                         memcpy(recv_data.buffer, buffer, len);
 365                         break;
 366                 }
 367
 368                 case BT_HID_TRANS_GET_PROTOCOL:{
 369                         BT_INFO("Get_PROTOCOL");
 370                         recv_data.type = HTYPE_TRANS_GET_PROTOCOL;
 371                         recv_data.param = PTYPE_DATA_RTYPE_INPUT;
 372                         recv_data.buffer_size = len;
 373                         recv_data.buffer = (char *)g_malloc0(sizeof(char) * len);
 374                         memcpy(recv_data.buffer, buffer, len);
 375                         break;
 376                 }
 377
 378                 case BT_HID_TRANS_SET_PROTOCOL:{
 379                         BT_INFO("Set_PROTOCOL");
 380                         recv_data.type = HTYPE_TRANS_SET_PROTOCOL;
 381                         recv_data.param = PTYPE_DATA_RTYPE_INPUT;
 382                         recv_data.buffer_size = len;
 383                         recv_data.buffer = (char *)g_malloc0(sizeof(char) * len);
 384                         memcpy(recv_data.buffer, buffer, len);
 385                         break;
 386                 }
 387
 388                 case BT_HID_TRANS_GET_IDLE:{
 389                         BT_INFO("Get_IDLE");
 390                         recv_data.type = HTYPE_TRANS_GET_IDLE;
 391                         recv_data.param = PTYPE_DATA_RTYPE_INPUT;
 392                         recv_data.buffer_size = len;
 393                         recv_data.buffer = (char *)g_malloc0(sizeof(char) * len);
 394                         memcpy(recv_data.buffer, buffer, len);
 395                         break;
 396                 }
 397
 398                 case BT_HID_TRANS_SET_IDLE:{
 399                         BT_INFO("Set_IDLE");
 400                         recv_data.type = HTYPE_TRANS_SET_IDLE;
 401                         recv_data.param = PTYPE_DATA_RTYPE_INPUT;
 402                         recv_data.buffer_size = len;
 403                         recv_data.buffer = (char *)g_malloc0(sizeof(char) * len);
 404                         memcpy(recv_data.buffer, buffer, len);
 405                         break;
 406                 }
 407
 408                 default: {
 409                         BT_INFO("unsupported HIDP control message");
 410                         BT_ERR("Send Handshake Message");
 411                         guint8 type = BT_HID_TRANS_HANDSHAKE |
 412                                 BT_HID_HSHK_ERR_UNSUPPORTED_REQUEST;
 413                         recv_data.type = HTYPE_TRANS_UNKNOWN;
 414                         int fd = g_io_channel_unix_get_fd(chan);
 415                         int bytes = write(fd,  &type, sizeof(type));
 416                         BT_INFO("Bytes Written %d", bytes);
 417                         break;
 418                 }
 419         }
 420
 421         _bt_common_event_cb(BLUETOOTH_HID_DEVICE_DATA_RECEIVED,
 422                                 BLUETOOTH_ERROR_NONE, &recv_data,
 423                                 event_info->cb, event_info->user_data);
 424         if (recv_data.buffer)
 425                 g_free(recv_data.buffer);
 426
 427         if (recv_data.address)
 428                 g_free((char *)recv_data.address);
 429         } else {
 430                 BT_ERR("Error while reading data %d [%s]", status, info->address);
 431                 if (err) {
 432                         BT_ERR("IO Channel read error [%s]", err->message);
 433                         if (status == G_IO_STATUS_ERROR &&
 434                                         __is_error_by_disconnect(err)) {
 435                                 BT_DBG("cond : %d", cond);
 436                                 g_error_free(err);
 437                                 __hid_disconnect(info);
 438                                 return FALSE;
 439                         }
 440                         g_error_free(err);
 441                 } else if (status == G_IO_STATUS_EOF) {
 442                         __hid_disconnect(info);
 443                         return FALSE;
 444                 }
 445         }
 446         return TRUE;
 447 }
 448
 449 static void __free_hid_info(void *data)
 450 {
 451         BT_DBG("");
 452
 453         hid_connected_device_info_t *dev_info = (hid_connected_device_info_t *)data;
 454
 455         if (dev_info->disconnect_idle_id > 0) {
 456                 BT_INFO("Disconnect idle still not process remove source");
 457                 g_source_remove(dev_info->disconnect_idle_id);
 458                 dev_info->disconnect_idle_id = 0;
 459         }
 460         __hid_disconnect(dev_info);
 461 }
 462
 463 int _bt_hid_device_get_fd(const char *address, int *ctrl, int *intr)
 464 {
 465
 466         int ret = BLUETOOTH_ERROR_NONE;
 467         char *adapter_path;
 468         GVariant *result = NULL;
 469         GError *err = NULL;
 470         GDBusConnection *conn;
 471         GDBusProxy *server_proxy;
 472         int index1 = 0;
 473         int index2 = 0;
 474         GUnixFDList *out_fd_list = NULL;
 475         conn = _bt_get_system_private_conn();
 476         retv_if(conn == NULL, BLUETOOTH_ERROR_INTERNAL);
 477
 478         adapter_path = _bt_get_device_object_path((char *)address);
 479         retv_if(adapter_path == NULL, BLUETOOTH_ERROR_INTERNAL);
 480         BT_INFO_C("Device : %s", adapter_path);
 481         server_proxy = g_dbus_proxy_new_sync(conn, G_DBUS_PROXY_FLAGS_DO_NOT_LOAD_PROPERTIES,
 482                         NULL, BT_BLUEZ_NAME,
 483                         adapter_path, "org.bluez.Input1",  NULL, NULL);
 484         g_free(adapter_path);
 485
 486         if (server_proxy == NULL) {
 487                 BT_ERR("Failed to get the network server proxy\n");
 488                 return BLUETOOTH_ERROR_INTERNAL;
 489         }
 490
 491         result = g_dbus_proxy_call_with_unix_fd_list_sync(server_proxy, "GetFD",
 492                                  NULL,
 493                                  G_DBUS_CALL_FLAGS_NONE,
 494                                  -1,
 495                                  NULL,
 496                                  &out_fd_list,
 497                                  NULL,
 498                                  &err);
 499         if (result == NULL) {
 500                 if (err != NULL) {
 501                         g_dbus_error_strip_remote_error(err);
 502                         BT_ERR("INPUT server register Error: %s\n", err->message);
 503                         if (g_strcmp0(err->message, "Already Exists") == 0)
 504                                 ret = BLUETOOTH_ERROR_ALREADY_INITIALIZED;
 505                         else
 506                                 ret = BLUETOOTH_ERROR_INTERNAL;
 507
 508                         g_error_free(err);
 509                 }
 510         } else {
 511                 g_variant_get(result, "(hh)", &index1, &index2);
 512                 int fd1 = g_unix_fd_list_get(out_fd_list, index1, NULL);
 513                 int fd2 = g_unix_fd_list_get(out_fd_list, index2, NULL);
 514
 515                 *ctrl = fd1;
 516                 *intr = fd2;
 517                 g_object_unref(out_fd_list);
 518                 g_variant_unref(result);
 519         }
 520         g_object_unref(server_proxy);
 521         return ret;
 522 }
 523
 524 int _bt_hid_new_connection(bluetooth_device_address_t *addr,
 525                                 int ctrl_fd, int intr_fd)
 526 {
 527         hid_connected_device_info_t *dev_info = NULL;
 528         char address[18];
 529         char secure_addr[BT_ADDRESS_STRING_SIZE] = { 0 };
 530
 531         _bt_convert_addr_type_to_string((char *)address, addr->addr);
 532         _bt_convert_addr_string_to_secure_string(secure_addr, address);
 533         BT_INFO("Address [%s]", secure_addr);
 534         dev_info = __find_hid_info_with_address(address);
 535         if (dev_info != NULL)
 536                 __free_hid_info(dev_info);
 537
 538         dev_info = (hid_connected_device_info_t *)
 539                 g_malloc0(sizeof(hid_connected_device_info_t));
 540
 541         dev_info->ctrl_fd = ctrl_fd;
 542         dev_info->intr_fd = intr_fd;
 543         dev_info->address = g_strdup(address);
 544         dev_info->ctrl_data_io = g_io_channel_unix_new(dev_info->ctrl_fd);
 545         dev_info->intr_data_io = g_io_channel_unix_new(dev_info->intr_fd);
 546         g_io_channel_set_encoding(dev_info->ctrl_data_io, NULL, NULL);
 547         g_io_channel_set_flags(dev_info->ctrl_data_io, G_IO_FLAG_NONBLOCK, NULL);
 548         g_io_channel_set_close_on_unref(dev_info->ctrl_data_io, TRUE);
 549         g_io_channel_set_encoding(dev_info->intr_data_io, NULL, NULL);
 550         g_io_channel_set_flags(dev_info->intr_data_io, G_IO_FLAG_NONBLOCK, NULL);
 551         g_io_channel_set_close_on_unref(dev_info->intr_data_io, TRUE);
 552         dev_info->ctrl_data_id = g_io_add_watch(dev_info->ctrl_data_io,
 553                         G_IO_IN | G_IO_HUP | G_IO_ERR | G_IO_NVAL,
 554                         __received_cb, dev_info);
 555         dev_info->intr_data_id = g_io_add_watch(dev_info->intr_data_io,
 556                         G_IO_IN | G_IO_HUP | G_IO_ERR | G_IO_NVAL,
 557                         __received_cb, dev_info);
 558         device_list = g_slist_append(device_list, dev_info);
 559
 560         __hid_connected_cb(dev_info, BLUETOOTH_ERROR_NONE);
 561
 562         return 0;
 563 }
 564
 565 void _bt_hid_free_hid_info(void)
 566 {
 567         g_slist_free_full(device_list, __free_hid_info);
 568
 569         device_list = NULL;
 570 }
 571
 572 BT_EXPORT_API int bluetooth_hid_device_init(hid_cb_func_ptr callback_ptr, void *user_data)
 573 {
 574         int ret;
 575
 576         /* Register HID Device events */
 577         BT_INFO("BT_HID_DEVICE_EVENT");
 578         ret = _bt_register_event(BT_HID_DEVICE_EVENT , (void *)callback_ptr, user_data);
 579
 580         if (ret != BLUETOOTH_ERROR_NONE &&
 581              ret != BLUETOOTH_ERROR_ALREADY_INITIALIZED) {
 582                 BT_ERR("Fail to init the event handler");
 583                 return ret;
 584         }
 585
 586         _bt_set_user_data(BT_HID, (void *)callback_ptr, user_data);
 587
 588         return BLUETOOTH_ERROR_NONE;
 589 }
 590
 591 BT_EXPORT_API int bluetooth_hid_device_deinit(void)
 592 {
 593         int ret;
 594
 595         ret = _bt_unregister_event(BT_HID_DEVICE_EVENT);
 596
 597         if (ret != BLUETOOTH_ERROR_NONE) {
 598                 BT_ERR("Fail to deinit the event handler");
 599                 return ret;
 600         }
 601
 602         _bt_set_user_data(BT_HID, NULL, NULL);
 603
 604         return BLUETOOTH_ERROR_NONE;
 605 }
 606
 607 BT_EXPORT_API int bluetooth_hid_device_activate(void)
 608 {
 609         GVariant *reply;
 610         GError *err = NULL;
 611
 612         BT_CHECK_ENABLED(return);
 613
 614         if (_bt_check_privilege(BT_CHECK_PRIVILEGE, BT_HID_DEVICE_ACTIVATE)
 615                  == BLUETOOTH_ERROR_PERMISSION_DEINED) {
 616                 BT_ERR("Don't have a privilege to use this API");
 617                 return BLUETOOTH_ERROR_PERMISSION_DEINED;
 618         }
 619
 620         reply = __bt_hid_agent_dbus_send(BT_HID_AGENT_OBJECT_PATH,
 621                         BT_HID_SERVICE_INTERFACE,
 622                         "RegisterApplication", &err, NULL);
 623
 624         if (!reply) {
 625                 int ret = BLUETOOTH_ERROR_INTERNAL;
 626                 BT_ERR("Error returned in method call");
 627                 if (err) {
 628                         BT_ERR("Error = %s", err->message);
 629                         g_dbus_error_strip_remote_error(err);
 630                         if (g_strrstr(err->message, BT_ERROR_ALREADY_EXIST))
 631                                 ret = BLUETOOTH_ERROR_IN_PROGRESS;
 632                         else
 633                                 ret = BLUETOOTH_ERROR_INTERNAL;
 634                         g_clear_error(&err);
 635                 }
 636                 return ret;
 637         }
 638
 639         g_variant_unref(reply);
 640
 641         return BLUETOOTH_ERROR_NONE;
 642 }
 643
 644 BT_EXPORT_API int bluetooth_hid_device_deactivate(void)
 645 {
 646         GVariant *reply;
 647         GError *err = NULL;
 648
 649         BT_CHECK_ENABLED(return);
 650
 651         if (_bt_check_privilege(BT_CHECK_PRIVILEGE, BT_HID_DEVICE_DEACTIVATE)
 652                  == BLUETOOTH_ERROR_PERMISSION_DEINED) {
 653                 BT_ERR("Don't have a privilege to use this API");
 654                 return BLUETOOTH_ERROR_PERMISSION_DEINED;
 655         }
 656
 657         reply = __bt_hid_agent_dbus_send(BT_HID_AGENT_OBJECT_PATH,
 658                         BT_HID_SERVICE_INTERFACE,
 659                         "UnregisterApplication", &err, NULL);
 660
 661         if (!reply) {
 662                 int ret = BLUETOOTH_ERROR_INTERNAL;
 663                 BT_ERR("Error returned in method call");
 664                 if (err) {
 665                         BT_ERR("Error = %s", err->message);
 666                         g_dbus_error_strip_remote_error(err);
 667                         if (g_strrstr(err->message, BT_ERROR_NOT_AVAILABLE))
 668                                 ret = BLUETOOTH_ERROR_NOT_IN_OPERATION;
 669                         else
 670                                 ret = BLUETOOTH_ERROR_INTERNAL;
 671                         g_clear_error(&err);
 672                 }
 673                 return ret;
 674         }
 675
 676         g_variant_unref(reply);
 677
 678         _bt_hid_free_hid_info();
 679
 680         return BLUETOOTH_ERROR_NONE;
 681 }
 682
 683 BT_EXPORT_API int bluetooth_hid_device_connect(const char *remote_addr)
 684 {
 685         char device_address[BT_ADDRESS_STRING_SIZE] = {0};
 686         hid_connected_device_info_t *info = NULL;
 687         int ret;
 688         BT_DBG("+");
 689         BT_CHECK_PARAMETER(remote_addr, return);
 690
 691         BT_CHECK_ENABLED(return);
 692
 693         info = __find_hid_info_with_address(remote_addr);
 694         if (info) {
 695                 BT_ERR("Connection Already Exists");
 696                 return BLUETOOTH_ERROR_ALREADY_CONNECT;
 697         }
 698         if (_bt_check_privilege(BT_CHECK_PRIVILEGE, BT_HID_DEVICE_CONNECT)
 699                  == BLUETOOTH_ERROR_PERMISSION_DEINED) {
 700                 BT_ERR("Don't have a privilege to use this API");
 701                 return BLUETOOTH_ERROR_PERMISSION_DEINED;
 702         }
 703
 704         memcpy(device_address, remote_addr, BT_ADDRESS_STRING_SIZE);
 705         ret = _bt_connect_profile(device_address, HID_DEVICE_UUID,
 706                                 __hid_connect_response_cb, NULL);
 707
 708         return ret;
 709 }
 710 BT_EXPORT_API int bluetooth_hid_device_disconnect(const char *remote_addr)
 711 {
 712         BT_CHECK_PARAMETER(remote_addr, return);
 713
 714         BT_CHECK_ENABLED(return);
 715
 716         if (_bt_check_privilege(BT_CHECK_PRIVILEGE, BT_HID_DEVICE_DISCONNECT)
 717                  == BLUETOOTH_ERROR_PERMISSION_DEINED) {
 718                 BT_ERR("Don't have a privilege to use this API");
 719                 return BLUETOOTH_ERROR_PERMISSION_DEINED;
 720         }
 721
 722         hid_connected_device_info_t *info = NULL;
 723
 724         info = __find_hid_info_with_address(remote_addr);
 725         if (info == NULL)
 726                 return BLUETOOTH_ERROR_INVALID_PARAM;
 727
 728         _bt_disconnect_profile((char *)remote_addr, HID_DEVICE_UUID, NULL, NULL);
 729
 730         info->disconnect_idle_id = g_idle_add((GSourceFunc)__hid_disconnect, info);
 731
 732         BT_DBG("-");
 733         return BLUETOOTH_ERROR_NONE;
 734 }
 735 BT_EXPORT_API int bluetooth_hid_device_send_mouse_event(const char *remote_addr,
 736                                         hid_send_mouse_event_t send_event)
 737 {
 738         int result;
 739         int written = 0;
 740         hid_connected_device_info_t *info = NULL;
 741
 742         BT_CHECK_PARAMETER(remote_addr, return);
 743
 744         switch (privilege_token_send_mouse) {
 745         case 0:
 746                 result = _bt_check_privilege(BT_CHECK_PRIVILEGE, BT_HID_DEVICE_SEND_MOUSE_EVENT);
 747
 748                 if (result == BLUETOOTH_ERROR_NONE) {
 749                         privilege_token_send_mouse = 1; /* Have a permission */
 750                 } else if (result == BLUETOOTH_ERROR_PERMISSION_DEINED) {
 751                         BT_ERR("Don't have a privilege to use this API");
 752                         privilege_token_send_mouse = -1; /* Don't have a permission */
 753                         return BLUETOOTH_ERROR_PERMISSION_DEINED;
 754                 } else {
 755                         /* Just break - It is not related with permission error */
 756                 }
 757                 break;
 758         case 1:
 759                 /* Already have a privilege */
 760                 break;
 761         case -1:
 762                 return BLUETOOTH_ERROR_PERMISSION_DEINED;
 763         default:
 764                 /* Invalid privilge token value */
 765                 return BLUETOOTH_ERROR_INTERNAL;
 766         }
 767         info = __find_hid_info_with_address(remote_addr);
 768         if (info == NULL) {
 769                 BT_ERR("Connection Information not found");
 770                 return BLUETOOTH_ERROR_INVALID_PARAM;
 771         }
 772
 773         if (info->intr_fd >= 0) {
 774                 written = write(info->intr_fd, &send_event, sizeof(send_event));
 775         } else {
 776                 BT_ERR("intr_fd(%d) is invalid.", info->intr_fd);
 777                 __free_hid_info(info);
 778                 return BLUETOOTH_ERROR_INTERNAL;
 779         }
 780
 781         return written;
 782 }
 783
 784 BT_EXPORT_API int bluetooth_hid_device_send_key_event(const char *remote_addr,
 785                                         hid_send_key_event_t send_event)
 786 {
 787         int result;
 788         int written = 0;
 789         hid_connected_device_info_t *info = NULL;
 790
 791         BT_CHECK_PARAMETER(remote_addr, return);
 792
 793         switch (privilege_token_send_key) {
 794         case 0:
 795                 result = _bt_check_privilege(BT_CHECK_PRIVILEGE, BT_HID_DEVICE_SEND_KEY_EVENT);
 796
 797                 if (result == BLUETOOTH_ERROR_NONE) {
 798                         privilege_token_send_key = 1; /* Have a permission */
 799                 } else if (result == BLUETOOTH_ERROR_PERMISSION_DEINED) {
 800                         BT_ERR("Don't have a privilege to use this API");
 801                         privilege_token_send_key = -1; /* Don't have a permission */
 802                         return BLUETOOTH_ERROR_PERMISSION_DEINED;
 803                 } else {
 804                         /* Just break - It is not related with permission error */
 805                 }
 806                 break;
 807         case 1:
 808                 /* Already have a privilege */
 809                 break;
 810         case -1:
 811                 return BLUETOOTH_ERROR_PERMISSION_DEINED;
 812         default:
 813                 /* Invalid privilge token value */
 814                 return BLUETOOTH_ERROR_INTERNAL;
 815         }
 816
 817         info = __find_hid_info_with_address(remote_addr);
 818         if (info == NULL) {
 819                 BT_ERR("Connection Information not found");
 820                 return BLUETOOTH_ERROR_INVALID_PARAM;
 821         }
 822
 823         if (info->intr_fd >= 0) {
 824                 written = write(info->intr_fd, &send_event, sizeof(send_event));
 825         } else {
 826                 BT_ERR("intr_fd(%d) is invalid.", info->intr_fd);
 827                 __free_hid_info(info);
 828                 return BLUETOOTH_ERROR_INTERNAL;
 829         }
 830
 831         return written;
 832 }
 833
 834 BT_EXPORT_API int bluetooth_hid_device_send_custom_event(const char *remote_addr,
 835                         unsigned char btcode, unsigned char report_id,
 836                         const char *data, unsigned int data_len)
 837 {
 838         int result;
 839         int written = 0;
 840         hid_connected_device_info_t *info = NULL;
 841         char *send_event = NULL;
 842
 843         BT_CHECK_PARAMETER(remote_addr, return);
 844         BT_CHECK_PARAMETER(data, return);
 845
 846         switch (privilege_token_send_key) {
 847         case 0:
 848                 result = _bt_check_privilege(BT_CHECK_PRIVILEGE, BT_HID_DEVICE_SEND_CUSTOM_EVENT);
 849
 850                 if (result == BLUETOOTH_ERROR_NONE) {
 851                         privilege_token_send_key = 1; /* Have a permission */
 852                 } else if (result == BLUETOOTH_ERROR_PERMISSION_DEINED) {
 853                         BT_ERR("Don't have a privilege to use this API");
 854                         privilege_token_send_key = -1; /* Don't have a permission */
 855                         return BLUETOOTH_ERROR_PERMISSION_DEINED;
 856                 } else {
 857                         /* Just break - It is not related with permission error */
 858                 }
 859                 break;
 860         case 1:
 861                 /* Already have a privilege */
 862                 break;
 863         case -1:
 864                 return BLUETOOTH_ERROR_PERMISSION_DEINED;
 865         default:
 866                 /* Invalid privilge token value */
 867                 return BLUETOOTH_ERROR_INTERNAL;
 868         }
 869
 870         info = __find_hid_info_with_address(remote_addr);
 871         if (info == NULL) {
 872                 BT_ERR("Connection Information not found");
 873                 return BLUETOOTH_ERROR_INVALID_PARAM;
 874         }
 875
 876         if (info->intr_fd >= 0) {
 877                 send_event = g_malloc0(data_len + 2);
 878
 879                 send_event[0] = (char)btcode;
 880                 send_event[1] = (char)report_id;
 881                 memcpy(send_event + 2, data, data_len);
 882
 883                 written = write(info->intr_fd, send_event, data_len + 2);
 884                 g_free(send_event);
 885         } else {
 886                 BT_ERR("intr_fd(%d) is invalid.", info->intr_fd);
 887                 __free_hid_info(info);
 888                 return BLUETOOTH_ERROR_INTERNAL;
 889         }
 890
 891         return written;
 892 }
 893
 894 BT_EXPORT_API int bluetooth_hid_device_reply_to_report(const char *remote_addr,
 895                                 bt_hid_header_type_t htype,
 896                                 bt_hid_param_type_t ptype,
 897                                 const char *data,
 898                                 unsigned int data_len)
 899 {
 900         int result;
 901         struct reports output_report = { 0 };
 902         int bytes = -1;
 903         hid_connected_device_info_t *info = NULL;
 904
 905         BT_CHECK_PARAMETER(remote_addr, return);
 906         if (data_len > 20) {
 907                 BT_ERR("data(len:%d) overflow", data_len);
 908                 return BLUETOOTH_ERROR_INVALID_PARAM;
 909         }
 910
 911         info = __find_hid_info_with_address(remote_addr);
 912         if (info == NULL) {
 913                 BT_ERR("Connection Information not found");
 914                 return BLUETOOTH_ERROR_INVALID_PARAM;
 915         }
 916
 917         if (info->ctrl_fd < 0) {
 918                 BT_ERR("ctrl_fd(%d) is invalid.", info->ctrl_fd);
 919                 __free_hid_info(info);
 920                 return BLUETOOTH_ERROR_INTERNAL;
 921         }
 922
 923         switch (privilege_token_reply) {
 924         case 0:
 925                 result = _bt_check_privilege(BT_CHECK_PRIVILEGE, BT_HID_DEVICE_SEND_REPLY_TO_REPORT);
 926
 927                 if (result == BLUETOOTH_ERROR_NONE) {
 928                         privilege_token_reply = 1; /* Have a permission */
 929                 } else if (result == BLUETOOTH_ERROR_PERMISSION_DEINED) {
 930                         BT_ERR("Don't have a privilege to use this API");
 931                         privilege_token_reply = -1; /* Don't have a permission */
 932                         return BLUETOOTH_ERROR_PERMISSION_DEINED;
 933                 } else {
 934                         /* Just break - It is not related with permission error */
 935                 }
 936                 break;
 937         case 1:
 938                 /* Already have a privilege */
 939                 break;
 940         case -1:
 941                 return BLUETOOTH_ERROR_PERMISSION_DEINED;
 942         default:
 943                 /* Invalid privilge token value */
 944                 return BLUETOOTH_ERROR_INTERNAL;
 945         }
 946
 947         BT_INFO("htype %d ptype %d", htype, ptype);
 948         switch (htype) {
 949         case HTYPE_TRANS_GET_REPORT: {
 950                 switch (ptype) {
 951                 case PTYPE_DATA_RTYPE_INPUT: {
 952                         output_report.type = BT_HID_TRANS_DATA |
 953                                         BT_HID_DATA_RTYPE_INPUT;
 954                         memcpy(output_report.rep_data, data, data_len);
 955                         bytes = write(info->ctrl_fd, &output_report,
 956                                                 sizeof(output_report));
 957                         BT_DBG("Bytes Written %d", bytes);
 958                         break;
 959                 }
 960                 default:
 961                         BT_INFO("Not Supported");
 962                         break;
 963         }
 964         break;
 965
 966         case HTYPE_TRANS_GET_PROTOCOL: {
 967                 output_report.type = BT_HID_TRANS_DATA | BT_HID_DATA_RTYPE_OUTPUT;
 968                 output_report.rep_data[0] = data[0];
 969                 bytes = write(info->ctrl_fd, &output_report, 2);
 970                 break;
 971         }
 972
 973         case HTYPE_TRANS_SET_PROTOCOL: {
 974                 output_report.type = BT_HID_TRANS_DATA | BT_HID_DATA_RTYPE_INPUT;
 975                 memcpy(output_report.rep_data, data, data_len);
 976                 bytes = write(info->ctrl_fd, &output_report,
 977                                 sizeof(output_report));
 978                 break;
 979         }
 980
 981         case HTYPE_TRANS_HANDSHAKE: {
 982                 output_report.type = BT_HID_TRANS_HANDSHAKE | data[0];
 983                 memset(output_report.rep_data, 0, sizeof(output_report.rep_data));
 984                 bytes = write(info->ctrl_fd,  &output_report.type,
 985                                 sizeof(output_report.type));
 986                 break;
 987         }
 988
 989         case HTYPE_TRANS_DATA: {
 990                 output_report.type = BT_HID_TRANS_DATA;
 991                 memcpy(output_report.rep_data, data, data_len);
 992                 bytes = write(info->ctrl_fd,  &output_report.type,
 993                                 data_len + 1);
 994                 break;
 995         }
 996
 997         case HTYPE_TRANS_GET_IDLE: {
 998                 output_report.type = BT_HID_TRANS_DATA | BT_HID_DATA_RTYPE_OUTPUT;
 999                 output_report.rep_data[0] = data[0];
1000                 bytes = write(info->ctrl_fd, &output_report, 2);
1001                 break;
1002         }
1003
1004         case HTYPE_TRANS_SET_IDLE: {
1005                 output_report.type = BT_HID_TRANS_DATA | BT_HID_DATA_RTYPE_INPUT;
1006                 memcpy(output_report.rep_data, data, data_len);
1007                 bytes = write(info->ctrl_fd, &output_report,
1008                                 sizeof(output_report));
1009                 break;
1010         }
1011
1012         default:
1013                 break;
1014                 }
1015         }
1016
1017         BT_DBG("Bytes Written %d", bytes);
1018
1019         return bytes;
1020 }