bt-api/bt-event-handler.c

   1 /*
   2  * bluetooth-frwk
   3  *
   4  * Copyright (c) 2012-2013 Samsung Electronics Co., Ltd.
   5  *
   6  * Licensed under the Apache License, Version 2.0 (the "License");
   7  * you may not use this file except in compliance with the License.
   8  * You may obtain a copy of the License at
   9  *
  10  *              http://www.apache.org/licenses/LICENSE-2.0
  11  *
  12  * Unless required by applicable law or agreed to in writing, software
  13  * distributed under the License is distributed on an "AS IS" BASIS,
  14  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  15  * See the License for the specific language governing permissions and
  16  * limitations under the License.
  17  *
  18  */
  19
  20 #include <string.h>
  21 #include <dbus/dbus-glib.h>
  22 #include <dbus/dbus-glib-lowlevel.h>
  23 #include <dbus/dbus.h>
  24 #include <glib.h>
  25 #include <dlog.h>
  26 #include <vconf.h>
  27
  28 #include "bluetooth-api.h"
  29 #include "bluetooth-audio-api.h"
  30 #include "bt-internal-types.h"
  31
  32 #include "bt-common.h"
  33 #include "bt-event-handler.h"
  34 #include "bt-request-sender.h"
  35
  36 typedef struct {
  37         int server_fd;
  38 } bt_server_info_t;
  39
  40 typedef struct {
  41         int request_id;
  42 } bt_sending_info_t;
  43
  44 static int obex_server_id;
  45 static gboolean is_initialized;
  46 static GSList *sending_list = NULL;
  47 static GSList *server_list = NULL;
  48 static GSList *event_list = NULL;
  49
  50 void _bt_add_push_request_id(int request_id)
  51 {
  52         bt_sending_info_t *info;
  53
  54         info = g_new0(bt_sending_info_t, 1);
  55         info->request_id = request_id;
  56
  57         sending_list = g_slist_append(sending_list, info);
  58 }
  59
  60 static gboolean __bt_is_request_id_exist(int request_id)
  61 {
  62         GSList *l;
  63         bt_sending_info_t *info;
  64
  65         for (l = sending_list; l != NULL; l = g_slist_next(l)) {
  66                 info = l->data;
  67                 if (info == NULL)
  68                         continue;
  69
  70                 retv_if(info->request_id == request_id, TRUE);
  71         }
  72
  73         return FALSE;
  74 }
  75
  76 static void __bt_remove_push_request_id(int request_id)
  77 {
  78         GSList *l;
  79         bt_sending_info_t *info;
  80
  81         for (l = sending_list; l != NULL; l = g_slist_next(l)) {
  82                 info = l->data;
  83                 if (info == NULL)
  84                         continue;
  85
  86                 if (info->request_id == request_id) {
  87                         sending_list = g_slist_remove(sending_list, (void *)info);
  88                         g_free(info);
  89                         break;
  90                 }
  91         }
  92 }
  93
  94 static void __bt_remove_all_push_request_id(void)
  95 {
  96         GSList *l;
  97         bt_sending_info_t *info;
  98
  99         for (l = sending_list; l != NULL; l = g_slist_next(l)) {
 100                 info = l->data;
 101                 g_free(info);
 102         }
 103
 104         g_slist_free(sending_list);
 105         sending_list = NULL;
 106 }
 107
 108 static void __bt_remove_all_server(void)
 109 {
 110         GSList *l;
 111         bt_server_info_t *info;
 112
 113         for (l = server_list; l != NULL; l = g_slist_next(l)) {
 114                 info = l->data;
 115                 g_free(info);
 116         }
 117
 118         g_slist_free(server_list);
 119         server_list = NULL;
 120 }
 121
 122 static gboolean __bt_is_server_exist(int server_fd)
 123 {
 124         GSList *l;
 125         bt_server_info_t *info;
 126
 127         for (l = server_list; l != NULL; l = g_slist_next(l)) {
 128                 info = l->data;
 129                 if (info == NULL)
 130                         continue;
 131
 132                 retv_if(info->server_fd == server_fd, TRUE);
 133         }
 134
 135         return FALSE;
 136 }
 137
 138 static void __bt_get_uuid_info(bluetooth_device_info_t *dev_info,
 139                                 char **uuids,
 140                                 int uuid_count)
 141 {
 142         int i;
 143         char **parts;
 144
 145         ret_if(dev_info == NULL);
 146         ret_if(uuids == NULL);
 147         ret_if(uuid_count <= 0);
 148
 149         dev_info->service_index = uuid_count;
 150
 151         for (i = 0; i < uuid_count && uuids[i] != NULL; i++) {
 152                 g_strlcpy(dev_info->uuids[i], uuids[i], BLUETOOTH_UUID_STRING_MAX);
 153
 154                 parts = g_strsplit(uuids[i], "-", -1);
 155
 156                 if (parts == NULL || parts[0] == NULL) {
 157                         g_strfreev(parts);
 158                         continue;
 159                 }
 160
 161                 dev_info->service_list_array[i] = g_ascii_strtoull(parts[0], NULL, 16);
 162                 g_strfreev(parts);
 163         }
 164 }
 165
 166 static bluetooth_device_info_t *__bt_get_device_info_in_message(DBusMessage *msg, int *ret)
 167 {
 168         bluetooth_device_info_t *dev_info;
 169         char *address = NULL;
 170         char *name = NULL;
 171         char **uuids = NULL;
 172         unsigned int class = 0;
 173         int rssi = 0;
 174         gboolean paired = FALSE;
 175         gboolean connected = FALSE;
 176         gboolean trust = FALSE;
 177         int uuid_count = 0;
 178         int result = BLUETOOTH_ERROR_NONE;
 179
 180         if (!dbus_message_get_args(msg, NULL,
 181                 DBUS_TYPE_INT32, &result,
 182                 DBUS_TYPE_STRING, &address,
 183                 DBUS_TYPE_UINT32, &class,
 184                 DBUS_TYPE_INT16, &rssi,
 185                 DBUS_TYPE_STRING, &name,
 186                 DBUS_TYPE_BOOLEAN, &paired,
 187                 DBUS_TYPE_BOOLEAN, &connected,
 188                 DBUS_TYPE_BOOLEAN, &trust,
 189                 DBUS_TYPE_ARRAY, DBUS_TYPE_STRING,
 190                 &uuids, &uuid_count,
 191                 DBUS_TYPE_INVALID)) {
 192                 BT_ERR("Unexpected parameters in signal");
 193                 return NULL;
 194         }
 195
 196         dev_info = g_malloc0(sizeof(bluetooth_device_info_t));
 197
 198         dev_info->rssi = rssi;
 199         dev_info->paired = paired;
 200         dev_info->connected = connected;
 201         dev_info->paired = paired;
 202         dev_info->trust = trust;
 203
 204         g_strlcpy(dev_info->device_name.name, name, BLUETOOTH_DEVICE_NAME_LENGTH_MAX + 1);
 205
 206         _bt_divide_device_class(&dev_info->device_class, class);
 207
 208         _bt_convert_addr_string_to_type(dev_info->device_address.addr,
 209                                         address);
 210
 211         if (uuid_count > 0)
 212                 __bt_get_uuid_info(dev_info, uuids, uuid_count);
 213
 214         *ret = result;
 215
 216         return dev_info;
 217 }
 218
 219 static DBusHandlerResult __bt_adapter_event_filter(DBusConnection *conn,
 220                                            DBusMessage *msg, void *data)
 221 {
 222         bt_event_info_t *event_info;
 223         int result = BLUETOOTH_ERROR_NONE;
 224         const char *member = dbus_message_get_member(msg);
 225
 226         event_info = (bt_event_info_t *)data;
 227         retv_if(event_info == NULL, DBUS_HANDLER_RESULT_NOT_YET_HANDLED);
 228
 229         if (dbus_message_get_type(msg) != DBUS_MESSAGE_TYPE_SIGNAL)
 230                 return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
 231
 232         if (!dbus_message_has_interface(msg, BT_EVENT_SERVICE))
 233                 return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
 234
 235         if (!dbus_message_has_path(msg, BT_ADAPTER_PATH))
 236                 return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
 237
 238
 239         retv_if(member == NULL, DBUS_HANDLER_RESULT_NOT_YET_HANDLED);
 240
 241         if (strcasecmp(member, BT_ENABLED) == 0) {
 242                 if (!dbus_message_get_args(msg, NULL,
 243                         DBUS_TYPE_INT32, &result,
 244                         DBUS_TYPE_INVALID)) {
 245                         BT_ERR("Unexpected parameters in signal");
 246                         return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
 247                 }
 248
 249                 if (result == BLUETOOTH_ERROR_NONE) {
 250                         if (vconf_set_int(BT_OFF_DUE_TO_FLIGHT_MODE, 0) != 0)
 251                                 BT_ERR("Set vconf failed\n");
 252                 }
 253
 254                 _bt_common_event_cb(BLUETOOTH_EVENT_ENABLED,
 255                                 result, NULL,
 256                                 event_info->cb, event_info->user_data);
 257         } else if (strcasecmp(member, BT_DISABLED) == 0) {
 258                 _bt_common_event_cb(BLUETOOTH_EVENT_DISABLED,
 259                                 BLUETOOTH_ERROR_NONE, NULL,
 260                                 event_info->cb, event_info->user_data);
 261
 262                 obex_server_id = BT_NO_SERVER;
 263                 __bt_remove_all_server();
 264                 __bt_remove_all_push_request_id();
 265         } else if (strcasecmp(member, BT_DISCOVERABLE_MODE_CHANGED) == 0) {
 266                 int mode = 0;
 267
 268                 if (!dbus_message_get_args(msg, NULL,
 269                         DBUS_TYPE_INT32, &result,
 270                         DBUS_TYPE_INT16, &mode,
 271                         DBUS_TYPE_INVALID)) {
 272                         BT_ERR("Unexpected parameters in signal");
 273                         return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
 274                 }
 275
 276                 _bt_common_event_cb(BLUETOOTH_EVENT_DISCOVERABLE_MODE_CHANGED,
 277                                 result, &mode,
 278                                 event_info->cb, event_info->user_data);
 279         } else if (strcasecmp(member, BT_DISCOVERABLE_TIMEOUT_CHANGED) == 0) {
 280                 int timeout = 0;
 281
 282                 if (!dbus_message_get_args(msg, NULL,
 283                         DBUS_TYPE_INT32, &result,
 284                         DBUS_TYPE_INT16, &timeout,
 285                         DBUS_TYPE_INVALID)) {
 286                         BT_ERR("Unexpected parameters in signal");
 287                         return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
 288                 }
 289
 290                 _bt_common_event_cb(BLUETOOTH_EVENT_DISCOVERABLE_TIMEOUT_CHANGED,
 291                                 result, &timeout,
 292                                 event_info->cb, event_info->user_data);
 293         } else if (strcasecmp(member, BT_ADAPTER_NAME_CHANGED) == 0) {
 294                 char *adapter_name = NULL;
 295
 296                 if (!dbus_message_get_args(msg, NULL,
 297                         DBUS_TYPE_INT32, &result,
 298                         DBUS_TYPE_STRING, &adapter_name,
 299                         DBUS_TYPE_INVALID)) {
 300                         BT_ERR("Unexpected parameters in signal");
 301                         return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
 302                 }
 303
 304                 _bt_common_event_cb(BLUETOOTH_EVENT_LOCAL_NAME_CHANGED,
 305                                 result, adapter_name,
 306                                 event_info->cb, event_info->user_data);
 307         } else if (strcasecmp(member, BT_DISCOVERY_STARTED) == 0) {
 308                 _bt_common_event_cb(BLUETOOTH_EVENT_DISCOVERY_STARTED,
 309                                 BLUETOOTH_ERROR_NONE, NULL,
 310                                 event_info->cb, event_info->user_data);
 311         } else if (strcasecmp(member, BT_DISCOVERY_FINISHED) == 0) {
 312                 if (!dbus_message_get_args(msg, NULL,
 313                         DBUS_TYPE_INT32, &result,
 314                         DBUS_TYPE_INVALID)) {
 315                         BT_ERR("Unexpected parameters in signal");
 316                         return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
 317                 }
 318
 319                 _bt_common_event_cb(BLUETOOTH_EVENT_DISCOVERY_FINISHED,
 320                                 result, NULL,
 321                                 event_info->cb, event_info->user_data);
 322         } else if (strcasecmp(member, BT_DEVICE_FOUND) == 0) {
 323                 int event;
 324                 bluetooth_device_info_t *device_info;
 325
 326                 device_info = __bt_get_device_info_in_message(msg, &result);
 327                 retv_if(device_info == NULL, DBUS_HANDLER_RESULT_NOT_YET_HANDLED);
 328
 329                 if (strlen(device_info->device_name.name) > 0) {
 330                         event = BLUETOOTH_EVENT_REMOTE_DEVICE_NAME_UPDATED;
 331                 } else {
 332                         event = BLUETOOTH_EVENT_REMOTE_DEVICE_FOUND;
 333                 }
 334
 335                 _bt_common_event_cb(event,
 336                                 result, device_info,
 337                                 event_info->cb, event_info->user_data);
 338
 339                 g_free(device_info);
 340         } else if (strcasecmp(member, BT_DEVICE_DISAPPEARED) == 0) {
 341                 bluetooth_device_info_t *device_info;
 342
 343                 device_info = __bt_get_device_info_in_message(msg, &result);
 344                 retv_if(device_info == NULL, DBUS_HANDLER_RESULT_NOT_YET_HANDLED);
 345
 346
 347                 _bt_common_event_cb(BLUETOOTH_EVENT_REMOTE_DEVICE_DISAPPEARED,
 348                                 result, device_info,
 349                                 event_info->cb, event_info->user_data);
 350                 g_free(device_info);
 351         } else if (strcasecmp(member, BT_BOND_CREATED) == 0) {
 352                 bluetooth_device_info_t *device_info;
 353
 354                 device_info = __bt_get_device_info_in_message(msg, &result);
 355
 356                 _bt_common_event_cb(BLUETOOTH_EVENT_BONDING_FINISHED,
 357                                 result, device_info,
 358                                 event_info->cb, event_info->user_data);
 359
 360                 g_free(device_info);
 361         } else if (strcasecmp(member, BT_BOND_DESTROYED) == 0) {
 362                 char *address = NULL;
 363                 bluetooth_device_address_t dev_address = { {0} };
 364
 365                 if (!dbus_message_get_args(msg, NULL,
 366                         DBUS_TYPE_INT32, &result,
 367                         DBUS_TYPE_STRING, &address,
 368                         DBUS_TYPE_INVALID)) {
 369                         BT_ERR("Unexpected parameters in signal");
 370                         return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
 371                 }
 372
 373                 _bt_convert_addr_string_to_type(dev_address.addr,
 374                                                 address);
 375
 376                 _bt_common_event_cb(BLUETOOTH_EVENT_BONDED_DEVICE_REMOVED,
 377                                 result, &dev_address,
 378                                 event_info->cb, event_info->user_data);
 379         } else if (strcasecmp(member, BT_SERVICE_SEARCHED) == 0) {
 380                 bluetooth_device_info_t *device_info;
 381                 bt_sdp_info_t sdp_info;
 382
 383                 device_info = __bt_get_device_info_in_message(msg, &result);
 384
 385                 memset(&sdp_info, 0x00, sizeof(bt_sdp_info_t));
 386
 387                 sdp_info.service_index = device_info->service_index;
 388
 389                 memcpy(&sdp_info.device_addr,
 390                         &device_info->device_address,
 391                         BLUETOOTH_ADDRESS_LENGTH);
 392
 393                 memcpy(sdp_info.service_list_array,
 394                         device_info->service_list_array,
 395                         BLUETOOTH_MAX_SERVICES_FOR_DEVICE);
 396
 397                 memcpy(sdp_info.uuids,
 398                         device_info->uuids,
 399                         BLUETOOTH_MAX_SERVICES_FOR_DEVICE * BLUETOOTH_UUID_STRING_MAX);
 400
 401                 _bt_common_event_cb(BLUETOOTH_EVENT_SERVICE_SEARCHED,
 402                                 result, &sdp_info,
 403                                 event_info->cb, event_info->user_data);
 404
 405                 g_free(device_info);
 406         }
 407
 408         return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
 409 }
 410
 411 static DBusHandlerResult __bt_device_event_filter(DBusConnection *conn,
 412                                            DBusMessage *msg, void *data)
 413 {
 414         bt_event_info_t *event_info;
 415         int result = BLUETOOTH_ERROR_NONE;
 416         const char *member = dbus_message_get_member(msg);
 417
 418         event_info = (bt_event_info_t *)data;
 419         retv_if(event_info == NULL, DBUS_HANDLER_RESULT_NOT_YET_HANDLED);
 420
 421         if (dbus_message_get_type(msg) != DBUS_MESSAGE_TYPE_SIGNAL)
 422                 return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
 423
 424         if (!dbus_message_has_interface(msg, BT_EVENT_SERVICE))
 425                 return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
 426
 427         if (!dbus_message_has_path(msg, BT_DEVICE_PATH))
 428                 return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
 429
 430
 431         retv_if(member == NULL, DBUS_HANDLER_RESULT_NOT_YET_HANDLED);
 432
 433         if (strcasecmp(member, BT_DEVICE_CONNECTED) == 0) {
 434                 char *address = NULL;
 435                 bluetooth_device_address_t dev_address = { {0} };
 436
 437                 if (!dbus_message_get_args(msg, NULL,
 438                         DBUS_TYPE_INT32, &result,
 439                         DBUS_TYPE_STRING, &address,
 440                         DBUS_TYPE_INVALID)) {
 441                         BT_DBG("Unexpected parameters in signal");
 442                         return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
 443                 }
 444
 445                 _bt_convert_addr_string_to_type(dev_address.addr,
 446                                                 address);
 447
 448                 _bt_common_event_cb(BLUETOOTH_EVENT_DEVICE_CONNECTED,
 449                                 result, &dev_address,
 450                                 event_info->cb, event_info->user_data);
 451         } else if (strcasecmp(member, BT_DEVICE_DISCONNECTED) == 0) {
 452                 char *address = NULL;
 453                 bluetooth_device_address_t dev_address = { {0} };
 454
 455                 if (!dbus_message_get_args(msg, NULL,
 456                         DBUS_TYPE_INT32, &result,
 457                         DBUS_TYPE_STRING, &address,
 458                         DBUS_TYPE_INVALID)) {
 459                         BT_DBG("Unexpected parameters in signal");
 460                         return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
 461                 }
 462
 463                 _bt_convert_addr_string_to_type(dev_address.addr,
 464                                                 address);
 465
 466                 _bt_common_event_cb(BLUETOOTH_EVENT_DEVICE_DISCONNECTED,
 467                                 result, &dev_address,
 468                                 event_info->cb, event_info->user_data);
 469         }
 470
 471         return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
 472 }
 473
 474 static DBusHandlerResult __bt_hid_event_filter(DBusConnection *conn,
 475                                            DBusMessage *msg, void *data)
 476 {
 477         bt_event_info_t *event_info;
 478         int result = BLUETOOTH_ERROR_NONE;
 479         const char *member = dbus_message_get_member(msg);
 480
 481         event_info = (bt_event_info_t *)data;
 482         retv_if(event_info == NULL, DBUS_HANDLER_RESULT_NOT_YET_HANDLED);
 483
 484         if (dbus_message_get_type(msg) != DBUS_MESSAGE_TYPE_SIGNAL)
 485                 return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
 486
 487         if (!dbus_message_has_interface(msg, BT_EVENT_SERVICE))
 488                 return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
 489
 490         if (!dbus_message_has_path(msg, BT_HID_PATH))
 491                 return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
 492
 493         retv_if(member == NULL, DBUS_HANDLER_RESULT_NOT_YET_HANDLED);
 494
 495         if (strcasecmp(member, BT_INPUT_CONNECTED) == 0) {
 496                 char *address = NULL;
 497                 bluetooth_device_address_t dev_address = { {0} };
 498
 499                 if (!dbus_message_get_args(msg, NULL,
 500                         DBUS_TYPE_INT32, &result,
 501                         DBUS_TYPE_STRING, &address,
 502                         DBUS_TYPE_INVALID)) {
 503                         BT_DBG("Unexpected parameters in signal");
 504                         return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
 505                 }
 506
 507                 _bt_convert_addr_string_to_type(dev_address.addr,
 508                                                 address);
 509
 510                 _bt_input_event_cb(BLUETOOTH_HID_CONNECTED,
 511                                 result, &dev_address,
 512                                 event_info->cb, event_info->user_data);
 513         } else if (strcasecmp(member, BT_INPUT_DISCONNECTED) == 0) {
 514                 char *address = NULL;
 515                 bluetooth_device_address_t dev_address = { {0} };
 516
 517                 if (!dbus_message_get_args(msg, NULL,
 518                         DBUS_TYPE_INT32, &result,
 519                         DBUS_TYPE_STRING, &address,
 520                         DBUS_TYPE_INVALID)) {
 521                         BT_DBG("Unexpected parameters in signal");
 522                         return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
 523                 }
 524
 525                 BT_DBG("address: %s", address);
 526
 527                 _bt_convert_addr_string_to_type(dev_address.addr,
 528                                                 address);
 529
 530                 _bt_input_event_cb(BLUETOOTH_HID_DISCONNECTED,
 531                                 result, &dev_address,
 532                                 event_info->cb, event_info->user_data);
 533         }
 534
 535         return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
 536 }
 537
 538 static DBusHandlerResult __bt_headset_event_filter(DBusConnection *conn,
 539                                            DBusMessage *msg, void *data)
 540 {
 541         bt_event_info_t *event_info;
 542         int result = BLUETOOTH_ERROR_NONE;
 543         const char *member = dbus_message_get_member(msg);
 544
 545         event_info = (bt_event_info_t *)data;
 546         retv_if(event_info == NULL, DBUS_HANDLER_RESULT_NOT_YET_HANDLED);
 547
 548         if (dbus_message_get_type(msg) != DBUS_MESSAGE_TYPE_SIGNAL)
 549                 return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
 550
 551         if (!dbus_message_has_interface(msg, BT_EVENT_SERVICE))
 552                 return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
 553
 554         if (!dbus_message_has_path(msg, BT_HEADSET_PATH))
 555                 return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
 556
 557         retv_if(member == NULL, DBUS_HANDLER_RESULT_NOT_YET_HANDLED);
 558
 559         if (strcasecmp(member, BT_HEADSET_CONNECTED) == 0) {
 560                 char *address = NULL;
 561
 562                 if (!dbus_message_get_args(msg, NULL,
 563                         DBUS_TYPE_INT32, &result,
 564                         DBUS_TYPE_STRING, &address,
 565                         DBUS_TYPE_INVALID)) {
 566                         BT_ERR("Unexpected parameters in signal");
 567                         return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
 568                 }
 569
 570                 _bt_headset_event_cb(BLUETOOTH_EVENT_AG_CONNECTED,
 571                                 result, address,
 572                                 event_info->cb, event_info->user_data);
 573         } else if (strcasecmp(member, BT_HEADSET_DISCONNECTED) == 0) {
 574                 char *address = NULL;
 575
 576                 if (!dbus_message_get_args(msg, NULL,
 577                         DBUS_TYPE_INT32, &result,
 578                         DBUS_TYPE_STRING, &address,
 579                         DBUS_TYPE_INVALID)) {
 580                         BT_ERR("Unexpected parameters in signal");
 581                         return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
 582                 }
 583
 584                 _bt_headset_event_cb(BLUETOOTH_EVENT_AG_DISCONNECTED,
 585                                 result, address,
 586                                 event_info->cb, event_info->user_data);
 587         } else if (strcasecmp(member, BT_STEREO_HEADSET_CONNECTED) == 0) {
 588                 char *address = NULL;
 589
 590                 if (!dbus_message_get_args(msg, NULL,
 591                         DBUS_TYPE_INT32, &result,
 592                         DBUS_TYPE_STRING, &address,
 593                         DBUS_TYPE_INVALID)) {
 594                         BT_ERR("Unexpected parameters in signal");
 595                         return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
 596                 }
 597
 598                 _bt_headset_event_cb(BLUETOOTH_EVENT_AV_CONNECTED,
 599                                 result, address,
 600                                 event_info->cb, event_info->user_data);
 601         } else if (strcasecmp(member, BT_STEREO_HEADSET_DISCONNECTED) == 0) {
 602                 char *address = NULL;
 603
 604                 if (!dbus_message_get_args(msg, NULL,
 605                         DBUS_TYPE_INT32, &result,
 606                         DBUS_TYPE_STRING, &address,
 607                         DBUS_TYPE_INVALID)) {
 608                         BT_ERR("Unexpected parameters in signal");
 609                         return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
 610                 }
 611
 612                 _bt_headset_event_cb(BLUETOOTH_EVENT_AV_DISCONNECTED,
 613                                 result, address,
 614                                 event_info->cb, event_info->user_data);
 615         } else if (strcasecmp(member, BT_SCO_CONNECTED) == 0) {
 616                 char *address = NULL;
 617                 bluetooth_device_address_t dev_address = { {0} };
 618
 619                 if (!dbus_message_get_args(msg, NULL,
 620                         DBUS_TYPE_INT32, &result,
 621                         DBUS_TYPE_STRING, &address,
 622                         DBUS_TYPE_INVALID)) {
 623                         BT_ERR("Unexpected parameters in signal");
 624                         return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
 625                 }
 626
 627                 _bt_convert_addr_string_to_type(dev_address.addr,
 628                                                 address);
 629
 630                 _bt_headset_event_cb(BLUETOOTH_EVENT_AG_AUDIO_CONNECTED,
 631                                 result, &dev_address,
 632                                 event_info->cb, event_info->user_data);
 633         } else if (strcasecmp(member, BT_SCO_DISCONNECTED) == 0) {
 634                 char *address = NULL;
 635                 bluetooth_device_address_t dev_address = { {0} };
 636
 637                 if (!dbus_message_get_args(msg, NULL,
 638                         DBUS_TYPE_INT32, &result,
 639                         DBUS_TYPE_STRING, &address,
 640                         DBUS_TYPE_INVALID)) {
 641                         BT_ERR("Unexpected parameters in signal");
 642                         return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
 643                 }
 644
 645                 _bt_convert_addr_string_to_type(dev_address.addr,
 646                                                 address);
 647
 648                 _bt_headset_event_cb(BLUETOOTH_EVENT_AG_AUDIO_DISCONNECTED,
 649                                 result, &dev_address,
 650                                 event_info->cb, event_info->user_data);
 651         } else if (strcasecmp(member, BT_SPEAKER_GAIN) == 0) {
 652                 unsigned int gain;
 653                 guint16 spkr_gain;
 654                 char *address = NULL;
 655
 656                 if (!dbus_message_get_args(msg, NULL,
 657                         DBUS_TYPE_INT32, &result,
 658                         DBUS_TYPE_STRING, &address,
 659                         DBUS_TYPE_UINT16, &spkr_gain,
 660                         DBUS_TYPE_INVALID)) {
 661                         BT_ERR("Unexpected parameters in signal");
 662                         return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
 663                 }
 664                 gain = (unsigned int)spkr_gain;
 665
 666                 _bt_headset_event_cb(BLUETOOTH_EVENT_AG_SPEAKER_GAIN,
 667                                 result, &gain,
 668                                 event_info->cb, event_info->user_data);
 669         } else if (strcasecmp(member, BT_MICROPHONE_GAIN) == 0) {
 670                 unsigned int gain;
 671                 guint16 mic_gain;
 672                 char *address = NULL;
 673
 674                 if (!dbus_message_get_args(msg, NULL,
 675                         DBUS_TYPE_INT32, &result,
 676                         DBUS_TYPE_STRING, &address,
 677                         DBUS_TYPE_UINT16, &mic_gain,
 678                         DBUS_TYPE_INVALID)) {
 679                         BT_ERR("Unexpected parameters in signal");
 680                         return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
 681                 }
 682                 gain = (unsigned int)mic_gain;
 683
 684                 _bt_headset_event_cb(BLUETOOTH_EVENT_AG_MIC_GAIN,
 685                                 result, &gain,
 686                                 event_info->cb, event_info->user_data);
 687         }
 688
 689         return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
 690 }
 691
 692 static DBusHandlerResult __bt_network_event_filter(DBusConnection *conn,
 693                                            DBusMessage *msg, void *data)
 694 {
 695         bt_event_info_t *event_info;
 696         int result = BLUETOOTH_ERROR_NONE;
 697         const char *member = dbus_message_get_member(msg);
 698
 699         event_info = (bt_event_info_t *)data;
 700         retv_if(event_info == NULL, DBUS_HANDLER_RESULT_NOT_YET_HANDLED);
 701
 702         if (dbus_message_get_type(msg) != DBUS_MESSAGE_TYPE_SIGNAL)
 703                 return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
 704
 705         if (!dbus_message_has_interface(msg, BT_EVENT_SERVICE))
 706                 return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
 707
 708         if (!dbus_message_has_path(msg, BT_NETWORK_PATH))
 709                 return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
 710
 711         retv_if(member == NULL, DBUS_HANDLER_RESULT_NOT_YET_HANDLED);
 712
 713         if (strcasecmp(member, BT_NETWORK_CONNECTED) == 0) {
 714                 char *address = NULL;
 715                 bluetooth_device_address_t dev_address = { {0} };
 716
 717                 if (!dbus_message_get_args(msg, NULL,
 718                         DBUS_TYPE_INT32, &result,
 719                         DBUS_TYPE_STRING, &address,
 720                         DBUS_TYPE_INVALID)) {
 721                         BT_ERR("Unexpected parameters in signal");
 722                         return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
 723                 }
 724
 725                 _bt_convert_addr_string_to_type(dev_address.addr,
 726                                                 address);
 727
 728                 _bt_common_event_cb(BLUETOOTH_EVENT_NETWORK_CONNECTED,
 729                                 result, &dev_address,
 730                                 event_info->cb, event_info->user_data);
 731         } else if (strcasecmp(member, BT_NETWORK_DISCONNECTED) == 0) {
 732                 char *address = NULL;
 733                 bluetooth_device_address_t dev_address = { {0} };
 734
 735                 if (!dbus_message_get_args(msg, NULL,
 736                         DBUS_TYPE_INT32, &result,
 737                         DBUS_TYPE_STRING, &address,
 738                         DBUS_TYPE_INVALID)) {
 739                         BT_ERR("Unexpected parameters in signal");
 740                         return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
 741                 }
 742
 743                 _bt_convert_addr_string_to_type(dev_address.addr,
 744                                                 address);
 745
 746                 _bt_common_event_cb(BLUETOOTH_EVENT_NETWORK_DISCONNECTED,
 747                                 result, &dev_address,
 748                                 event_info->cb, event_info->user_data);
 749         } else if (strcasecmp(member, BT_NETWORK_SERVER_CONNECTED) == 0) {
 750                 char *device = NULL;
 751                 char *address = NULL;
 752                 bluetooth_network_device_info_t network_info;
 753
 754                 if (!dbus_message_get_args(msg, NULL,
 755                         DBUS_TYPE_INT32, &result,
 756                         DBUS_TYPE_STRING, &device,
 757                         DBUS_TYPE_STRING, &address,
 758                         DBUS_TYPE_INVALID)) {
 759                         BT_ERR("Unexpected parameters in signal");
 760                         return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
 761                 }
 762
 763                 memset(&network_info, 0x00, sizeof(bluetooth_network_device_info_t));
 764
 765                 _bt_convert_addr_string_to_type(network_info.device_address.addr,
 766                                                 address);
 767
 768                 _bt_print_device_address_t(&network_info.device_address);
 769                 g_strlcpy(network_info.interface_name, device, BLUETOOTH_INTERFACE_NAME_LENGTH);
 770
 771                 BT_DBG("name: %s", network_info.interface_name);
 772
 773                 _bt_common_event_cb(BLUETOOTH_EVENT_NETWORK_SERVER_CONNECTED,
 774                                 result, &network_info,
 775                                 event_info->cb, event_info->user_data);
 776         } else if (strcasecmp(member, BT_NETWORK_SERVER_DISCONNECTED) == 0) {
 777                 char *device = NULL;
 778                 char *address = NULL;
 779                 bluetooth_network_device_info_t network_info;
 780
 781                 if (!dbus_message_get_args(msg, NULL,
 782                         DBUS_TYPE_INT32, &result,
 783                         DBUS_TYPE_STRING, &device,
 784                         DBUS_TYPE_STRING, &address,
 785                         DBUS_TYPE_INVALID)) {
 786                         BT_ERR("Unexpected parameters in signal");
 787                         return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
 788                 }
 789
 790                 memset(&network_info, 0x00, sizeof(bluetooth_network_device_info_t));
 791
 792                 _bt_convert_addr_string_to_type(network_info.device_address.addr,
 793                                                 address);
 794
 795                 _bt_print_device_address_t(&network_info.device_address);
 796
 797                 _bt_common_event_cb(BLUETOOTH_EVENT_NETWORK_SERVER_DISCONNECTED,
 798                                 result, &network_info,
 799                                 event_info->cb, event_info->user_data);
 800         }
 801
 802
 803         return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
 804 }
 805
 806 static DBusHandlerResult __bt_avrcp_event_filter(DBusConnection *conn,
 807                                            DBusMessage *msg, void *data)
 808 {
 809         bt_event_info_t *event_info;
 810         int result = BLUETOOTH_ERROR_NONE;
 811         const char *member = dbus_message_get_member(msg);
 812
 813         event_info = (bt_event_info_t *)data;
 814         retv_if(event_info == NULL, DBUS_HANDLER_RESULT_NOT_YET_HANDLED);
 815
 816         if (dbus_message_get_type(msg) != DBUS_MESSAGE_TYPE_SIGNAL)
 817                 return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
 818
 819         if (!dbus_message_has_interface(msg, BT_EVENT_SERVICE))
 820                 return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
 821
 822         if (!dbus_message_has_path(msg, BT_AVRCP_PATH))
 823                 return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
 824
 825         retv_if(member == NULL, DBUS_HANDLER_RESULT_NOT_YET_HANDLED);
 826
 827         if (strcasecmp(member, BT_STEREO_HEADSET_CONNECTED) == 0) {
 828                 char *address = NULL;
 829
 830                 if (!dbus_message_get_args(msg, NULL,
 831                         DBUS_TYPE_INT32, &result,
 832                         DBUS_TYPE_STRING, &address,
 833                         DBUS_TYPE_INVALID)) {
 834                         BT_ERR("Unexpected parameters in signal");
 835                         return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
 836                 }
 837
 838                 _bt_avrcp_event_cb(BLUETOOTH_EVENT_AVRCP_CONNECTED,
 839                                 result, address,
 840                                 event_info->cb, event_info->user_data);
 841         } else if (strcasecmp(member, BT_STEREO_HEADSET_DISCONNECTED) == 0) {
 842                 char *address = NULL;
 843
 844                 if (!dbus_message_get_args(msg, NULL,
 845                         DBUS_TYPE_INT32, &result,
 846                         DBUS_TYPE_STRING, &address,
 847                         DBUS_TYPE_INVALID)) {
 848                         BT_ERR("Unexpected parameters in signal");
 849                         return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
 850                 }
 851
 852                 _bt_avrcp_event_cb(BLUETOOTH_EVENT_AVRCP_DISCONNECTED,
 853                                 result, address,
 854                                 event_info->cb, event_info->user_data);
 855         } else if (strcasecmp(member, BT_MEDIA_SHUFFLE_STATUS) == 0) {
 856                 unsigned int status;
 857                 if (!dbus_message_get_args(msg, NULL,
 858                         DBUS_TYPE_UINT32, &status,
 859                         DBUS_TYPE_INVALID)) {
 860                         BT_ERR("Unexpected parameters in signal");
 861                         return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
 862                 }
 863                 _bt_avrcp_event_cb(BLUETOOTH_EVENT_AVRCP_SETTING_SHUFFLE_STATUS,
 864                                 result, &status,
 865                                 event_info->cb, event_info->user_data);
 866         } else if (strcasecmp(member, BT_MEDIA_EQUALIZER_STATUS) == 0) {
 867                 unsigned int status;
 868                 if (!dbus_message_get_args(msg, NULL,
 869                         DBUS_TYPE_UINT32, &status,
 870                         DBUS_TYPE_INVALID)) {
 871                         BT_ERR("Unexpected parameters in signal");
 872                         return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
 873                 }
 874                 _bt_avrcp_event_cb(BLUETOOTH_EVENT_AVRCP_SETTING_EQUALIZER_STATUS,
 875                                 result, &status,
 876                                 event_info->cb, event_info->user_data);
 877         } else if (strcasecmp(member, BT_MEDIA_REPEAT_STATUS) == 0) {
 878                 unsigned int status;
 879                 if (!dbus_message_get_args(msg, NULL,
 880                         DBUS_TYPE_UINT32, &status,
 881                         DBUS_TYPE_INVALID)) {
 882                         BT_ERR("Unexpected parameters in signal");
 883                         return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
 884                 }
 885                 _bt_avrcp_event_cb(BLUETOOTH_EVENT_AVRCP_SETTING_REPEAT_STATUS,
 886                                 result, &status,
 887                                 event_info->cb, event_info->user_data);
 888         }  else if (strcasecmp(member, BT_MEDIA_SCAN_STATUS) == 0) {
 889                 unsigned int status;
 890                 if (!dbus_message_get_args(msg, NULL,
 891                         DBUS_TYPE_UINT32, &status,
 892                         DBUS_TYPE_INVALID)) {
 893                         BT_ERR("Unexpected parameters in signal");
 894                         return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
 895                 }
 896                 _bt_avrcp_event_cb(BLUETOOTH_EVENT_AVRCP_SETTING_SCAN_STATUS,
 897                                 result, &status,
 898                                 event_info->cb, event_info->user_data);
 899         }
 900
 901         return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
 902 }
 903
 904 static DBusHandlerResult __bt_opp_client_event_filter(DBusConnection *conn,
 905                                            DBusMessage *msg, void *data)
 906 {
 907         bt_event_info_t *event_info;
 908         int result = BLUETOOTH_ERROR_NONE;
 909         const char *member = dbus_message_get_member(msg);
 910
 911         event_info = (bt_event_info_t *)data;
 912         retv_if(event_info == NULL, DBUS_HANDLER_RESULT_NOT_YET_HANDLED);
 913
 914         if (dbus_message_get_type(msg) != DBUS_MESSAGE_TYPE_SIGNAL)
 915                 return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
 916
 917         if (!dbus_message_has_interface(msg, BT_EVENT_SERVICE))
 918                 return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
 919
 920         if (!dbus_message_has_path(msg, BT_OPP_CLIENT_PATH))
 921                 return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
 922
 923         retv_if(member == NULL, DBUS_HANDLER_RESULT_NOT_YET_HANDLED);
 924
 925         if (strcasecmp(member, BT_OPP_CONNECTED) == 0) {
 926                 char *address = NULL;
 927                 int request_id = 0;
 928                 bluetooth_device_address_t dev_address = { {0} };
 929
 930                 if (!dbus_message_get_args(msg, NULL,
 931                         DBUS_TYPE_INT32, &result,
 932                         DBUS_TYPE_STRING, &address,
 933                         DBUS_TYPE_INT32, &request_id,
 934                         DBUS_TYPE_INVALID)) {
 935                         BT_ERR("Unexpected parameters in signal");
 936                         return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
 937                 }
 938
 939                 if (__bt_is_request_id_exist(request_id) == FALSE) {
 940                         BT_ERR("Different request id!");
 941                         return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
 942                 }
 943
 944                 _bt_convert_addr_string_to_type(dev_address.addr,
 945                                                 address);
 946
 947                 _bt_common_event_cb(BLUETOOTH_EVENT_OPC_CONNECTED,
 948                                 result, &dev_address,
 949                                 event_info->cb, event_info->user_data);
 950
 951                 if (result != BLUETOOTH_ERROR_NONE) {
 952                         __bt_remove_push_request_id(request_id);
 953                 }
 954         } else if (strcasecmp(member, BT_OPP_DISCONNECTED) == 0) {
 955                 char *address = NULL;
 956                 int request_id = 0;
 957                 bluetooth_device_address_t dev_address = { {0} };
 958
 959                 if (!dbus_message_get_args(msg, NULL,
 960                         DBUS_TYPE_INT32, &result,
 961                         DBUS_TYPE_STRING, &address,
 962                         DBUS_TYPE_INT32, &request_id,
 963                         DBUS_TYPE_INVALID)) {
 964                         BT_ERR("Unexpected parameters in signal");
 965                         return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
 966                 }
 967
 968                 if (__bt_is_request_id_exist(request_id) == FALSE) {
 969                         BT_ERR("Different request id!");
 970                         return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
 971                 }
 972
 973                 _bt_convert_addr_string_to_type(dev_address.addr,
 974                                                 address);
 975
 976                 _bt_common_event_cb(BLUETOOTH_EVENT_OPC_DISCONNECTED,
 977                                 result, &dev_address,
 978                                 event_info->cb, event_info->user_data);
 979
 980                 __bt_remove_push_request_id(request_id);
 981         } else if (strcasecmp(member, BT_TRANSFER_STARTED) == 0) {
 982                 char *file_name = NULL;
 983                 int request_id = 0;
 984                 guint64 size = 0;
 985                 bt_opc_transfer_info_t transfer_info;
 986
 987                 if (!dbus_message_get_args(msg, NULL,
 988                         DBUS_TYPE_INT32, &result,
 989                         DBUS_TYPE_STRING, &file_name,
 990                         DBUS_TYPE_UINT64, &size,
 991                         DBUS_TYPE_INT32, &request_id,
 992                         DBUS_TYPE_INVALID)) {
 993                         BT_ERR("Unexpected parameters in signal");
 994                         return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
 995                 }
 996
 997                 if (__bt_is_request_id_exist(request_id) == FALSE) {
 998                         BT_ERR("Different request id!");
 999                         return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
1000                 }
1001
1002                 memset(&transfer_info, 0x00, sizeof(bt_opc_transfer_info_t));
1003
1004                 transfer_info.filename = g_strdup(file_name);
1005                 transfer_info.size = size;
1006
1007                 _bt_common_event_cb(BLUETOOTH_EVENT_OPC_TRANSFER_STARTED,
1008                                 result, &transfer_info,
1009                                 event_info->cb, event_info->user_data);
1010
1011                 g_free(transfer_info.filename);
1012         } else if (strcasecmp(member, BT_TRANSFER_PROGRESS) == 0) {
1013                 char *file_name = NULL;
1014                 int request_id = 0;
1015                 guint64 size = 0;
1016                 int progress = 0;
1017                 bt_opc_transfer_info_t transfer_info;
1018
1019                 if (!dbus_message_get_args(msg, NULL,
1020                         DBUS_TYPE_INT32, &result,
1021                         DBUS_TYPE_STRING, &file_name,
1022                         DBUS_TYPE_UINT64, &size,
1023                         DBUS_TYPE_INT32, &progress,
1024                         DBUS_TYPE_INT32, &request_id,
1025                         DBUS_TYPE_INVALID)) {
1026                         BT_ERR("Unexpected parameters in signal");
1027                         return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
1028                 }
1029
1030                 if (__bt_is_request_id_exist(request_id) == FALSE) {
1031                         BT_ERR("Different request id!");
1032                         return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
1033                 }
1034
1035                 memset(&transfer_info, 0x00, sizeof(bt_opc_transfer_info_t));
1036
1037                 transfer_info.filename = g_strdup(file_name);
1038                 transfer_info.size = size;
1039                 transfer_info.percentage = progress;
1040
1041                 _bt_common_event_cb(BLUETOOTH_EVENT_OPC_TRANSFER_PROGRESS,
1042                                 result, &transfer_info,
1043                                 event_info->cb, event_info->user_data);
1044
1045                 g_free(transfer_info.filename);
1046         } else if (strcasecmp(member, BT_TRANSFER_COMPLETED) == 0) {
1047                 char *file_name = NULL;
1048                 int request_id = 0;
1049                 guint64 size = 0;
1050                 bt_opc_transfer_info_t transfer_info;
1051
1052                 if (!dbus_message_get_args(msg, NULL,
1053                         DBUS_TYPE_INT32, &result,
1054                         DBUS_TYPE_STRING, &file_name,
1055                         DBUS_TYPE_UINT64, &size,
1056                         DBUS_TYPE_INT32, &request_id,
1057                         DBUS_TYPE_INVALID)) {
1058                         BT_ERR("Unexpected parameters in signal");
1059                         return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
1060                 }
1061
1062                 if (__bt_is_request_id_exist(request_id) == FALSE) {
1063                         BT_ERR("Different request id!");
1064                         return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
1065                 }
1066
1067                 memset(&transfer_info, 0x00, sizeof(bt_opc_transfer_info_t));
1068
1069                 transfer_info.filename = g_strdup(file_name);
1070                 transfer_info.size = size;
1071
1072                 _bt_common_event_cb(BLUETOOTH_EVENT_OPC_TRANSFER_COMPLETE,
1073                                 result, &transfer_info,
1074                                 event_info->cb, event_info->user_data);
1075
1076                 g_free(transfer_info.filename);
1077         }
1078
1079         return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
1080 }
1081
1082 static DBusHandlerResult __bt_opp_server_event_filter(DBusConnection *conn,
1083                                            DBusMessage *msg, void *data)
1084 {
1085         bt_event_info_t *event_info;
1086         int result = BLUETOOTH_ERROR_NONE;
1087         const char *member = dbus_message_get_member(msg);
1088
1089         event_info = (bt_event_info_t *)data;
1090         retv_if(event_info == NULL, DBUS_HANDLER_RESULT_NOT_YET_HANDLED);
1091
1092         if (dbus_message_get_type(msg) != DBUS_MESSAGE_TYPE_SIGNAL)
1093                 return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
1094
1095         if (!dbus_message_has_interface(msg, BT_EVENT_SERVICE))
1096                 return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
1097
1098         if (!dbus_message_has_path(msg, BT_OPP_SERVER_PATH))
1099                 return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
1100
1101         retv_if(member == NULL, DBUS_HANDLER_RESULT_NOT_YET_HANDLED);
1102
1103         if (strcasecmp(member, BT_TRANSFER_AUTHORIZED) == 0) {
1104                 /* Native only event */
1105                 char *file_name = NULL;
1106                 guint64 size = 0;
1107                 bt_obex_server_authorize_into_t auth_info;
1108
1109                 if (!dbus_message_get_args(msg, NULL,
1110                         DBUS_TYPE_INT32, &result,
1111                         DBUS_TYPE_STRING, &file_name,
1112                         DBUS_TYPE_UINT64, &size,
1113                         DBUS_TYPE_INVALID)) {
1114                         BT_ERR("Unexpected parameters in signal");
1115                         return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
1116                 }
1117
1118                 /* OSP server: Don't get this event */
1119                 retv_if(obex_server_id == BT_CUSTOM_SERVER,
1120                                 DBUS_HANDLER_RESULT_NOT_YET_HANDLED);
1121
1122                 memset(&auth_info, 0x00, sizeof(bt_obex_server_authorize_into_t));
1123
1124                 auth_info.filename = g_strdup(file_name);
1125                 auth_info.length = size;
1126
1127                 _bt_common_event_cb(BLUETOOTH_EVENT_OBEX_SERVER_TRANSFER_AUTHORIZE,
1128                                 result, &auth_info,
1129                                 event_info->cb, event_info->user_data);
1130
1131                 g_free(auth_info.filename);
1132         } else if (strcasecmp(member, BT_CONNECTION_AUTHORIZED) == 0) {
1133                 /* OSP only event */
1134                 char *address = NULL;
1135                 char *name = NULL;
1136                 bluetooth_device_address_t dev_address = { {0} };
1137
1138                 if (!dbus_message_get_args(msg, NULL,
1139                         DBUS_TYPE_INT32, &result,
1140                         DBUS_TYPE_STRING, &address,
1141                         DBUS_TYPE_STRING, &name,
1142                         DBUS_TYPE_INVALID)) {
1143                         BT_ERR("Unexpected parameters in signal");
1144                         return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
1145                 }
1146
1147                 /* Native server: Don't get this event */
1148                 retv_if(obex_server_id == BT_NATIVE_SERVER,
1149                                 DBUS_HANDLER_RESULT_NOT_YET_HANDLED);
1150
1151                 _bt_convert_addr_string_to_type(dev_address.addr,
1152                                                 address);
1153
1154                 _bt_common_event_cb(BLUETOOTH_EVENT_OBEX_SERVER_CONNECTION_AUTHORIZE,
1155                                 result, &dev_address,
1156                                 event_info->cb, event_info->user_data);
1157         } else if (strcasecmp(member, BT_TRANSFER_STARTED) == 0) {
1158                 char *file_name = NULL;
1159                 char *type = NULL;
1160                 int transfer_id = 0;
1161                 int server_type = 0; /* bt_server_type_t */
1162                 guint64 size = 0;
1163                 bt_obex_server_transfer_info_t transfer_info;
1164
1165                 if (!dbus_message_get_args(msg, NULL,
1166                         DBUS_TYPE_INT32, &result,
1167                         DBUS_TYPE_STRING, &file_name,
1168                         DBUS_TYPE_STRING, &type,
1169                         DBUS_TYPE_UINT64, &size,
1170                         DBUS_TYPE_INT32, &transfer_id,
1171                         DBUS_TYPE_INT32, &server_type,
1172                         DBUS_TYPE_INVALID)) {
1173                         BT_ERR("Unexpected parameters in signal");
1174                         return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
1175                 }
1176
1177                 /* Other server's event */
1178                 retv_if(obex_server_id != server_type &&
1179                         server_type != BT_FTP_SERVER,
1180                                 DBUS_HANDLER_RESULT_NOT_YET_HANDLED);
1181
1182                 memset(&transfer_info, 0x00, sizeof(bt_obex_server_transfer_info_t));
1183
1184                 transfer_info.filename = g_strdup(file_name);
1185                 transfer_info.type = g_strdup(type);
1186                 transfer_info.file_size = size;
1187                 transfer_info.transfer_id = transfer_id;
1188
1189                 _bt_common_event_cb(BLUETOOTH_EVENT_OBEX_SERVER_TRANSFER_STARTED,
1190                                 result, &transfer_info,
1191                                 event_info->cb, event_info->user_data);
1192
1193                 g_free(transfer_info.filename);
1194                 g_free(transfer_info.type);
1195         } else if (strcasecmp(member, BT_TRANSFER_PROGRESS) == 0) {
1196                 char *file_name = NULL;
1197                 char *type = NULL;
1198                 int transfer_id = 0;
1199                 int progress = 0;
1200                 int server_type = 0; /* bt_server_type_t */
1201                 guint64 size = 0;
1202                 bt_obex_server_transfer_info_t transfer_info;
1203
1204                 if (!dbus_message_get_args(msg, NULL,
1205                         DBUS_TYPE_INT32, &result,
1206                         DBUS_TYPE_STRING, &file_name,
1207                         DBUS_TYPE_STRING, &type,
1208                         DBUS_TYPE_UINT64, &size,
1209                         DBUS_TYPE_INT32, &transfer_id,
1210                         DBUS_TYPE_INT32, &progress,
1211                         DBUS_TYPE_INT32, &server_type,
1212                         DBUS_TYPE_INVALID)) {
1213                         BT_ERR("Unexpected parameters in signal");
1214                         return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
1215                 }
1216
1217                 /* Other server's event */
1218                 retv_if(obex_server_id != server_type &&
1219                         server_type != BT_FTP_SERVER,
1220                                 DBUS_HANDLER_RESULT_NOT_YET_HANDLED);
1221
1222                 memset(&transfer_info, 0x00, sizeof(bt_obex_server_transfer_info_t));
1223
1224                 transfer_info.filename = g_strdup(file_name);
1225                 transfer_info.type = g_strdup(type);
1226                 transfer_info.file_size = size;
1227                 transfer_info.transfer_id = transfer_id;
1228                 transfer_info.percentage = progress;
1229
1230                 _bt_common_event_cb(BLUETOOTH_EVENT_OBEX_SERVER_TRANSFER_PROGRESS,
1231                                 result, &transfer_info,
1232                                 event_info->cb, event_info->user_data);
1233
1234                 g_free(transfer_info.filename);
1235                 g_free(transfer_info.type);
1236         } else if (strcasecmp(member, BT_TRANSFER_COMPLETED) == 0) {
1237                 char *file_name = NULL;
1238                 char *device_name = NULL;
1239                 char *type = NULL;
1240                 int transfer_id = 0;
1241                 int server_type = 0; /* bt_server_type_t */
1242                 guint64 size = 0;
1243                 bt_obex_server_transfer_info_t transfer_info;
1244
1245                 if (!dbus_message_get_args(msg, NULL,
1246                         DBUS_TYPE_INT32, &result,
1247                         DBUS_TYPE_STRING, &file_name,
1248                         DBUS_TYPE_STRING, &type,
1249                         DBUS_TYPE_STRING, &device_name,
1250                         DBUS_TYPE_UINT64, &size,
1251                         DBUS_TYPE_INT32, &transfer_id,
1252                         DBUS_TYPE_INT32, &server_type,
1253                         DBUS_TYPE_INVALID)) {
1254                         BT_ERR("Unexpected parameters in signal");
1255                         return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
1256                 }
1257
1258                 /* Other server's event */
1259                 retv_if(obex_server_id != server_type &&
1260                         server_type != BT_FTP_SERVER,
1261                                 DBUS_HANDLER_RESULT_NOT_YET_HANDLED);
1262
1263                 memset(&transfer_info, 0x00, sizeof(bt_obex_server_transfer_info_t));
1264
1265                 transfer_info.filename = g_strdup(file_name);
1266                 transfer_info.type = g_strdup(type);
1267                 transfer_info.device_name = g_strdup(device_name);
1268                 transfer_info.file_size = size;
1269                 transfer_info.transfer_id = transfer_id;
1270
1271                 _bt_common_event_cb(BLUETOOTH_EVENT_OBEX_SERVER_TRANSFER_COMPLETED,
1272                                 result, &transfer_info,
1273                                 event_info->cb, event_info->user_data);
1274
1275                 g_free(transfer_info.filename);
1276                 g_free(transfer_info.type);
1277                 g_free(transfer_info.device_name);
1278         }
1279
1280         return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
1281 }
1282
1283 static DBusHandlerResult __bt_rfcomm_client_event_filter(DBusConnection *conn,
1284                                            DBusMessage *msg, void *data)
1285 {
1286         bt_event_info_t *event_info;
1287         int result = BLUETOOTH_ERROR_NONE;
1288         const char *member = dbus_message_get_member(msg);
1289
1290         event_info = (bt_event_info_t *)data;
1291         retv_if(event_info == NULL, DBUS_HANDLER_RESULT_NOT_YET_HANDLED);
1292
1293         if (dbus_message_get_type(msg) != DBUS_MESSAGE_TYPE_SIGNAL)
1294                 return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
1295
1296         if (!dbus_message_has_interface(msg, BT_EVENT_SERVICE))
1297                 return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
1298
1299         if (!dbus_message_has_path(msg, BT_RFCOMM_CLIENT_PATH))
1300                 return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
1301
1302         retv_if(member == NULL, DBUS_HANDLER_RESULT_NOT_YET_HANDLED);
1303
1304         if (strcasecmp(member, BT_RFCOMM_CONNECTED) == 0) {
1305                 char *address = NULL;
1306                 char *uuid = NULL;
1307                 int socket_fd = 0;
1308                 bluetooth_rfcomm_connection_t conn_info;
1309
1310                 if (!dbus_message_get_args(msg, NULL,
1311                         DBUS_TYPE_INT32, &result,
1312                         DBUS_TYPE_STRING, &address,
1313                         DBUS_TYPE_STRING, &uuid,
1314                         DBUS_TYPE_INT16, &socket_fd,
1315                         DBUS_TYPE_INVALID)) {
1316                         BT_ERR("Unexpected parameters in signal");
1317                         return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
1318                 }
1319
1320                 memset(&conn_info, 0x00, sizeof(bluetooth_rfcomm_connection_t));
1321                 conn_info.device_role = RFCOMM_ROLE_CLIENT;
1322                 g_strlcpy(conn_info.uuid, uuid, BLUETOOTH_UUID_STRING_MAX);
1323                 conn_info.socket_fd = socket_fd;
1324                 _bt_convert_addr_string_to_type(conn_info.device_addr.addr,
1325                                                 address);
1326
1327                 _bt_common_event_cb(BLUETOOTH_EVENT_RFCOMM_CONNECTED,
1328                                 result, &conn_info,
1329                                 event_info->cb, event_info->user_data);
1330         } else if (strcasecmp(member, BT_RFCOMM_DISCONNECTED) == 0) {
1331                 char *address = NULL;
1332                 char *uuid = NULL;
1333                 int socket_fd = 0;
1334                 bluetooth_rfcomm_disconnection_t disconn_info;
1335
1336                 if (!dbus_message_get_args(msg, NULL,
1337                         DBUS_TYPE_INT32, &result,
1338                         DBUS_TYPE_STRING, &address,
1339                         DBUS_TYPE_STRING, &uuid,
1340                         DBUS_TYPE_INT16, &socket_fd,
1341                         DBUS_TYPE_INVALID)) {
1342                         BT_ERR("Unexpected parameters in signal");
1343                         return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
1344                 }
1345
1346                 memset(&disconn_info, 0x00, sizeof(bluetooth_rfcomm_disconnection_t));
1347                 disconn_info.device_role = RFCOMM_ROLE_CLIENT;
1348                 g_strlcpy(disconn_info.uuid, uuid, BLUETOOTH_UUID_STRING_MAX);
1349                 disconn_info.socket_fd = socket_fd;
1350                 _bt_convert_addr_string_to_type(disconn_info.device_addr.addr,
1351                                                 address);
1352
1353                 _bt_common_event_cb(BLUETOOTH_EVENT_RFCOMM_DISCONNECTED,
1354                                 result, &disconn_info,
1355                                 event_info->cb, event_info->user_data);
1356         } else if (strcasecmp(member, BT_RFCOMM_DATA_RECEIVED) == 0) {
1357                 char *buffer = NULL;
1358                 int buffer_len = 0;
1359                 int socket_fd = 0;
1360                 bluetooth_rfcomm_received_data_t data_r;
1361
1362                 if (!dbus_message_get_args(msg, NULL,
1363                         DBUS_TYPE_INT32, &result,
1364                         DBUS_TYPE_INT16, &socket_fd,
1365                         DBUS_TYPE_ARRAY, DBUS_TYPE_BYTE,
1366                         &buffer, &buffer_len,
1367                         DBUS_TYPE_INVALID)) {
1368                         BT_ERR("Unexpected parameters in signal");
1369                         return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
1370                 }
1371
1372                 data_r.socket_fd = socket_fd;
1373                 data_r.buffer_size = buffer_len;
1374                 data_r.buffer = g_memdup(buffer, buffer_len);
1375
1376                 _bt_common_event_cb(BLUETOOTH_EVENT_RFCOMM_DATA_RECEIVED,
1377                                 result, &data_r,
1378                                 event_info->cb, event_info->user_data);
1379
1380                 g_free(data_r.buffer);
1381         }
1382
1383         return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
1384 }
1385
1386 static DBusHandlerResult __bt_rfcomm_server_event_filter(DBusConnection *conn,
1387                                            DBusMessage *msg, void *data)
1388 {
1389         bt_event_info_t *event_info;
1390         int result = BLUETOOTH_ERROR_NONE;
1391         const char *member = dbus_message_get_member(msg);
1392
1393         event_info = (bt_event_info_t *)data;
1394         retv_if(event_info == NULL, DBUS_HANDLER_RESULT_NOT_YET_HANDLED);
1395
1396         if (dbus_message_get_type(msg) != DBUS_MESSAGE_TYPE_SIGNAL)
1397                 return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
1398
1399         if (!dbus_message_has_interface(msg, BT_EVENT_SERVICE))
1400                 return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
1401
1402         if (!dbus_message_has_path(msg, BT_RFCOMM_SERVER_PATH))
1403                 return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
1404
1405         retv_if(member == NULL, DBUS_HANDLER_RESULT_NOT_YET_HANDLED);
1406
1407         if (strcasecmp(member, BT_RFCOMM_CONNECTED) == 0) {
1408                 char *address = NULL;
1409                 char *uuid = NULL;
1410                 int socket_fd = 0;
1411                 bluetooth_rfcomm_connection_t conn_info;
1412
1413                 if (!dbus_message_get_args(msg, NULL,
1414                         DBUS_TYPE_INT32, &result,
1415                         DBUS_TYPE_STRING, &address,
1416                         DBUS_TYPE_STRING, &uuid,
1417                         DBUS_TYPE_INT16, &socket_fd,
1418                         DBUS_TYPE_INVALID)) {
1419                         BT_ERR("Unexpected parameters in signal");
1420                         return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
1421                 }
1422
1423                 memset(&conn_info, 0x00, sizeof(bluetooth_rfcomm_connection_t));
1424                 conn_info.device_role = RFCOMM_ROLE_SERVER;
1425                 g_strlcpy(conn_info.uuid, uuid, BLUETOOTH_UUID_STRING_MAX);
1426                 conn_info.socket_fd = socket_fd;
1427                 _bt_convert_addr_string_to_type(conn_info.device_addr.addr,
1428                                                 address);
1429
1430                 _bt_common_event_cb(BLUETOOTH_EVENT_RFCOMM_CONNECTED,
1431                                 result, &conn_info,
1432                                 event_info->cb, event_info->user_data);
1433         } else if (strcasecmp(member, BT_RFCOMM_DISCONNECTED) == 0) {
1434                 char *address = NULL;
1435                 char *uuid = NULL;
1436                 int socket_fd = 0;
1437                 bluetooth_rfcomm_disconnection_t disconn_info;
1438
1439                 if (!dbus_message_get_args(msg, NULL,
1440                         DBUS_TYPE_INT32, &result,
1441                         DBUS_TYPE_STRING, &address,
1442                         DBUS_TYPE_STRING, &uuid,
1443                         DBUS_TYPE_INT16, &socket_fd,
1444                         DBUS_TYPE_INVALID)) {
1445                         BT_ERR("Unexpected parameters in signal");
1446                         return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
1447                 }
1448
1449                 memset(&disconn_info, 0x00, sizeof(bluetooth_rfcomm_disconnection_t));
1450                 disconn_info.device_role = RFCOMM_ROLE_SERVER;
1451                 g_strlcpy(disconn_info.uuid, uuid, BLUETOOTH_UUID_STRING_MAX);
1452                 disconn_info.socket_fd = socket_fd;
1453                 _bt_convert_addr_string_to_type(disconn_info.device_addr.addr,
1454                                                 address);
1455
1456                 _bt_common_event_cb(BLUETOOTH_EVENT_RFCOMM_DISCONNECTED,
1457                                 result, &disconn_info,
1458                                 event_info->cb, event_info->user_data);
1459         } else if (strcasecmp(member, BT_CONNECTION_AUTHORIZED) == 0) {
1460                 /* OSP only event */
1461                 bluetooth_rfcomm_connection_request_t req_ind;
1462                 char *address = NULL;
1463                 char *uuid = NULL;
1464                 char *name = NULL;
1465                 int socket_fd = 0;
1466
1467                 if (!dbus_message_get_args(msg, NULL,
1468                         DBUS_TYPE_INT32, &result,
1469                         DBUS_TYPE_STRING, &address,
1470                         DBUS_TYPE_STRING, &uuid,
1471                         DBUS_TYPE_STRING, &name,
1472                         DBUS_TYPE_INT16, &socket_fd,
1473                         DBUS_TYPE_INVALID)) {
1474                         BT_ERR("Unexpected parameters in signal");
1475                         return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
1476                 }
1477
1478                 /* Don't send the authorized event to other server */
1479                 retv_if(__bt_is_server_exist(socket_fd) == FALSE,
1480                                 DBUS_HANDLER_RESULT_NOT_YET_HANDLED);
1481
1482                 memset(&req_ind, 0x00, sizeof(bluetooth_rfcomm_connection_request_t));
1483                 _bt_convert_addr_string_to_type(req_ind.device_addr.addr,
1484                                                 address);
1485
1486                 req_ind.socket_fd = socket_fd;
1487
1488                 _bt_common_event_cb(BLUETOOTH_EVENT_RFCOMM_AUTHORIZE,
1489                                 result, &req_ind,
1490                                 event_info->cb, event_info->user_data);
1491         } else if (strcasecmp(member, BT_RFCOMM_SERVER_REMOVED) == 0) {
1492                 /* OSP only event */
1493                 int socket_fd = 0;
1494
1495                 if (!dbus_message_get_args(msg, NULL,
1496                         DBUS_TYPE_INT32, &result,
1497                         DBUS_TYPE_INT16, &socket_fd,
1498                         DBUS_TYPE_INVALID)) {
1499                         BT_ERR("Unexpected parameters in signal");
1500                         return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
1501                 }
1502
1503                 retv_if(__bt_is_server_exist(socket_fd) == FALSE,
1504                                 DBUS_HANDLER_RESULT_NOT_YET_HANDLED);
1505
1506                 _bt_remove_server(socket_fd);
1507         } else if (strcasecmp(member, BT_RFCOMM_DATA_RECEIVED) == 0) {
1508                 char *buffer = NULL;
1509                 int buffer_len = 0;
1510                 int socket_fd = 0;
1511                 bluetooth_rfcomm_received_data_t data_r;
1512
1513                 if (!dbus_message_get_args(msg, NULL,
1514                         DBUS_TYPE_INT32, &result,
1515                         DBUS_TYPE_INT16, &socket_fd,
1516                         DBUS_TYPE_ARRAY, DBUS_TYPE_BYTE,
1517                         &buffer, &buffer_len,
1518                         DBUS_TYPE_INVALID)) {
1519                         BT_ERR("Unexpected parameters in signal");
1520                         return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
1521                 }
1522
1523                 data_r.socket_fd = socket_fd;
1524                 data_r.buffer_size = buffer_len;
1525                 data_r.buffer = g_memdup(buffer, buffer_len);
1526
1527                 _bt_common_event_cb(BLUETOOTH_EVENT_RFCOMM_DATA_RECEIVED,
1528                                 result, &data_r,
1529                                 event_info->cb, event_info->user_data);
1530
1531                 g_free(data_r.buffer);
1532         }
1533
1534         return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
1535 }
1536
1537 static void __bt_remove_all_events(void)
1538 {
1539         GSList *l;
1540         bt_event_info_t *info;
1541
1542         for (l = event_list; l != NULL; l = g_slist_next(l)) {
1543                 info = l->data;
1544
1545                 if (info)
1546                         _bt_unregister_event(info->event_type);
1547         }
1548
1549         g_slist_free(event_list);
1550         event_list = NULL;
1551 }
1552
1553 static gboolean __bt_event_is_registered(int event_type)
1554 {
1555         GSList *l;
1556         bt_event_info_t *info;
1557
1558         for (l = event_list; l != NULL; l = g_slist_next(l)) {
1559                 info = l->data;
1560                 if (info == NULL)
1561                         continue;
1562
1563                 retv_if(info->event_type == event_type, TRUE);
1564         }
1565
1566         return FALSE;
1567 }
1568
1569 bt_event_info_t* __bt_event_get_cb_data(int event_type)
1570 {
1571         GSList *l;
1572         bt_event_info_t *info;
1573
1574         for (l = event_list; l != NULL; l = g_slist_next(l)) {
1575                 info = l->data;
1576                 if (info == NULL)
1577                         continue;
1578
1579                 if (info->event_type == event_type)
1580                         return info;
1581         }
1582
1583         return NULL;
1584 }
1585
1586 void _bt_add_server(int server_fd)
1587 {
1588         bt_server_info_t *info;
1589
1590         info = g_new0(bt_server_info_t, 1);
1591         info->server_fd = server_fd;
1592
1593         server_list = g_slist_append(server_list, info);
1594 }
1595
1596 void _bt_remove_server(int server_fd)
1597 {
1598         GSList *l;
1599         bt_server_info_t *info;
1600
1601         for (l = server_list; l != NULL; l = g_slist_next(l)) {
1602                 info = l->data;
1603                 if (info == NULL)
1604                         continue;
1605
1606                 if (info->server_fd == server_fd) {
1607                         server_list = g_slist_remove(server_list, (void *)info);
1608                 }
1609
1610                 g_free(info);
1611         }
1612 }
1613
1614 void _bt_set_obex_server_id(int server_type)
1615 {
1616         obex_server_id = server_type;
1617 }
1618
1619 int _bt_get_obex_server_id(void)
1620 {
1621         return obex_server_id;
1622 }
1623
1624 int _bt_init_event_handler(void)
1625 {
1626         if (is_initialized == TRUE) {
1627                 BT_ERR("Connection already exist");
1628                 return BLUETOOTH_ERROR_ALREADY_INITIALIZED;
1629         }
1630
1631         __bt_remove_all_events();
1632
1633         is_initialized = TRUE;
1634
1635         return BLUETOOTH_ERROR_NONE;
1636 }
1637
1638 int _bt_deinit_event_handler(void)
1639 {
1640         if (is_initialized == FALSE) {
1641                 BT_ERR("Connection dose not exist");
1642                 return BLUETOOTH_ERROR_INTERNAL;
1643         }
1644
1645         __bt_remove_all_events();
1646
1647         is_initialized = FALSE;
1648
1649         return BLUETOOTH_ERROR_NONE;
1650 }
1651
1652 static void __bt_event_data_free(void *data)
1653 {
1654         bt_event_info_t *cb_data = data;
1655
1656         ret_if(cb_data == NULL);
1657
1658         if (cb_data->conn)
1659                 dbus_connection_unref(cb_data->conn);
1660
1661         g_free(cb_data);
1662 }
1663
1664 int _bt_register_event(int event_type, void *event_cb, void *user_data)
1665 {
1666         DBusError dbus_error;
1667         char *match;
1668         DBusConnection *connection_type;
1669         DBusHandleMessageFunction event_func;
1670         bt_event_info_t *cb_data;
1671
1672         if (is_initialized == FALSE)
1673                 _bt_init_event_handler();
1674
1675         if (__bt_event_is_registered(event_type) == TRUE) {
1676                 BT_ERR("The event is already registed");
1677                 return BLUETOOTH_ERROR_ALREADY_INITIALIZED;
1678         }
1679
1680         switch (event_type) {
1681         case BT_ADAPTER_EVENT:
1682                 connection_type = dbus_bus_get(DBUS_BUS_SYSTEM, NULL);
1683                 retv_if(connection_type == NULL, BLUETOOTH_ERROR_INTERNAL);
1684
1685                 event_func = __bt_adapter_event_filter;
1686                 match = g_strdup_printf(EVENT_MATCH_RULE, BT_EVENT_SERVICE,
1687                                         BT_ADAPTER_PATH);
1688                 break;
1689         case BT_DEVICE_EVENT:
1690                 connection_type = dbus_bus_get(DBUS_BUS_SYSTEM, NULL);
1691                 retv_if(connection_type == NULL, BLUETOOTH_ERROR_INTERNAL);
1692
1693                 event_func = __bt_device_event_filter;
1694                 match = g_strdup_printf(EVENT_MATCH_RULE, BT_EVENT_SERVICE,
1695                                         BT_DEVICE_PATH);
1696                 break;
1697         case BT_HID_EVENT:
1698                 connection_type = dbus_bus_get(DBUS_BUS_SYSTEM, NULL);
1699                 retv_if(connection_type == NULL, BLUETOOTH_ERROR_INTERNAL);
1700
1701                 event_func = __bt_hid_event_filter;
1702                 match = g_strdup_printf(EVENT_MATCH_RULE, BT_EVENT_SERVICE,
1703                                         BT_HID_PATH);
1704                 break;
1705         case BT_HEADSET_EVENT:
1706                 connection_type = dbus_bus_get(DBUS_BUS_SYSTEM, NULL);
1707                 retv_if(connection_type == NULL, BLUETOOTH_ERROR_INTERNAL);
1708
1709                 event_func = __bt_headset_event_filter;
1710                 match = g_strdup_printf(EVENT_MATCH_RULE, BT_EVENT_SERVICE,
1711                                         BT_HEADSET_PATH);
1712                 break;
1713         case BT_NETWORK_EVENT:
1714                 connection_type = dbus_bus_get(DBUS_BUS_SYSTEM, NULL);
1715                 retv_if(connection_type == NULL, BLUETOOTH_ERROR_INTERNAL);
1716
1717                 event_func = __bt_network_event_filter;
1718                 match = g_strdup_printf(EVENT_MATCH_RULE, BT_EVENT_SERVICE,
1719                                         BT_NETWORK_PATH);
1720                 break;
1721         case BT_AVRCP_EVENT:
1722                 connection_type = dbus_bus_get(DBUS_BUS_SYSTEM, NULL);
1723                 retv_if(connection_type == NULL, BLUETOOTH_ERROR_INTERNAL);
1724
1725                 event_func = __bt_avrcp_event_filter;
1726                 match = g_strdup_printf(EVENT_MATCH_RULE, BT_EVENT_SERVICE,
1727                                         BT_AVRCP_PATH);
1728                 break;
1729         case BT_OPP_CLIENT_EVENT:
1730                 connection_type = dbus_bus_get(DBUS_BUS_SYSTEM, NULL);
1731                 retv_if(connection_type == NULL, BLUETOOTH_ERROR_INTERNAL);
1732
1733                 event_func = __bt_opp_client_event_filter;
1734                 match = g_strdup_printf(EVENT_MATCH_RULE, BT_EVENT_SERVICE,
1735                                         BT_OPP_CLIENT_PATH);
1736                 break;
1737         case BT_OPP_SERVER_EVENT:
1738                 connection_type = dbus_bus_get(DBUS_BUS_SYSTEM, NULL);
1739                 retv_if(connection_type == NULL, BLUETOOTH_ERROR_INTERNAL);
1740
1741                 event_func = __bt_opp_server_event_filter;
1742                 match = g_strdup_printf(EVENT_MATCH_RULE, BT_EVENT_SERVICE,
1743                                         BT_OPP_SERVER_PATH);
1744                 break;
1745         case BT_RFCOMM_CLIENT_EVENT:
1746                 connection_type = dbus_bus_get(DBUS_BUS_SYSTEM, NULL);
1747                 retv_if(connection_type == NULL, BLUETOOTH_ERROR_INTERNAL);
1748
1749                 event_func = __bt_rfcomm_client_event_filter;
1750                 match = g_strdup_printf(EVENT_MATCH_RULE, BT_EVENT_SERVICE,
1751                                         BT_RFCOMM_CLIENT_PATH);
1752                 break;
1753         case BT_RFCOMM_SERVER_EVENT:
1754                 connection_type = dbus_bus_get(DBUS_BUS_SYSTEM, NULL);
1755                 retv_if(connection_type == NULL, BLUETOOTH_ERROR_INTERNAL);
1756
1757                 event_func = __bt_rfcomm_server_event_filter;
1758                 match = g_strdup_printf(EVENT_MATCH_RULE, BT_EVENT_SERVICE,
1759                                         BT_RFCOMM_SERVER_PATH);
1760                 break;
1761         default:
1762                 BT_ERR("Unknown event");
1763                 return BLUETOOTH_ERROR_INTERNAL;
1764         }
1765
1766         cb_data = g_new0(bt_event_info_t, 1);
1767
1768         cb_data->event_type = event_type;
1769         cb_data->conn = connection_type;
1770         cb_data->func = event_func;
1771         cb_data->match_rule = match;
1772         cb_data->cb = event_cb;
1773         cb_data->user_data = user_data;
1774
1775         if (!dbus_connection_add_filter(connection_type, event_func,
1776                                 (void *)cb_data, __bt_event_data_free)) {
1777                 BT_ERR("Fail to add filter");
1778                 goto fail;
1779         }
1780
1781         dbus_error_init(&dbus_error);
1782
1783         if (match)
1784                 dbus_bus_add_match(connection_type, match, &dbus_error);
1785
1786         if (dbus_error_is_set(&dbus_error)) {
1787                 BT_ERR("Fail to add match: %s\n", dbus_error.message);
1788                 dbus_error_free(&dbus_error);
1789                 goto fail;
1790         }
1791
1792         event_list = g_slist_append(event_list, cb_data);
1793
1794         return BLUETOOTH_ERROR_NONE;
1795 fail:
1796         if (connection_type)
1797                 dbus_connection_unref(connection_type);
1798
1799         g_free(cb_data);
1800         g_free(match);
1801         return BLUETOOTH_ERROR_INTERNAL;
1802 }
1803
1804 int _bt_unregister_event(int event_type)
1805 {
1806         DBusConnection *connection_type;
1807         DBusHandleMessageFunction event_func;
1808         bt_event_info_t *cb_data;
1809         char *match;
1810         DBusError dbus_error;
1811
1812         if (is_initialized == FALSE) {
1813                 BT_ERR("Event is not registered");
1814                 return BLUETOOTH_ERROR_INTERNAL;
1815         }
1816
1817         if (__bt_event_is_registered(event_type) == FALSE) {
1818                 BT_ERR("Not registered event");
1819                 return BLUETOOTH_ERROR_INTERNAL;
1820         }
1821
1822         cb_data = __bt_event_get_cb_data(event_type);
1823
1824         if (cb_data == NULL) {
1825                 BT_ERR("No matched event data");
1826                 return BLUETOOTH_ERROR_INTERNAL;
1827         }
1828
1829         connection_type = cb_data->conn;
1830         event_func = cb_data->func;
1831         match = cb_data->match_rule;
1832
1833         event_list = g_slist_remove(event_list, (void *)cb_data);
1834
1835         retv_if(connection_type == NULL, BLUETOOTH_ERROR_INTERNAL);
1836         retv_if(event_func == NULL, BLUETOOTH_ERROR_INTERNAL);
1837
1838         dbus_error_init(&dbus_error);
1839
1840         dbus_bus_remove_match (connection_type, match, &dbus_error);
1841
1842         if (dbus_error_is_set(&dbus_error)) {
1843                 BT_ERR("Fail to remove match: %s\n", dbus_error.message);
1844                 dbus_error_free(&dbus_error);
1845         }
1846
1847         dbus_connection_remove_filter(connection_type, event_func,
1848                                         (void *)cb_data);
1849
1850         g_free(match);
1851         return BLUETOOTH_ERROR_NONE;
1852 }