bt-api/bt-event-handler.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
  18 #include <string.h>
  19 #include <dbus/dbus.h>
  20 #include <glib.h>
  21 #include <dlog.h>
  22 #include <vconf.h>
  23
  24 #include "bluetooth-api.h"
  25 #include "bluetooth-audio-api.h"
  26 #include "bluetooth-hid-api.h"
  27 #include "bt-internal-types.h"
  28 #include "bluetooth-media-control.h"
  29
  30 #include "bt-common.h"
  31 #include "bt-event-handler.h"
  32 #include "bt-gatt-client.h"
  33 #include "bt-request-sender.h"
  34
  35 #define PROFILE_SUPPORTED 0x3 /* This corresponds to binary 0b11*/
  36 #define BT_RELIABLE_DISABLE_TIME 300 /* 300 ms */
  37
  38 typedef struct {
  39         int server_fd;
  40 } bt_server_info_t;
  41
  42 typedef struct {
  43         int request_id;
  44 } bt_sending_info_t;
  45
  46 static int obex_server_id;
  47 static guint disable_timer_id;
  48 static gboolean is_initialized;
  49 static GSList *sending_list = NULL;
  50 static GSList *server_list = NULL;
  51 static GSList *event_list = NULL;
  52 static int owner_sig_id = -1;
  53
  54 void _bt_add_push_request_id(int request_id)
  55 {
  56         bt_sending_info_t *info;
  57
  58         info = g_new0(bt_sending_info_t, 1);
  59         info->request_id = request_id;
  60
  61         sending_list = g_slist_append(sending_list, info);
  62 }
  63
  64 static gboolean __bt_is_request_id_exist(int request_id)
  65 {
  66         GSList *l;
  67         bt_sending_info_t *info;
  68
  69         for (l = sending_list; l != NULL; l = g_slist_next(l)) {
  70                 info = l->data;
  71                 if (info == NULL)
  72                         continue;
  73
  74                 if (info->request_id == request_id)
  75                         return TRUE;
  76         }
  77
  78         return FALSE;
  79 }
  80
  81 static void __bt_remove_push_request_id(int request_id)
  82 {
  83         GSList *l;
  84         bt_sending_info_t *info;
  85
  86         for (l = sending_list; l != NULL; l = g_slist_next(l)) {
  87                 info = l->data;
  88                 if (info == NULL)
  89                         continue;
  90
  91                 BT_DBG("info->request_id = %d\n", info->request_id);
  92                 BT_DBG("request_id = %d\n", request_id);
  93                 if (info->request_id == request_id) {
  94                         sending_list = g_slist_remove(sending_list, (void *)info);
  95                         g_free(info);
  96                         break;
  97                 }
  98         }
  99 }
 100
 101 static void __bt_remove_all_push_request_id(void)
 102 {
 103         GSList *l;
 104         bt_sending_info_t *info;
 105
 106         for (l = sending_list; l != NULL; l = g_slist_next(l)) {
 107                 info = l->data;
 108                 g_free(info);
 109         }
 110
 111         g_slist_free(sending_list);
 112         sending_list = NULL;
 113 }
 114
 115 static void __bt_remove_all_server(void)
 116 {
 117         GSList *l;
 118         bt_server_info_t *info;
 119
 120         for (l = server_list; l != NULL; l = g_slist_next(l)) {
 121                 info = l->data;
 122                 g_free(info);
 123         }
 124
 125         g_slist_free(server_list);
 126         server_list = NULL;
 127 }
 128
 129 static gboolean __bt_is_server_exist(int server_fd)
 130 {
 131         GSList *l;
 132         bt_server_info_t *info;
 133
 134         for (l = server_list; l != NULL; l = g_slist_next(l)) {
 135                 info = l->data;
 136                 if (info == NULL)
 137                         continue;
 138
 139                 retv_if(info->server_fd == server_fd, TRUE);
 140         }
 141
 142         return FALSE;
 143 }
 144
 145 static void __bt_get_uuid_info(bluetooth_device_info_t *dev_info,
 146                                 char **uuids,
 147                                 int uuid_count)
 148 {
 149         int i;
 150         char **parts;
 151
 152         ret_if(dev_info == NULL);
 153         ret_if(uuids == NULL);
 154         ret_if(uuid_count <= 0);
 155
 156         dev_info->service_index = uuid_count;
 157
 158         for (i = 0; i < uuid_count && uuids[i] != NULL; i++) {
 159                 g_strlcpy(dev_info->uuids[i], uuids[i], BLUETOOTH_UUID_STRING_MAX);
 160
 161                 parts = g_strsplit(uuids[i], "-", -1);
 162
 163                 if (parts == NULL || parts[0] == NULL) {
 164                         g_strfreev(parts);
 165                         continue;
 166                 }
 167
 168                 dev_info->service_list_array[i] = g_ascii_strtoull(parts[0], NULL, 16);
 169                 g_strfreev(parts);
 170         }
 171 }
 172 static int __bt_call_list_create(bt_hf_call_list_s **list)
 173 {
 174         bt_hf_call_list_s *handle;
 175
 176         if (*list != NULL) {
 177                 BT_DBG("Already Initialized");
 178                 return BLUETOOTH_ERROR_NONE;
 179         }
 180         handle = g_malloc0(sizeof(bt_hf_call_list_s));
 181         *list = handle;
 182         return BLUETOOTH_ERROR_NONE;
 183 }
 184
 185 static int __bt_call_list_reset(bt_hf_call_list_s *list)
 186 {
 187         bt_hf_call_list_s *handle;
 188         bt_hf_call_status_info_t *call_status;
 189
 190         if (list == NULL) {
 191                 BT_ERR("invalid parameter");
 192                 return BLUETOOTH_ERROR_INVALID_PARAM;
 193         }
 194         handle = (bt_hf_call_list_s *)list;
 195         do  {
 196                 call_status = (bt_hf_call_status_info_t *)g_list_nth_data(handle->list, 0);
 197                 if (call_status == NULL)
 198                         break;
 199                 handle->list = g_list_remove(handle->list, call_status);
 200                 g_free(call_status->number);
 201                 g_free(call_status);
 202         } while (1);
 203         return BLUETOOTH_ERROR_NONE;
 204 }
 205
 206 static int __bt_call_list_destroy(bt_hf_call_list_s *list)
 207 {
 208         int result;
 209         bt_hf_call_list_s *handle;
 210
 211         if (list == NULL) {
 212                 BT_ERR("invalid parameter");
 213                 return BLUETOOTH_ERROR_INVALID_PARAM;
 214         }
 215         handle = (bt_hf_call_list_s *)list;
 216         result = __bt_call_list_reset(list);
 217         g_free(handle);
 218         return result;
 219 }
 220 static int __bt_call_list_add(bt_hf_call_list_s *list, char * number,
 221                                                                 int dir, int status, int mpart, int idx)
 222 {
 223         bt_hf_call_list_s *handle;
 224         bt_hf_call_status_info_t *call_status;
 225
 226         if (list == NULL) {
 227                 BT_ERR("invalid parameter");
 228                 return BLUETOOTH_ERROR_INVALID_PARAM;
 229         }
 230         handle = (bt_hf_call_list_s *)list;
 231         call_status = g_malloc0(sizeof(bt_hf_call_status_info_t));
 232         /* Fix : NULL_RETURNS */
 233         retv_if(call_status == NULL, BLUETOOTH_ERROR_MEMORY_ALLOCATION);
 234
 235         call_status->number = g_strdup(number);
 236         call_status->direction = dir;
 237         call_status->status = status;
 238         call_status->mpart = mpart;
 239         call_status->idx = idx;
 240         handle->list = g_list_append(handle->list, (gpointer)call_status);
 241         return BLUETOOTH_ERROR_NONE;
 242 }
 243
 244 static bluetooth_device_info_t *__bt_get_device_info_in_message(GVariant *parameters, int *ret)
 245 {
 246         bluetooth_device_info_t *dev_info;
 247         const char *address = NULL;
 248         const char *name = NULL;
 249         gchar **uuids = NULL;
 250         unsigned int dev_class = 0;
 251         short rssi = 0;
 252         gboolean paired = FALSE;
 253         guint connected = 0;
 254         gboolean trust = FALSE;
 255         gsize uuid_count;
 256         int result = BLUETOOTH_ERROR_NONE;
 257         GVariant *string_var;
 258         int i = 0, len = 0;
 259         int manufacturer_data_len = 0;
 260         GVariant *manufacturer_var = NULL;
 261         const char *manufacturer_data = NULL;
 262
 263         g_variant_get(parameters, "(isunsbub@asn@ay)", &result, &address,
 264                         &dev_class, &rssi, &name, &paired,
 265                         &connected, &trust,  &string_var, &manufacturer_data_len, &manufacturer_var);
 266
 267         if (string_var == NULL) {
 268                 BT_ERR("invalid parameters in signal");
 269                 return NULL;
 270         }
 271
 272         uuids = (gchar **)g_variant_get_strv(string_var, &uuid_count);
 273
 274         len = g_variant_get_size(manufacturer_var);
 275         if (len > 0)
 276                 manufacturer_data = (char *)g_variant_get_data(manufacturer_var);
 277
 278         dev_info = g_malloc0(sizeof(bluetooth_device_info_t));
 279         /* Fix : NULL_RETURNS */
 280         if (dev_info == NULL) {
 281                 result = BLUETOOTH_ERROR_MEMORY_ALLOCATION;
 282                 goto done;
 283         }
 284
 285         dev_info->rssi = rssi;
 286         dev_info->paired = paired;
 287         dev_info->connected = connected;
 288         dev_info->trust = trust;
 289
 290         g_strlcpy(dev_info->device_name.name, name,
 291                 BLUETOOTH_DEVICE_NAME_LENGTH_MAX + 1);
 292
 293         _bt_divide_device_class(&dev_info->device_class, dev_class);
 294
 295         _bt_convert_addr_string_to_type(dev_info->device_address.addr,
 296                                         address);
 297
 298         if (uuid_count > 0)
 299                 __bt_get_uuid_info(dev_info, uuids, uuid_count);
 300
 301         if (manufacturer_data_len > BLUETOOTH_MANUFACTURER_DATA_LENGTH_MAX) {
 302                 BT_ERR("manufacturer_data_len is too long(len = %d)", manufacturer_data_len);
 303                 manufacturer_data_len = BLUETOOTH_MANUFACTURER_DATA_LENGTH_MAX;
 304         }
 305         dev_info->manufacturer_data.data_len = manufacturer_data_len;
 306         if (manufacturer_data)
 307                 for (i = 0; i < manufacturer_data_len; i++)
 308                         dev_info->manufacturer_data.data[i] = manufacturer_data[i];
 309 done:
 310         *ret = result;
 311         g_free(uuids);
 312         g_variant_unref(string_var);
 313         g_variant_unref(manufacturer_var);
 314         return dev_info;
 315 }
 316
 317 static bluetooth_le_device_info_t *__bt_get_le_device_info_in_message(GVariant *parameters, int *ret)
 318 {
 319         bluetooth_le_device_info_t *le_dev_info;
 320         const char *address = NULL;
 321         int i;
 322         short addr_type = 0;
 323         short rssi = 0;
 324         int len = 0;
 325         int adv_data_len = 0;
 326         GVariant *adv_var = NULL;
 327         const char *adv_data = NULL;
 328         int scan_data_len = 0;
 329         GVariant *scan_var = NULL;
 330         const char *scan_data = NULL;
 331         int result = BLUETOOTH_ERROR_NONE;
 332
 333         g_variant_get(parameters, "(i&snnn@ayn@ay)", &result, &address,
 334                         &addr_type, &rssi, &adv_data_len, &adv_var, &scan_data_len, &scan_var);
 335
 336         len = g_variant_get_size(adv_var);
 337         if (len > 0)
 338                 adv_data = (char *)g_variant_get_data(adv_var);
 339
 340         len = g_variant_get_size(scan_var);
 341         if (len > 0)
 342                 scan_data = (char *)g_variant_get_data(scan_var);
 343
 344         le_dev_info = g_malloc0(sizeof(bluetooth_le_device_info_t));
 345         /* Fix : NULL_RETURNS */
 346         if (le_dev_info == NULL) {
 347                 result = BLUETOOTH_ERROR_MEMORY_ALLOCATION;
 348                 goto done;
 349         }
 350         _bt_convert_addr_string_to_type(le_dev_info->device_address.addr, address);
 351         le_dev_info->addr_type = addr_type;
 352         le_dev_info->rssi = rssi;
 353         le_dev_info->adv_ind_data.data_len = adv_data_len;
 354
 355         for (i = 0; i < adv_data_len; i++)
 356                 if (adv_data)
 357                         le_dev_info->adv_ind_data.data.data[i] = adv_data[i];
 358
 359         le_dev_info->scan_resp_data.data_len = scan_data_len;
 360
 361         for (i = 0; i < scan_data_len; i++)
 362                 if (scan_data)
 363                         le_dev_info->scan_resp_data.data.data[i] = scan_data[i];
 364
 365 done:
 366         *ret = result;
 367
 368         g_variant_unref(adv_var);
 369         g_variant_unref(scan_var);
 370         return le_dev_info;
 371 }
 372
 373 gboolean __bt_reliable_disable_cb(gpointer user_data)
 374 {
 375         BT_DBG("+");
 376         bt_event_info_t *event_info = user_data;
 377
 378         _bt_set_le_scan_status(FALSE);
 379
 380         _bt_set_adapter_internal_status(FALSE);
 381
 382         if (is_initialized != FALSE) {
 383                 _bt_common_event_cb(BLUETOOTH_EVENT_DISABLED,
 384                                 BLUETOOTH_ERROR_NONE, NULL,
 385                                 event_info->cb, event_info->user_data);
 386         }
 387
 388         obex_server_id = BT_NO_SERVER;
 389         __bt_remove_all_server();
 390         __bt_remove_all_push_request_id();
 391 #ifdef RFCOMM_DIRECT
 392          _bt_rfcomm_server_free_all();
 393 #endif
 394         bluetooth_hid_device_deactivate();
 395         BT_DBG("-");
 396         return FALSE;
 397 }
 398
 399 void __bt_adapter_event_filter(GDBusConnection *connection,
 400                                                  const gchar *sender_name,
 401                                                  const gchar *object_path,
 402                                                  const gchar *interface_name,
 403                                                  const gchar *signal_name,
 404                                                  GVariant *parameters,
 405                                                  gpointer user_data)
 406 {
 407         bt_event_info_t *event_info;
 408         int result = BLUETOOTH_ERROR_NONE;
 409
 410         event_info = (bt_event_info_t *)user_data;
 411         ret_if(event_info == NULL);
 412
 413         if (strcasecmp(object_path, BT_ADAPTER_PATH) != 0)
 414                 return;
 415         if (strcasecmp(interface_name, BT_EVENT_SERVICE) != 0)
 416                 return;
 417
 418         if (strcasecmp(signal_name, BT_ENABLED) == 0) {
 419                 BT_INFO("BT_ENABLED");
 420                 g_variant_get(parameters, "(i)", &result);
 421
 422                 _bt_common_event_cb(BLUETOOTH_EVENT_ENABLED,
 423                                 result, NULL,
 424                                 event_info->cb, event_info->user_data);
 425         } else if (strcasecmp(signal_name, BT_DISABLED) == 0) {
 426                 BT_INFO("BT_DISABLED");
 427
 428                 /* Wait for the termining time of bt-service  */
 429                 if (disable_timer_id > 0)
 430                         g_source_remove(disable_timer_id);
 431
 432                 disable_timer_id = g_timeout_add(BT_RELIABLE_DISABLE_TIME,
 433                                 (GSourceFunc)__bt_reliable_disable_cb,
 434                                 event_info);
 435         } else if (strcasecmp(signal_name, BT_DISCOVERABLE_MODE_CHANGED) == 0) {
 436                 int mode = 0;
 437
 438                 g_variant_get(parameters, "(in)", &result, &mode);
 439                 _bt_common_event_cb(BLUETOOTH_EVENT_DISCOVERABLE_MODE_CHANGED,
 440                                 result, &mode,
 441                                 event_info->cb, event_info->user_data);
 442         } else if (strcasecmp(signal_name, BT_DISCOVERABLE_TIMEOUT_CHANGED) == 0) {
 443                 int timeout = 0;
 444
 445                 g_variant_get(parameters, "(in)", &result, &timeout);
 446                 _bt_common_event_cb(BLUETOOTH_EVENT_DISCOVERABLE_TIMEOUT_CHANGED,
 447                                 result, &timeout,
 448                                 event_info->cb, event_info->user_data);
 449         } else if (strcasecmp(signal_name, BT_CONNECTABLE_CHANGED) == 0) {
 450                 gboolean connectable = FALSE;
 451
 452                 g_variant_get(parameters, "(b)", &connectable);
 453                 BT_DBG("Connectable is changed : %d", connectable);
 454
 455                 _bt_common_event_cb(BLUETOOTH_EVENT_CONNECTABLE_CHANGED,
 456                                 result, &connectable,
 457                                 event_info->cb, event_info->user_data);
 458         } else if (strcasecmp(signal_name, BT_ADAPTER_NAME_CHANGED) == 0) {
 459                 char *adapter_name = NULL;
 460
 461                 g_variant_get(parameters, "(i&s)", &result, &adapter_name);
 462                 _bt_common_event_cb(BLUETOOTH_EVENT_LOCAL_NAME_CHANGED,
 463                                 result, adapter_name,
 464                                 event_info->cb, event_info->user_data);
 465         } else if (strcasecmp(signal_name, BT_DISCOVERY_STARTED) == 0) {
 466                 _bt_common_event_cb(BLUETOOTH_EVENT_DISCOVERY_STARTED,
 467                                 BLUETOOTH_ERROR_NONE, NULL,
 468                                 event_info->cb, event_info->user_data);
 469         } else if (strcasecmp(signal_name, BT_DISCOVERY_FINISHED) == 0) {
 470                 g_variant_get(parameters, "(i)", &result);
 471                 _bt_common_event_cb(BLUETOOTH_EVENT_DISCOVERY_FINISHED,
 472                                 result, NULL,
 473                                 event_info->cb, event_info->user_data);
 474         } else if (strcasecmp(signal_name, BT_ADVERTISING_STARTED) == 0) {
 475                 int adv_handle;
 476
 477                 g_variant_get(parameters, "(ii)", &result, &adv_handle);
 478                 _bt_common_event_cb(BLUETOOTH_EVENT_ADVERTISING_STARTED,
 479                                 result, &adv_handle,
 480                                 event_info->cb, event_info->user_data);
 481         } else if (strcasecmp(signal_name, BT_ADVERTISING_STOPPED) == 0) {
 482                 int adv_handle;
 483
 484                 g_variant_get(parameters, "(ii)", &result, &adv_handle);
 485                 _bt_common_event_cb(BLUETOOTH_EVENT_ADVERTISING_STOPPED,
 486                                 result, &adv_handle,
 487                                 event_info->cb, event_info->user_data);
 488         } else if (strcasecmp(signal_name, BT_ADVERTISING_MANUFACTURER_DATA_CHANGED) == 0) {
 489                 GVariant *var = NULL;
 490                 char *data;
 491                 int len;
 492
 493                 g_variant_get(parameters, "(@ay)", &var);
 494                 len = g_variant_get_size(var);
 495                 data = (char *)g_variant_get_data(var);
 496
 497                 _bt_common_event_cb(BLUETOOTH_EVENT_ADVERTISING_MANUFACTURER_DATA_CHANGED,
 498                                 len, data,
 499                                 event_info->cb, event_info->user_data);
 500
 501                 g_variant_unref(var);
 502         }  else if (strcasecmp(signal_name, BT_SCAN_RESPONSE_MANUFACTURER_DATA_CHANGED) == 0) {
 503                 GVariant *var = NULL;
 504                 char *data;
 505                 int len;
 506
 507                 g_variant_get(parameters, "(@ay)", &var);
 508                 len = g_variant_get_size(var);
 509                 data = (char *)g_variant_get_data(var);
 510
 511                 _bt_common_event_cb(BLUETOOTH_EVENT_SCAN_RESPONSE_MANUFACTURER_DATA_CHANGED,
 512                                 len, data,
 513                                 event_info->cb, event_info->user_data);
 514
 515                 g_variant_unref(var);
 516         } else if (strcasecmp(signal_name, BT_MANUFACTURER_DATA_CHANGED) == 0) {
 517                 GVariant *var = NULL;
 518                 char *data;
 519                 int len;
 520
 521                 g_variant_get(parameters, "(@ay)", &var);
 522                 len = g_variant_get_size(var);
 523                 data = (char *)g_variant_get_data(var);
 524
 525                 _bt_common_event_cb(BLUETOOTH_EVENT_MANUFACTURER_DATA_CHANGED,
 526                                 len, data,
 527                                 event_info->cb, event_info->user_data);
 528
 529                 g_variant_unref(var);
 530         } else if (strcasecmp(signal_name, BT_PASSKEY_NOTIFICATION) == 0) {
 531                 const char *address = NULL;
 532                 const char *passkey = NULL;
 533                 const char *passkey_info[2];
 534
 535                 g_variant_get(parameters, "(&s&s)", &address, &passkey);
 536                 passkey_info[0] = address;
 537                 passkey_info[1] = passkey;
 538
 539                 _bt_common_event_cb(BLUETOOTH_EVENT_PASSKEY_NOTIFICATION,
 540                                 BLUETOOTH_ERROR_NONE, (void*)passkey_info,
 541                                 event_info->cb, event_info->user_data);
 542         } else if (strcasecmp(signal_name, BT_DEVICE_FOUND) == 0) {
 543                 int event;
 544                 bluetooth_device_info_t *device_info;
 545
 546                 device_info = __bt_get_device_info_in_message(parameters,
 547                                                                 &result);
 548                 ret_if(device_info == NULL);
 549
 550                 if (strlen(device_info->device_name.name) > 0)
 551                         event = BLUETOOTH_EVENT_REMOTE_DEVICE_NAME_UPDATED;
 552                 else
 553                         event = BLUETOOTH_EVENT_REMOTE_DEVICE_FOUND;
 554
 555                 _bt_common_event_cb(event,
 556                                 result, device_info,
 557                                 event_info->cb, event_info->user_data);
 558
 559                 g_free(device_info);
 560         } else if (strcasecmp(signal_name, BT_BOND_CREATED) == 0) {
 561                 bluetooth_device_info_t *device_info;
 562
 563                 device_info = __bt_get_device_info_in_message(parameters,
 564                                                                 &result);
 565                 ret_if(device_info == NULL);
 566
 567                 _bt_common_event_cb(BLUETOOTH_EVENT_BONDING_FINISHED,
 568                                 result, device_info,
 569                                 event_info->cb, event_info->user_data);
 570
 571                 g_free(device_info);
 572         } else if (strcasecmp(signal_name, BT_BOND_DESTROYED) == 0) {
 573                 const char *address = NULL;
 574                 bluetooth_device_address_t dev_address = { {0} };
 575
 576                 g_variant_get(parameters, "(i&s)", &result, &address);
 577
 578                 _bt_convert_addr_string_to_type(dev_address.addr,
 579                                                 address);
 580
 581                 _bt_common_event_cb(BLUETOOTH_EVENT_BONDED_DEVICE_REMOVED,
 582                                 result, &dev_address,
 583                                 event_info->cb, event_info->user_data);
 584         } else if (strcasecmp(signal_name, BT_SERVICE_SEARCHED) == 0) {
 585                 bluetooth_device_info_t *device_info;
 586                 bt_sdp_info_t sdp_info;
 587
 588                 device_info = __bt_get_device_info_in_message(parameters,
 589                                                                 &result);
 590                 ret_if(device_info == NULL);
 591
 592                 memset(&sdp_info, 0x00, sizeof(bt_sdp_info_t));
 593
 594                 sdp_info.service_index = device_info->service_index;
 595
 596                 memcpy(&sdp_info.device_addr,
 597                         &device_info->device_address,
 598                         BLUETOOTH_ADDRESS_LENGTH);
 599
 600                 memcpy(sdp_info.service_list_array,
 601                         device_info->service_list_array,
 602                         BLUETOOTH_MAX_SERVICES_FOR_DEVICE);
 603
 604                 memcpy(sdp_info.uuids,
 605                         device_info->uuids,
 606                         BLUETOOTH_MAX_SERVICES_FOR_DEVICE * BLUETOOTH_UUID_STRING_MAX);
 607
 608                 _bt_common_event_cb(BLUETOOTH_EVENT_SERVICE_SEARCHED,
 609                                 result, &sdp_info,
 610                                 event_info->cb, event_info->user_data);
 611
 612                 g_free(device_info);
 613         } else if (strcasecmp(signal_name, BT_IPSP_INITIALIZED) == 0) {
 614                 gboolean ipsp_intialized = FALSE;
 615                 g_variant_get(parameters, "(b)", &ipsp_intialized);
 616
 617                 BT_DBG("IPSP init state changed to : %d", ipsp_intialized);
 618
 619                 _bt_common_event_cb(BLUETOOTH_EVENT_IPSP_INIT_STATE_CHANGED,
 620                                 BLUETOOTH_ERROR_NONE, &ipsp_intialized,
 621                                 event_info->cb, event_info->user_data);
 622         } else if (strcasecmp(signal_name, BT_KBD_PASSKEY_DISPLAY_REQ_RECEIVED) == 0) {
 623                 const char *address =  NULL;
 624                 const char *name =  NULL;
 625                 const char *str_passkey = NULL;
 626
 627                 bluetooth_authentication_request_info_t auth_info;
 628                 memset(&auth_info, 0x00, sizeof(bluetooth_authentication_request_info_t));
 629
 630                 g_variant_get(parameters, "(i&s&s&s)", &result, &address, &name, &str_passkey);
 631
 632                 g_strlcpy(auth_info.device_name.name, name,
 633                         BLUETOOTH_DEVICE_NAME_LENGTH_MAX + 1);
 634                 _bt_convert_addr_string_to_type(auth_info.device_address.addr,
 635                         address);
 636                 g_strlcpy(auth_info.str_passkey, str_passkey, strlen(str_passkey)+1);
 637
 638                 _bt_common_event_cb(BLUETOOTH_EVENT_KEYBOARD_PASSKEY_DISPLAY,
 639                         result, &auth_info,
 640                         event_info->cb, event_info->user_data);
 641         } else if (strcasecmp(signal_name, BT_PIN_REQ_RECEIVED) == 0) {
 642                 const char *address =  NULL;
 643                 const char *name =  NULL;
 644
 645                 bluetooth_authentication_request_info_t auth_info;
 646                 memset(&auth_info, 0x00, sizeof(bluetooth_authentication_request_info_t));
 647
 648                 g_variant_get(parameters, "(i&s&s)", &result, &address, &name);
 649
 650                 g_strlcpy(auth_info.device_name.name, name,
 651                         BLUETOOTH_DEVICE_NAME_LENGTH_MAX + 1);
 652                 _bt_convert_addr_string_to_type(auth_info.device_address.addr,
 653                         address);
 654
 655                 _bt_common_event_cb(BLUETOOTH_EVENT_PIN_REQUEST,
 656                         result, &auth_info,
 657                         event_info->cb, event_info->user_data);
 658         } else if (strcasecmp(signal_name, BT_PASSKEY_REQ_RECEIVED) == 0) {
 659                 const char *address = NULL;
 660                 const char *name =  NULL;
 661
 662                 bluetooth_authentication_request_info_t auth_info;
 663                 memset(&auth_info, 0x00, sizeof(bluetooth_authentication_request_info_t));
 664
 665                 g_variant_get(parameters, "(i&s&s)", &result, &address, &name);
 666
 667                 g_strlcpy(auth_info.device_name.name, name,
 668                         BLUETOOTH_DEVICE_NAME_LENGTH_MAX + 1);
 669                 _bt_convert_addr_string_to_type(auth_info.device_address.addr,
 670                         address);
 671
 672                 _bt_common_event_cb(BLUETOOTH_EVENT_PASSKEY_REQUEST,
 673                         result, &auth_info,
 674                         event_info->cb, event_info->user_data);
 675         } else if (strcasecmp(signal_name, BT_PASSKEY_CFM_REQ_RECEIVED) == 0) {
 676                 const char *address =  NULL;
 677                 const char *name =  NULL;
 678                 const char *str_passkey = NULL;
 679
 680                 bluetooth_authentication_request_info_t auth_info;
 681                 memset(&auth_info, 0x00, sizeof(bluetooth_authentication_request_info_t));
 682
 683                 g_variant_get(parameters, "(i&s&s&s)", &result, &address, &name, &str_passkey);
 684
 685                 g_strlcpy(auth_info.device_name.name, name,
 686                         BLUETOOTH_DEVICE_NAME_LENGTH_MAX + 1);
 687                 _bt_convert_addr_string_to_type(auth_info.device_address.addr,
 688                         address);
 689                 g_strlcpy(auth_info.str_passkey, str_passkey, strlen(str_passkey)+1);
 690
 691                 _bt_common_event_cb(BLUETOOTH_EVENT_PASSKEY_CONFIRM_REQUEST,
 692                         result, &auth_info,
 693                         event_info->cb, event_info->user_data);
 694         }
 695 }
 696
 697 void __bt_adapter_le_event_filter(GDBusConnection *connection,
 698                                                  const gchar *sender_name,
 699                                                  const gchar *object_path,
 700                                                  const gchar *interface_name,
 701                                                  const gchar *signal_name,
 702                                                  GVariant *parameters,
 703                                                  gpointer user_data)
 704 {
 705         bt_event_info_t *event_info;
 706         int result = BLUETOOTH_ERROR_NONE;
 707
 708         event_info = (bt_event_info_t *)user_data;
 709         ret_if(event_info == NULL);
 710
 711         if (strcasecmp(object_path, BT_LE_ADAPTER_PATH) != 0)
 712                 return;
 713         if (strcasecmp(interface_name, BT_EVENT_SERVICE) != 0)
 714                 return;
 715
 716         if (strcasecmp(signal_name, BT_LE_ENABLED) == 0) {
 717                 BT_INFO("BT_LE_ENABLED");
 718                 g_variant_get(parameters, "(i)", &result);
 719                 _bt_common_event_cb(BLUETOOTH_EVENT_LE_ENABLED,
 720                                 result, NULL,
 721                                 event_info->cb, event_info->user_data);
 722         } else if (strcasecmp(signal_name, BT_LE_DISABLED) == 0) {
 723                 BT_INFO("BT_LE_DISABLED");
 724                 _bt_common_event_cb(BLUETOOTH_EVENT_LE_DISABLED,
 725                                 result, NULL,
 726                                 event_info->cb, event_info->user_data);
 727         } else if (strcasecmp(signal_name, BT_LE_DISCOVERY_STARTED) == 0) {
 728                 _bt_common_event_cb(BLUETOOTH_EVENT_LE_DISCOVERY_STARTED,
 729                                 BLUETOOTH_ERROR_NONE, NULL,
 730                                 event_info->cb, event_info->user_data);
 731         } else if (strcasecmp(signal_name, BT_LE_DISCOVERY_FINISHED) == 0) {
 732                 g_variant_get(parameters, "(i)", &result);
 733                 _bt_common_event_cb(BLUETOOTH_EVENT_LE_DISCOVERY_FINISHED,
 734                                 result, NULL,
 735                                 event_info->cb, event_info->user_data);
 736         } else if (strcasecmp(signal_name, BT_LE_DEVICE_FOUND) == 0) {
 737                 bluetooth_le_device_info_t *le_device_info;
 738
 739                 le_device_info = __bt_get_le_device_info_in_message(parameters,
 740                                                                 &result);
 741                 ret_if(le_device_info == NULL);
 742
 743                 if (bluetooth_is_le_scanning() == TRUE) {
 744                         _bt_common_event_cb(BLUETOOTH_EVENT_REMOTE_LE_DEVICE_FOUND,
 745                                 result, le_device_info,
 746                                 event_info->cb, event_info->user_data);
 747                 }
 748
 749                 g_free(le_device_info);
 750         }
 751 }
 752
 753 void __bt_device_event_filter(GDBusConnection *connection,
 754                                                  const gchar *sender_name,
 755                                                  const gchar *object_path,
 756                                                  const gchar *interface_name,
 757                                                  const gchar *signal_name,
 758                                                  GVariant *parameters,
 759                                                  gpointer user_data)
 760 {
 761         bt_event_info_t *event_info;
 762         int result = BLUETOOTH_ERROR_NONE;
 763
 764         event_info = (bt_event_info_t *)user_data;
 765         ret_if(event_info == NULL);
 766
 767 #ifdef GATT_NO_RELAY
 768         gboolean gatt_interface = FALSE;
 769
 770         if (strcasecmp(interface_name, BT_GATT_CHARACTERISTIC_INTERFACE) == 0)
 771                 gatt_interface = TRUE;
 772
 773         if (strcasecmp(object_path, BT_DEVICE_PATH) != 0 &&
 774                  gatt_interface == FALSE)
 775                 return;
 776         if (strcasecmp(interface_name, BT_EVENT_SERVICE) != 0 &&
 777                  gatt_interface == FALSE)
 778                 return;
 779 #else
 780         if (strcasecmp(object_path, BT_DEVICE_PATH) != 0)
 781                 return;
 782         if (strcasecmp(interface_name, BT_EVENT_SERVICE) != 0)
 783                 return;
 784 #endif
 785
 786         ret_if(signal_name == NULL);
 787
 788         if (strcasecmp(signal_name, BT_GATT_CONNECTED) == 0) {
 789                 const char *address = NULL;
 790                 bluetooth_device_address_t dev_address = { {0} };
 791                 BT_DBG("BT_GATT_CONNECTED");
 792                 g_variant_get(parameters, "(i&s)", &result, &address);
 793
 794                 _bt_convert_addr_string_to_type(dev_address.addr, address);
 795                 BT_DBG("Sending Event to Framework");
 796                 _bt_common_event_cb(BLUETOOTH_EVENT_GATT_CONNECTED,
 797                                 result, &dev_address,
 798                                 event_info->cb, event_info->user_data);
 799         } else if (strcasecmp(signal_name, BT_GATT_DISCONNECTED) == 0) {
 800                 const char *address = NULL;
 801                 bluetooth_device_address_t dev_address = { {0} };
 802                 BT_DBG("BT_GATT_DISCONNECTED");
 803                 g_variant_get(parameters, "(i&s)", &result, &address);
 804
 805                 _bt_convert_addr_string_to_type(dev_address.addr, address);
 806                 BT_DBG("Sending Event to Framework");
 807                 _bt_common_event_cb(BLUETOOTH_EVENT_GATT_DISCONNECTED,
 808                                 result, &dev_address,
 809                                 event_info->cb, event_info->user_data);
 810         } else if (strcasecmp(signal_name, BT_GATT_REQ_ATT_MTU_CHANGED) == 0) {
 811                 const char *address = NULL;
 812                 bluetooth_device_address_t dev_address = { {0} };
 813                 bluetooth_le_att_mtu_info_t att_mtu_info;
 814                 guint16 mtu;
 815                 guint8 status;
 816                 BT_DBG("BT_GATT_REQ_ATT_MTU_CHANGED");
 817                 g_variant_get(parameters, "(i&sqy)", &result, &address, &mtu, &status);
 818
 819                 _bt_convert_addr_string_to_type(dev_address.addr, address);
 820
 821                 memset(&att_mtu_info, 0x00, sizeof(bluetooth_le_att_mtu_info_t));
 822                 memcpy(att_mtu_info.device_address.addr,
 823                                         dev_address.addr,
 824                                         BLUETOOTH_ADDRESS_LENGTH);
 825
 826                 att_mtu_info.mtu = mtu;
 827                 att_mtu_info.status = status;
 828
 829                 _bt_common_event_cb(BLUETOOTH_EVENT_GATT_ATT_MTU_CHANGED,
 830                                 result, &att_mtu_info,
 831                                 event_info->cb, event_info->user_data);
 832 #ifdef GATT_NO_RELAY
 833         } else if (strcasecmp(signal_name, BT_GATT_BLUEZ_CHAR_VAL_CHANGED) == 0) {
 834 #else
 835         } else if (strcasecmp(signal_name, BT_GATT_CHAR_VAL_CHANGED) == 0) {
 836 #endif
 837                 const char *char_handle = NULL;
 838                 int len = 0;
 839                 const char * value = NULL;
 840                 GVariant *char_value_var = NULL;
 841                 bt_gatt_char_value_t char_val = { 0, };
 842                 BT_DBG("BT_GATT_CHAR_VAL_CHANGED");
 843
 844                 g_variant_get(parameters, "(i&s@ay)", &result, &char_handle, &char_value_var);
 845
 846                 len = g_variant_get_size(char_value_var);
 847                 if (len > 0)
 848                         value = (char *)g_variant_get_data(char_value_var);
 849
 850                 char_val.char_handle = g_strdup(char_handle);
 851                 char_val.val_len = len;
 852                 /* Fix : FORWARD_NULL : g_variant_get_data can return NULL */
 853                 if (char_val.val_len > 0 && value != NULL) {
 854                         char_val.char_value = (unsigned char*) g_malloc0(char_val.val_len);
 855                         /* Fix : NULL_RETURNS */
 856                         if (char_val.char_value == NULL) {
 857                                 BT_ERR("BLUETOOTH_ERROR_OUT_OF_MEMORY");
 858                                 g_free(char_val.char_handle);
 859                                 if (char_value_var)
 860                                         g_variant_unref(char_value_var);
 861                                 return;
 862                         }
 863                         memcpy(char_val.char_value, value, len);
 864                         _bt_common_event_cb(BLUETOOTH_EVENT_GATT_CHAR_VAL_CHANGED,
 865                                         result, &char_val,
 866                                         event_info->cb, event_info->user_data);
 867                         g_free(char_val.char_value);
 868                         if (char_value_var)
 869                                 g_variant_unref(char_value_var);
 870                 }
 871                 g_free(char_val.char_handle);
 872         } else if (strcasecmp(signal_name, BT_DEVICE_CONNECTED) == 0) {
 873                 const char *address = NULL;
 874                 unsigned char addr_type;
 875                 bt_connection_info_t conn_info;
 876                 bluetooth_device_address_t dev_address = { {0} };
 877                 BT_DBG("BT_DEVICE_CONNECTED");
 878                 g_variant_get(parameters, "(i&sy)", &result, &address, &addr_type);
 879
 880                 _bt_convert_addr_string_to_type(dev_address.addr,
 881                                                 address);
 882
 883                 memset(&conn_info, 0x00, sizeof(bt_connection_info_t));
 884
 885                 memcpy(conn_info.device_addr.addr,
 886                                         dev_address.addr,
 887                                         BLUETOOTH_ADDRESS_LENGTH);
 888
 889                 conn_info.addr_type = addr_type;
 890                 conn_info.disc_reason = 0;
 891                 BT_DBG("Sending Event to Framework");
 892                 _bt_common_event_cb(BLUETOOTH_EVENT_DEVICE_CONNECTED,
 893                                 result, &conn_info,
 894                                 event_info->cb, event_info->user_data);
 895
 896         } else if (strcasecmp(signal_name, BT_DEVICE_DISCONNECTED) == 0) {
 897                 const char *address = NULL;
 898                 unsigned char addr_type;
 899                 bt_connection_info_t conn_info;
 900                 bluetooth_device_address_t dev_address = { {0} };
 901                 BT_DBG("BT_DEVICE_DISCONNECTED");
 902                 g_variant_get(parameters, "(i&sy)", &result, &address, &addr_type);
 903
 904                 _bt_convert_addr_string_to_type(dev_address.addr,
 905                                                 address);
 906
 907                 memset(&conn_info, 0x00, sizeof(bt_connection_info_t));
 908
 909                 memcpy(conn_info.device_addr.addr,
 910                                         dev_address.addr,
 911                                         BLUETOOTH_ADDRESS_LENGTH);
 912
 913                 conn_info.addr_type = addr_type;
 914                 conn_info.disc_reason = result;
 915                 BT_DBG("Sending Event to Framework");
 916                 _bt_common_event_cb(BLUETOOTH_EVENT_DEVICE_DISCONNECTED,
 917                                 result, &conn_info,
 918                                 event_info->cb, event_info->user_data);
 919
 920         } else if (strcasecmp(signal_name, BT_RSSI_MONITORING_ENABLED) == 0) {
 921                 bt_rssi_enabled_t enabled = { 0, };
 922                 char *address;
 923                 int link_type;
 924                 gboolean rssi_enabled = FALSE;
 925
 926                 g_variant_get(parameters, "(isib)", &result, &address,
 927                                         &link_type, &rssi_enabled);
 928
 929                 BT_DBG("RSSI Enabled[Address:%s LinkType:%d RSSI_dbm:%d]",
 930                                 address, link_type, rssi_enabled);
 931                 enabled.address = address;
 932                 enabled.link_type = link_type;
 933                 enabled.rssi_enabled = rssi_enabled;
 934
 935                 _bt_common_event_cb(BLUETOOTH_EVENT_RSSI_ENABLED,
 936                                 result, &enabled,
 937                                 event_info->cb, event_info->user_data);
 938         } else if (strcasecmp(signal_name, BT_RSSI_ALERT) == 0) {
 939                 int alert_type;
 940                 int rssi_dbm;
 941                 char *address;
 942                 int link_type;
 943                 bt_rssi_alert_t alert = { 0, };
 944
 945                 g_variant_get(parameters, "(isiii)", &result, &address,
 946                                         &link_type, &alert_type, &rssi_dbm);
 947
 948                 alert.alert_type = alert_type;
 949                 alert.rssi_dbm = rssi_dbm;
 950                 alert.address = address;
 951                 alert.link_type = link_type;
 952                 BT_DBG("Address [%s] LinkType[%d] AlertType[%d] RSSI dBm[%d]",
 953                                 address, link_type, alert_type, rssi_dbm);
 954                 _bt_common_event_cb(BLUETOOTH_EVENT_RSSI_ALERT,
 955                                 result, &alert,
 956                                 event_info->cb, event_info->user_data);
 957         } else if (strcasecmp(signal_name, BT_RAW_RSSI_EVENT) == 0) {
 958                 int rssi_dbm;
 959                 int link_type;
 960                 char *address;
 961                 bt_raw_rssi_t raw_rssi = { 0, };
 962
 963                 g_variant_get(parameters, "(isii)", &result,
 964                                         &address, &link_type, &rssi_dbm);
 965
 966                 BT_DBG("Address [%s] Link Type[%d] dBm[%d]",
 967                                 address, link_type, rssi_dbm);
 968
 969                 raw_rssi.rssi_dbm = rssi_dbm;
 970                 raw_rssi.address = address;
 971                 raw_rssi.link_type = link_type;
 972
 973                 _bt_common_event_cb(BLUETOOTH_EVENT_RAW_RSSI,
 974                                 result, &raw_rssi,
 975                                 event_info->cb, event_info->user_data);
 976         } else if (strcasecmp(signal_name, BT_DEVICE_AUTHORIZED) == 0) {
 977                 const char *address = NULL;
 978                 bluetooth_device_address_t dev_address = { {0} };
 979
 980                 g_variant_get(parameters, "(i&s)", &result, &address);
 981
 982                 _bt_convert_addr_string_to_type(dev_address.addr,
 983                                                 address);
 984
 985                 _bt_common_event_cb(BLUETOOTH_EVENT_DEVICE_AUTHORIZED,
 986                                 result, &dev_address,
 987                                 event_info->cb, event_info->user_data);
 988         } else if (strcasecmp(signal_name, BT_DEVICE_UNAUTHORIZED) == 0) {
 989                 const char *address = NULL;
 990                 bluetooth_device_address_t dev_address = { {0} };
 991
 992                 g_variant_get(parameters, "(i&s)", &result, &address);
 993
 994                 _bt_convert_addr_string_to_type(dev_address.addr,
 995                                                 address);
 996
 997                 _bt_common_event_cb(BLUETOOTH_EVENT_DEVICE_UNAUTHORIZED,
 998                                 result, &dev_address,
 999                                 event_info->cb, event_info->user_data);
1000         } else if (strcasecmp(signal_name, BT_SUPPORTED_PROFILE_TRUSTED) == 0) {
1001                 char *address;
1002                 bt_supported_profile_trusted_t profile_info = { 0, };
1003                 int trust;
1004
1005                 g_variant_get(parameters, "(i&si)", &result,
1006                                         &address, &trust);
1007
1008                 BT_DBG("Address [%s] trust[%d]", address, trust);
1009                 profile_info.address = address;
1010                 if (trust & (PROFILE_SUPPORTED << 0)) { /* Bit 0 & 1 - for PBAP Supported */
1011                         profile_info.profile = TRUSTED_PROFILE_PBAP;
1012                         profile_info.supported = TRUE;
1013                         if (trust & (1 << 1)) /* Bit 1 - for PBAP Trusted */
1014                                 profile_info.trusted = TRUE;
1015                         else
1016                                 profile_info.trusted = FALSE;
1017
1018                         _bt_common_event_cb(BLUETOOTH_EVENT_SUPPORTED_PROFILE_TRUSTED,
1019                                         result, &profile_info,
1020                                         event_info->cb, event_info->user_data);
1021                 }
1022                 if (trust & (PROFILE_SUPPORTED <<2 )) { /* Bit 2 & 3 - for MAP Supported */
1023                         profile_info.profile = TRUSTED_PROFILE_MAP;
1024                         profile_info.supported = TRUE;
1025                         if (trust & (1 <<3 )) /* Bit 3 - for PBAP Trusted */
1026                                 profile_info.trusted = TRUE;
1027                         else
1028                                 profile_info.trusted = FALSE;
1029
1030                         _bt_common_event_cb(BLUETOOTH_EVENT_SUPPORTED_PROFILE_TRUSTED,
1031                                         result, &profile_info,
1032                                         event_info->cb, event_info->user_data);
1033                 }
1034                 if (trust & (PROFILE_SUPPORTED <<4 )) { /* Bit 4 & 5- for SAP Supported */
1035                         profile_info.profile = TRUSTED_PROFILE_SAP;
1036                         profile_info.supported = TRUE;
1037                         if (trust & (1 <<5 )) /* Bit 5 - for SAP Trusted */
1038                                 profile_info.trusted = TRUE;
1039                         else
1040                                 profile_info.trusted = FALSE;
1041
1042                         _bt_common_event_cb(BLUETOOTH_EVENT_SUPPORTED_PROFILE_TRUSTED,
1043                                         result, &profile_info,
1044                                         event_info->cb, event_info->user_data);
1045                 }
1046         } else if (strcasecmp(signal_name, BT_IPSP_CONNECTED) == 0) {
1047                 const char *address = NULL;
1048                 const char *if_name = NULL;
1049                 bt_ipsp_connection_info_t bt_ipsp_iface_info;
1050                 memset(&bt_ipsp_iface_info, 0, sizeof(bt_ipsp_iface_info));
1051
1052                 BT_DBG("BT_IPSP_CONNECTED");
1053                 g_variant_get(parameters, "(i&s&s)", &result, &address, &if_name);
1054
1055                 _bt_convert_addr_string_to_type(bt_ipsp_iface_info.btaddr.addr, address);
1056                 memcpy(bt_ipsp_iface_info.if_name, if_name, 16);
1057
1058                 _bt_common_event_cb(BLUETOOTH_EVENT_IPSP_CONNECTED,
1059                                 result, &bt_ipsp_iface_info,
1060                                 event_info->cb, event_info->user_data);
1061         } else if (strcasecmp(signal_name, BT_IPSP_DISCONNECTED) == 0) {
1062                 const char *address = NULL;
1063                 const char *if_name = NULL;
1064                 bt_ipsp_connection_info_t bt_ipsp_iface_info;
1065                 memset(&bt_ipsp_iface_info, 0, sizeof(bt_ipsp_iface_info));
1066
1067                 BT_DBG("BT_IPSP_DISCONNECTED");
1068                 g_variant_get(parameters, "(i&s&s)", &result, &address, &if_name);
1069
1070                 _bt_convert_addr_string_to_type(bt_ipsp_iface_info.btaddr.addr, address);
1071                 memcpy(bt_ipsp_iface_info.if_name, if_name, 16);
1072
1073                 _bt_common_event_cb(BLUETOOTH_EVENT_IPSP_DISCONNECTED,
1074                                 result, &bt_ipsp_iface_info,
1075                                 event_info->cb, event_info->user_data);
1076         } else if (strcasecmp(signal_name, BT_LE_DATA_LENGTH_CHANGED) == 0) {
1077                 const char *address = NULL;
1078                 bluetooth_device_address_t dev_address = { {0} };
1079                 uint tx_octets = 0;
1080                 uint tx_time = 0;
1081                 uint rx_octets = 0;
1082                 uint rx_time = 0;
1083                 bt_le_data_length_params_t params;
1084
1085                 BT_DBG("BT_LE_DATA_LENGTH_CHANGED");
1086
1087                 g_variant_get(parameters, "(i&sqqqq)", &result, &address,
1088                                 tx_octets, tx_time, rx_octets, rx_time);
1089
1090                 params.max_tx_octets = tx_octets;
1091                 params.max_tx_time = tx_time;
1092                 params.max_rx_octets = rx_octets;
1093                 params.max_rx_time = rx_time;
1094
1095                 _bt_convert_addr_string_to_type(dev_address.addr, address);
1096
1097                 memcpy(&params.device_address,
1098                         &dev_address, BLUETOOTH_ADDRESS_LENGTH);
1099
1100                 _bt_common_event_cb(BLUETOOTH_EVENT_LE_DATA_LENGTH_CHANGED,
1101                                 result, &params, event_info->cb, event_info->user_data);
1102         }
1103 }
1104
1105 void __bt_hid_event_filter(GDBusConnection *connection,
1106                                                  const gchar *sender_name,
1107                                                  const gchar *object_path,
1108                                                  const gchar *interface_name,
1109                                                  const gchar *signal_name,
1110                                                  GVariant *parameters,
1111                                                  gpointer user_data)
1112 {
1113         bt_event_info_t *event_info;
1114         int result = BLUETOOTH_ERROR_NONE;
1115
1116         event_info = (bt_event_info_t *)user_data;
1117         ret_if(event_info == NULL);
1118
1119         if (strcasecmp(object_path, BT_HID_PATH) != 0)
1120                 return;
1121         if (strcasecmp(interface_name, BT_EVENT_SERVICE) != 0)
1122                 return;
1123
1124         ret_if(signal_name == NULL);
1125
1126         if (strcasecmp(signal_name, BT_INPUT_CONNECTED) == 0) {
1127                 const char *address = NULL;
1128                 bluetooth_device_address_t dev_address = { {0} };
1129
1130                 g_variant_get(parameters, "(i&s)", &result, &address);
1131
1132                 _bt_convert_addr_string_to_type(dev_address.addr,
1133                                                 address);
1134
1135                 _bt_input_event_cb(BLUETOOTH_HID_CONNECTED,
1136                                 result, &dev_address,
1137                                 event_info->cb, event_info->user_data);
1138         } else if (strcasecmp(signal_name, BT_INPUT_DISCONNECTED) == 0) {
1139                 const char *address = NULL;
1140                 bluetooth_device_address_t dev_address = { {0} };
1141
1142                 g_variant_get(parameters, "(i&s)", &result, &address);
1143
1144                 BT_DBG("address: %s", address);
1145
1146                 _bt_convert_addr_string_to_type(dev_address.addr,
1147                                                 address);
1148
1149                 _bt_input_event_cb(BLUETOOTH_HID_DISCONNECTED,
1150                                 result, &dev_address,
1151                                 event_info->cb, event_info->user_data);
1152         }
1153 }
1154
1155 void __bt_headset_event_filter(GDBusConnection *connection,
1156                                                  const gchar *sender_name,
1157                                                  const gchar *object_path,
1158                                                  const gchar *interface_name,
1159                                                  const gchar *signal_name,
1160                                                  GVariant *parameters,
1161                                                  gpointer user_data)
1162 {
1163         bt_event_info_t *event_info;
1164         int result = BLUETOOTH_ERROR_NONE;
1165         event_info = (bt_event_info_t *)user_data;
1166         ret_if(event_info == NULL);
1167
1168         if (strcasecmp(object_path, BT_HEADSET_PATH) != 0)
1169                 return;
1170         if (strcasecmp(interface_name, BT_EVENT_SERVICE) != 0)
1171                 return;
1172
1173         ret_if(signal_name == NULL);
1174
1175         if (strcasecmp(signal_name, BT_HEADSET_CONNECTED) == 0) {
1176                 char *address = NULL;
1177
1178                 g_variant_get(parameters, "(i&s)", &result, &address);
1179
1180                 _bt_headset_event_cb(BLUETOOTH_EVENT_AG_CONNECTED,
1181                                 result, address,
1182                                 event_info->cb, event_info->user_data);
1183         } else if (strcasecmp(signal_name, BT_HEADSET_DISCONNECTED) == 0) {
1184                 char *address = NULL;
1185
1186                 g_variant_get(parameters, "(i&s)", &result, &address);
1187
1188                 _bt_headset_event_cb(BLUETOOTH_EVENT_AG_DISCONNECTED,
1189                                 result, address,
1190                                 event_info->cb, event_info->user_data);
1191         } else if (strcasecmp(signal_name, BT_STEREO_HEADSET_CONNECTED) == 0) {
1192                 char *address = NULL;
1193
1194                 g_variant_get(parameters, "(i&s)", &result, &address);
1195
1196                 _bt_headset_event_cb(BLUETOOTH_EVENT_AV_CONNECTED,
1197                                 result, address,
1198                                 event_info->cb, event_info->user_data);
1199         } else if (strcasecmp(signal_name, BT_STEREO_HEADSET_DISCONNECTED) == 0) {
1200                 char *address = NULL;
1201
1202                 g_variant_get(parameters, "(i&s)", &result, &address);
1203
1204                 _bt_headset_event_cb(BLUETOOTH_EVENT_AV_DISCONNECTED,
1205                                 result, address,
1206                                 event_info->cb, event_info->user_data);
1207         } else if (strcasecmp(signal_name, BT_A2DP_SOURCE_CONNECTED) == 0) {
1208                 char *address = NULL;
1209
1210                 g_variant_get(parameters, "(i&s)", &result, &address);
1211                 _bt_a2dp_source_event_cb(BLUETOOTH_EVENT_AV_SOURCE_CONNECTED,
1212                                                 result, address,
1213                                                 event_info->cb, event_info->user_data);
1214         } else if (strcasecmp(signal_name, BT_A2DP_SOURCE_DISCONNECTED) == 0) {
1215                 char *address = NULL;
1216
1217                 g_variant_get(parameters, "(i&s)", &result, &address);
1218
1219                 _bt_a2dp_source_event_cb(BLUETOOTH_EVENT_AV_SOURCE_DISCONNECTED,
1220                                                 result, address,
1221                                                 event_info->cb, event_info->user_data);
1222         } else if (strcasecmp(signal_name, BT_SPEAKER_GAIN) == 0) {
1223                 unsigned int gain;
1224                 guint16 spkr_gain;
1225                 char *address = NULL;
1226
1227                 g_variant_get(parameters, "(i&sq)", &result, &address,
1228                                                                 &spkr_gain);
1229                 gain = (unsigned int)spkr_gain;
1230
1231                 _bt_headset_event_cb(BLUETOOTH_EVENT_AG_SPEAKER_GAIN,
1232                                 result, &gain,
1233                                 event_info->cb, event_info->user_data);
1234         } else if (strcasecmp(signal_name, BT_MICROPHONE_GAIN) == 0) {
1235                 unsigned int gain;
1236                 guint16 mic_gain;
1237                 char *address = NULL;
1238
1239                 g_variant_get(parameters, "(i&sq)", &result,
1240                                                 &address, &mic_gain);
1241                 gain = (unsigned int)mic_gain;
1242
1243                 _bt_headset_event_cb(BLUETOOTH_EVENT_AG_MIC_GAIN,
1244                                 result, &gain,
1245                                 event_info->cb, event_info->user_data);
1246         }
1247 }
1248
1249 void __bt_hid_device_event_filter(GDBusConnection *connection,
1250                                                  const gchar *sender_name,
1251                                                  const gchar *object_path,
1252                                                  const gchar *interface_name,
1253                                                  const gchar *signal_name,
1254                                                  GVariant *parameters,
1255                                                  gpointer user_data)
1256 {
1257         bt_event_info_t *event_info;
1258         int result = BLUETOOTH_ERROR_NONE;
1259
1260         event_info = (bt_event_info_t *)user_data;
1261         ret_if(event_info == NULL);
1262         if (strcasecmp(object_path, BT_HID_DEVICE_PATH) != 0)
1263                 return;
1264         if (strcasecmp(interface_name, BT_EVENT_SERVICE) != 0)
1265                 return;
1266
1267         ret_if(signal_name == NULL);
1268
1269         if (strcasecmp(signal_name, BT_HID_DEVICE_CONNECTED) == 0) {
1270                 const char *address = NULL;
1271                 bluetooth_device_address_t dev_address = { {0} };
1272
1273                 g_variant_get(parameters, "(i&s)", &result, &address);
1274
1275                 _bt_convert_addr_string_to_type(dev_address.addr,
1276                                                 address);
1277
1278                 _bt_input_event_cb(BLUETOOTH_HID_DEVICE_CONNECTED,
1279                                 result, &dev_address,
1280                                 event_info->cb, event_info->user_data);
1281         } else if (strcasecmp(signal_name, BT_HID_DEVICE_DISCONNECTED) == 0) {
1282                 const char *address = NULL;
1283                 bluetooth_device_address_t dev_address = { {0} };
1284
1285                 g_variant_get(parameters, "(i&s)", &result, &address);
1286
1287                 BT_DBG("address: %s", address);
1288
1289                 _bt_convert_addr_string_to_type(dev_address.addr,
1290                                                 address);
1291
1292                 _bt_input_event_cb(BLUETOOTH_HID_DEVICE_DISCONNECTED,
1293                                 result, &dev_address,
1294                                 event_info->cb, event_info->user_data);
1295         } else if (strcasecmp(signal_name, BT_INPUT_HID_DEVICE_CONNECTED) == 0) {
1296                 BT_INFO_C("Type %s", g_variant_get_type_string(parameters));
1297                 const char *address = NULL;
1298                 bluetooth_device_address_t dev_address = { {0} };
1299
1300                 g_variant_get(parameters, "(i&s)", &result, &address);
1301
1302                 BT_DBG("address: %s", address);
1303                 _bt_convert_addr_string_to_type(dev_address.addr,
1304                                                 address);
1305                 int ctrl = -1, intr = -1;
1306                 _bt_hid_device_get_fd(address, &ctrl, &intr);
1307                 if (ctrl != -1 && intr != -1) {
1308                         new_hid_connection(NULL, ctrl, &dev_address);
1309                         new_hid_connection(NULL, intr, &dev_address);
1310                 }
1311         } else if (strcasecmp(signal_name, BT_INPUT_HID_DEVICE_DISCONNECTED) == 0) {
1312                 const char *address = NULL;
1313                 g_variant_get(parameters, "(i&s)", &result, &address);
1314
1315                 BT_DBG("address: %s", address);
1316         }
1317 }
1318 void __bt_a2dp_source_event_filter(GDBusConnection *connection,
1319                                                  const gchar *sender_name,
1320                                                  const gchar *object_path,
1321                                                  const gchar *interface_name,
1322                                                  const gchar *signal_name,
1323                                                  GVariant *parameters,
1324                                                  gpointer user_data)
1325 {
1326         bt_event_info_t *event_info;
1327         int result = BLUETOOTH_ERROR_NONE;
1328         event_info = (bt_event_info_t *)user_data;
1329         ret_if(event_info == NULL);
1330
1331         if (strcasecmp(object_path, BT_A2DP_SOURCE_PATH) != 0)
1332                 return;
1333         if (strcasecmp(interface_name, BT_EVENT_SERVICE) != 0)
1334                 return;
1335
1336         ret_if(signal_name == NULL);
1337
1338         if (strcasecmp(signal_name, BT_A2DP_SOURCE_CONNECTED) == 0) {
1339                 char *address = NULL;
1340
1341                 g_variant_get(parameters, "(i&s)", &result, &address);
1342                 _bt_a2dp_source_event_cb(BLUETOOTH_EVENT_AV_SOURCE_CONNECTED,
1343                                                 result, address,
1344                                                 event_info->cb, event_info->user_data);
1345         } else if (strcasecmp(signal_name, BT_A2DP_SOURCE_DISCONNECTED) == 0) {
1346                 char *address = NULL;
1347
1348                 g_variant_get(parameters, "(i&s)", &result, &address);
1349
1350                 _bt_a2dp_source_event_cb(BLUETOOTH_EVENT_AV_SOURCE_DISCONNECTED,
1351                                                 result, address,
1352                                                 event_info->cb, event_info->user_data);
1353         }
1354 }
1355
1356 void __bt_network_event_filter(GDBusConnection *connection,
1357                                                  const gchar *sender_name,
1358                                                  const gchar *object_path,
1359                                                  const gchar *interface_name,
1360                                                  const gchar *signal_name,
1361                                                  GVariant *parameters,
1362                                                  gpointer user_data)
1363 {
1364         bt_event_info_t *event_info;
1365         int result = BLUETOOTH_ERROR_NONE;
1366         event_info = (bt_event_info_t *)user_data;
1367         ret_if(event_info == NULL);
1368
1369         if (strcasecmp(object_path, BT_NETWORK_PATH) != 0)
1370                 return;
1371         if (strcasecmp(interface_name, BT_EVENT_SERVICE) != 0)
1372                 return;
1373
1374         ret_if(signal_name == NULL);
1375
1376         if (strcasecmp(signal_name, BT_NETWORK_CONNECTED) == 0) {
1377                 const char *address = NULL;
1378                 bluetooth_device_address_t dev_address = { {0} };
1379
1380                 g_variant_get(parameters, "(i&s)", &result, &address);
1381
1382                 _bt_convert_addr_string_to_type(dev_address.addr,
1383                                                 address);
1384
1385                 _bt_common_event_cb(BLUETOOTH_EVENT_NETWORK_CONNECTED,
1386                                 result, &dev_address,
1387                                 event_info->cb, event_info->user_data);
1388         } else if (strcasecmp(signal_name, BT_NETWORK_DISCONNECTED) == 0) {
1389                 const char *address = NULL;
1390                 bluetooth_device_address_t dev_address = { {0} };
1391
1392                 g_variant_get(parameters, "(i&s)", &result, &address);
1393
1394                 _bt_convert_addr_string_to_type(dev_address.addr,
1395                                                 address);
1396
1397                 _bt_common_event_cb(BLUETOOTH_EVENT_NETWORK_DISCONNECTED,
1398                                 result, &dev_address,
1399                                 event_info->cb, event_info->user_data);
1400         } else if (strcasecmp(signal_name, BT_NETWORK_SERVER_CONNECTED) == 0) {
1401                 const char *device = NULL;
1402                 const char *address = NULL;
1403                 bluetooth_network_device_info_t network_info;
1404
1405                 g_variant_get(parameters, "(i&s&s)", &result,
1406                                                         &device, &address);
1407
1408                 memset(&network_info, 0x00, sizeof(bluetooth_network_device_info_t));
1409
1410                 _bt_convert_addr_string_to_type(network_info.device_address.addr,
1411                                                 address);
1412
1413                 _bt_print_device_address_t(&network_info.device_address);
1414                 g_strlcpy(network_info.interface_name, device,
1415                                         sizeof(network_info.interface_name));
1416
1417                 DBG_SECURE("Interface: %s", network_info.interface_name);
1418
1419                 _bt_common_event_cb(BLUETOOTH_EVENT_NETWORK_SERVER_CONNECTED,
1420                                 result, &network_info,
1421                                 event_info->cb, event_info->user_data);
1422         } else if (strcasecmp(signal_name, BT_NETWORK_SERVER_DISCONNECTED) == 0) {
1423                 const char *device = NULL;
1424                 const char *address = NULL;
1425                 bluetooth_network_device_info_t network_info;
1426
1427                 g_variant_get(parameters, "(i&s&s)", &result, &device, &address);
1428
1429                 memset(&network_info, 0x00, sizeof(bluetooth_network_device_info_t));
1430
1431                 _bt_convert_addr_string_to_type(network_info.device_address.addr,
1432                                                 address);
1433
1434                 _bt_print_device_address_t(&network_info.device_address);
1435
1436                 _bt_common_event_cb(BLUETOOTH_EVENT_NETWORK_SERVER_DISCONNECTED,
1437                                 result, &network_info,
1438                                 event_info->cb, event_info->user_data);
1439         }
1440 }
1441
1442 void __bt_avrcp_event_filter(GDBusConnection *connection,
1443                                                  const gchar *sender_name,
1444                                                  const gchar *object_path,
1445                                                  const gchar *interface_name,
1446                                                  const gchar *signal_name,
1447                                                  GVariant *parameters,
1448                                                  gpointer user_data)
1449 {
1450         bt_event_info_t *event_info;
1451         int result = BLUETOOTH_ERROR_NONE;
1452         event_info = (bt_event_info_t *)user_data;
1453         ret_if(event_info == NULL);
1454
1455         if (strcasecmp(object_path, BT_AVRCP_PATH) != 0)
1456                 return;
1457         if (strcasecmp(interface_name, BT_EVENT_SERVICE) != 0)
1458                 return;
1459
1460         ret_if(signal_name == NULL);
1461
1462         if (strcasecmp(signal_name, BT_AVRCP_CONNECTED) == 0) {
1463                 char *address = NULL;
1464
1465                 g_variant_get(parameters, "(i&s)", &result, &address);
1466
1467                 _bt_avrcp_event_cb(BLUETOOTH_EVENT_AVRCP_CONNECTED,
1468                                 result, address,
1469                                 event_info->cb, event_info->user_data);
1470         } else if (strcasecmp(signal_name, BT_AVRCP_DISCONNECTED) == 0) {
1471                 char *address = NULL;
1472
1473                 g_variant_get(parameters, "(i&s)", &result, &address);
1474
1475                 _bt_avrcp_event_cb(BLUETOOTH_EVENT_AVRCP_DISCONNECTED,
1476                                 result, address,
1477                                 event_info->cb, event_info->user_data);
1478         } else if (strcasecmp(signal_name, BT_MEDIA_SHUFFLE_STATUS) == 0) {
1479                 unsigned int status;
1480
1481                 g_variant_get(parameters, "(u)", &status);
1482                 _bt_avrcp_event_cb(BLUETOOTH_EVENT_AVRCP_SETTING_SHUFFLE_STATUS,
1483                                 result, &status,
1484                                 event_info->cb, event_info->user_data);
1485         } else if (strcasecmp(signal_name, BT_MEDIA_EQUALIZER_STATUS) == 0) {
1486                 unsigned int status;
1487
1488                 g_variant_get(parameters, "(u)", &status);
1489                 _bt_avrcp_event_cb(BLUETOOTH_EVENT_AVRCP_SETTING_EQUALIZER_STATUS,
1490                                 result, &status,
1491                                 event_info->cb, event_info->user_data);
1492         } else if (strcasecmp(signal_name, BT_MEDIA_REPEAT_STATUS) == 0) {
1493                 unsigned int status;
1494
1495                 g_variant_get(parameters, "(u)", &status);
1496                 _bt_avrcp_event_cb(BLUETOOTH_EVENT_AVRCP_SETTING_REPEAT_STATUS,
1497                                 result, &status,
1498                                 event_info->cb, event_info->user_data);
1499         }  else if (strcasecmp(signal_name, BT_MEDIA_SCAN_STATUS) == 0) {
1500                 unsigned int status;
1501
1502                 g_variant_get(parameters, "(u)", &status);
1503                 _bt_avrcp_event_cb(BLUETOOTH_EVENT_AVRCP_SETTING_SCAN_STATUS,
1504                                 result, &status,
1505                                 event_info->cb, event_info->user_data);
1506         }
1507 }
1508
1509 void __bt_avrcp_control_event_filter(GDBusConnection *connection,
1510                                                 const gchar *sender_name,
1511                                                 const gchar *object_path,
1512                                                 const gchar *interface_name,
1513                                                 const gchar *signal_name,
1514                                                 GVariant *parameters,
1515                                                 gpointer user_data)
1516 {
1517         bt_event_info_t *event_info;
1518         int result = BLUETOOTH_ERROR_NONE;
1519         event_info = (bt_event_info_t *)user_data;
1520         ret_if(event_info == NULL);
1521
1522         if (strcasecmp(object_path, BT_AVRCP_CONTROL_PATH) != 0)
1523                 return;
1524         if (strcasecmp(interface_name, BT_EVENT_SERVICE) != 0)
1525                 return;
1526
1527         ret_if(signal_name == NULL);
1528
1529         if (strcasecmp(signal_name, BT_AVRCP_CONNECTED) == 0) {
1530                 char *address = NULL;
1531
1532                 g_variant_get(parameters, "(i&s)", &result, &address);
1533
1534                 _bt_avrcp_event_cb(BLUETOOTH_EVENT_AVRCP_CONTROL_CONNECTED,
1535                                 result, address,
1536                                 event_info->cb, event_info->user_data);
1537         } else if (strcasecmp(signal_name, BT_AVRCP_DISCONNECTED) == 0) {
1538                 char *address = NULL;
1539
1540                 g_variant_get(parameters, "(i&s)", &result, &address);
1541
1542                 _bt_avrcp_event_cb(BLUETOOTH_EVENT_AVRCP_CONTROL_DISCONNECTED,
1543                                 result, address,
1544                                 event_info->cb, event_info->user_data);
1545         } else if (strcasecmp(signal_name, BT_MEDIA_SHUFFLE_STATUS) == 0) {
1546                 unsigned int status;
1547
1548                 g_variant_get(parameters, "(u)", &status);
1549                 _bt_avrcp_event_cb(BLUETOOTH_EVENT_AVRCP_CONTROL_SHUFFLE_STATUS,
1550                                 result, &status,
1551                                 event_info->cb, event_info->user_data);
1552         } else if (strcasecmp(signal_name, BT_MEDIA_EQUALIZER_STATUS) == 0) {
1553                 unsigned int status;
1554
1555                 g_variant_get(parameters, "(u)", &status);
1556                 _bt_avrcp_event_cb(BLUETOOTH_EVENT_AVRCP_CONTROL_EQUALIZER_STATUS,
1557                                 result, &status,
1558                                 event_info->cb, event_info->user_data);
1559         } else if (strcasecmp(signal_name, BT_MEDIA_REPEAT_STATUS) == 0) {
1560                 unsigned int status;
1561
1562                 g_variant_get(parameters, "(u)", &status);
1563                 _bt_avrcp_event_cb(BLUETOOTH_EVENT_AVRCP_CONTROL_REPEAT_STATUS,
1564                                 result, &status,
1565                                 event_info->cb, event_info->user_data);
1566         }  else if (strcasecmp(signal_name, BT_MEDIA_SCAN_STATUS) == 0) {
1567                 unsigned int status;
1568
1569                 g_variant_get(parameters, "(u)", &status);
1570                 _bt_avrcp_event_cb(BLUETOOTH_EVENT_AVRCP_CONTROL_SCAN_STATUS,
1571                                 result, &status,
1572                                 event_info->cb, event_info->user_data);
1573         } else if (strcasecmp(signal_name, BT_MEDIA_PLAY_STATUS) == 0) {
1574                 unsigned int status;
1575
1576                 g_variant_get(parameters, "(u)", &status);
1577                 _bt_avrcp_event_cb(BLUETOOTH_EVENT_AVRCP_PLAY_STATUS_CHANGED,
1578                                 result, &status,
1579                                 event_info->cb, event_info->user_data);
1580         } else if (strcasecmp(signal_name, BT_MEDIA_POSITION_STATUS) == 0) {
1581                 unsigned int status;
1582
1583                 g_variant_get(parameters, "(u)", &status);
1584                 _bt_avrcp_event_cb(BLUETOOTH_EVENT_AVRCP_SONG_POSITION_STATUS,
1585                                 result, &status,
1586                                 event_info->cb, event_info->user_data);
1587         } else if (strcasecmp(signal_name, BT_MEDIA_TRACK_CHANGE) == 0) {
1588                 media_metadata_attributes_t metadata;
1589                 const char *title;
1590                 const char *artist;
1591                 const char *album;
1592                 const char *genre;
1593                 unsigned int total_tracks;
1594                 unsigned int number;
1595                 unsigned int duration;
1596
1597                 g_variant_get(parameters, "(&s&s&s&suuu)", &title,
1598                                                 &artist, &album, &genre,
1599                                                 &total_tracks, &number,
1600                                                 &duration);
1601                 memset(&metadata, 0x00, sizeof(media_metadata_attributes_t));
1602
1603                 metadata.title = title;
1604                 metadata.artist = artist;
1605                 metadata.album = album;
1606                 metadata.genre = genre;
1607                 metadata.total_tracks = total_tracks;
1608                 metadata.number = number;
1609                 metadata.duration = (int64_t)duration;
1610
1611                 _bt_avrcp_event_cb(BLUETOOTH_EVENT_AVRCP_TRACK_CHANGED,
1612                                 result, &metadata,
1613                                 event_info->cb, event_info->user_data);
1614         }
1615 }
1616
1617 void __bt_opp_client_event_filter(GDBusConnection *connection,
1618                                                  const gchar *sender_name,
1619                                                  const gchar *object_path,
1620                                                  const gchar *interface_name,
1621                                                  const gchar *signal_name,
1622                                                  GVariant *parameters,
1623                                                  gpointer user_data)
1624 {
1625         bt_event_info_t *event_info;
1626         int result = BLUETOOTH_ERROR_NONE;
1627         event_info = (bt_event_info_t *)user_data;
1628         ret_if(event_info == NULL);
1629
1630         if (strcasecmp(object_path, BT_OPP_CLIENT_PATH) != 0)
1631                 return;
1632         if (strcasecmp(interface_name, BT_EVENT_SERVICE) != 0)
1633                 return;
1634
1635         ret_if(signal_name == NULL);
1636
1637         if (strcasecmp(signal_name, BT_OPP_CONNECTED) == 0) {
1638                 const char *address = NULL;
1639                 int request_id = 0;
1640                 bluetooth_device_address_t dev_address = { {0} };
1641
1642                 g_variant_get(parameters, "(i&si)", &result,
1643                                                 &address, &request_id);
1644
1645                 if (__bt_is_request_id_exist(request_id) == FALSE) {
1646                         BT_ERR("Different request id!");
1647                         return;
1648                 }
1649
1650                 _bt_convert_addr_string_to_type(dev_address.addr,
1651                                                 address);
1652
1653                 _bt_common_event_cb(BLUETOOTH_EVENT_OPC_CONNECTED,
1654                                 result, &dev_address,
1655                                 event_info->cb, event_info->user_data);
1656
1657                 if (result != BLUETOOTH_ERROR_NONE) {
1658                         __bt_remove_push_request_id(request_id);
1659                 }
1660         } else if (strcasecmp(signal_name, BT_OPP_DISCONNECTED) == 0) {
1661                 const char *address = NULL;
1662                 int request_id = 0;
1663                 bluetooth_device_address_t dev_address = { {0} };
1664
1665                 g_variant_get(parameters, "(i&si)", &result, &address,
1666                                                         &request_id);
1667
1668                 if (__bt_is_request_id_exist(request_id) == FALSE) {
1669                         BT_ERR("Different request id!");
1670                         return;
1671                 }
1672
1673                 _bt_convert_addr_string_to_type(dev_address.addr,
1674                                                 address);
1675
1676                 _bt_common_event_cb(BLUETOOTH_EVENT_OPC_DISCONNECTED,
1677                                 result, &dev_address,
1678                                 event_info->cb, event_info->user_data);
1679
1680                 __bt_remove_push_request_id(request_id);
1681         } else if (strcasecmp(signal_name, BT_TRANSFER_STARTED) == 0) {
1682                 const char *file_name = NULL;
1683                 const char *device_addr = NULL;
1684                 int request_id = 0;
1685                 guint64 size = 0;
1686                 bt_opc_transfer_info_t transfer_info;
1687
1688                 g_variant_get(parameters, "(i&s&sti)", &result, &device_addr, &file_name,
1689                                                 &size, &request_id);
1690
1691                 if (__bt_is_request_id_exist(request_id) == FALSE) {
1692                         BT_ERR("Different request id!");
1693                         return;
1694                 }
1695
1696                 memset(&transfer_info, 0x00, sizeof(bt_opc_transfer_info_t));
1697
1698                 transfer_info.filename = g_strdup(file_name);
1699                 transfer_info.device_addr = g_strdup(device_addr);
1700                 transfer_info.size = size;
1701
1702                 _bt_common_event_cb(BLUETOOTH_EVENT_OPC_TRANSFER_STARTED,
1703                                 result, &transfer_info,
1704                                 event_info->cb, event_info->user_data);
1705
1706                 g_free(transfer_info.device_addr);
1707                 g_free(transfer_info.filename);
1708         } else if (strcasecmp(signal_name, BT_TRANSFER_PROGRESS) == 0) {
1709                 const char *file_name = NULL;
1710                 int request_id = 0;
1711                 guint64 size = 0;
1712                 int progress = 0;
1713                 bt_opc_transfer_info_t transfer_info;
1714
1715                 g_variant_get(parameters, "(i&stii)", &result,
1716                         &file_name, &size, &progress, &request_id);
1717
1718                 if (__bt_is_request_id_exist(request_id) == FALSE) {
1719                         BT_ERR("Different request id!");
1720                         return;
1721                 }
1722
1723                 memset(&transfer_info, 0x00, sizeof(bt_opc_transfer_info_t));
1724
1725                 transfer_info.filename = g_strdup(file_name);
1726                 transfer_info.size = size;
1727                 transfer_info.percentage = progress;
1728
1729                 _bt_common_event_cb(BLUETOOTH_EVENT_OPC_TRANSFER_PROGRESS,
1730                                 result, &transfer_info,
1731                                 event_info->cb, event_info->user_data);
1732
1733                 g_free(transfer_info.filename);
1734         } else if (strcasecmp(signal_name, BT_TRANSFER_COMPLETED) == 0) {
1735                 const char *file_name = NULL;
1736                 const char *device_addr = NULL;
1737                 int request_id = 0;
1738                 guint64 size = 0;
1739                 bt_opc_transfer_info_t transfer_info;
1740
1741                 g_variant_get(parameters, "(i&s&sti)", &result, &device_addr,
1742                                         &file_name, &size, &request_id);
1743
1744                 if (__bt_is_request_id_exist(request_id) == FALSE) {
1745                         BT_ERR("Different request id!");
1746                         return;
1747                 }
1748
1749                 memset(&transfer_info, 0x00, sizeof(bt_opc_transfer_info_t));
1750
1751                 transfer_info.device_addr = g_strdup(device_addr);
1752                 transfer_info.filename = g_strdup(file_name);
1753                 transfer_info.size = size;
1754
1755                 _bt_common_event_cb(BLUETOOTH_EVENT_OPC_TRANSFER_COMPLETE,
1756                                 result, &transfer_info,
1757                                 event_info->cb, event_info->user_data);
1758
1759                 g_free(transfer_info.device_addr);
1760                 g_free(transfer_info.filename);
1761         }
1762 }
1763
1764 void __bt_opp_server_event_filter(GDBusConnection *connection,
1765                                                  const gchar *sender_name,
1766                                                  const gchar *object_path,
1767                                                  const gchar *interface_name,
1768                                                  const gchar *signal_name,
1769                                                  GVariant *parameters,
1770                                                  gpointer user_data)
1771 {
1772         bt_event_info_t *event_info;
1773         int result = BLUETOOTH_ERROR_NONE;
1774         event_info = (bt_event_info_t *)user_data;
1775         ret_if(event_info == NULL);
1776
1777         if (strcasecmp(object_path, BT_OPP_SERVER_PATH) != 0)
1778                 return;
1779         if (strcasecmp(interface_name, BT_EVENT_SERVICE) != 0)
1780                 return;
1781
1782         ret_if(signal_name == NULL);
1783
1784         if (strcasecmp(signal_name, BT_TRANSFER_AUTHORIZED) == 0) {
1785                 /* Native only event */
1786                 const char *file_name = NULL;
1787                 const char *address = NULL;
1788                 const char *device_name = NULL;
1789                 guint64 size = 0;
1790                 bt_obex_server_authorize_into_t auth_info;
1791
1792                 g_variant_get(parameters, "(i&st&s&s)", &result, &file_name, &size,
1793                                 &address, &device_name);
1794
1795                 /* OSP server: Don't get this event */
1796                 ret_if(obex_server_id == BT_CUSTOM_SERVER);
1797
1798                 memset(&auth_info, 0x00, sizeof(bt_obex_server_authorize_into_t));
1799
1800                 auth_info.filename = g_strdup(file_name);
1801                 auth_info.length = size;
1802                 auth_info.address = g_strdup(address);
1803                 auth_info.name = g_strdup(device_name);
1804                 _bt_common_event_cb(BLUETOOTH_EVENT_OBEX_SERVER_TRANSFER_AUTHORIZE,
1805                                 result, &auth_info,
1806                                 event_info->cb, event_info->user_data);
1807
1808                 g_free(auth_info.filename);
1809                 g_free(auth_info.address);
1810                 g_free(auth_info.name);
1811         } else if (strcasecmp(signal_name, BT_CONNECTION_AUTHORIZED) == 0) {
1812                 /* OSP only event */
1813                 const char *address = NULL;
1814                 const char *name = NULL;
1815                 bluetooth_device_address_t dev_address = { {0} };
1816
1817                 g_variant_get(parameters, "(i&s&s)", &result, &address, &name);
1818
1819                 /* Native server: Don't get this event */
1820                 ret_if(obex_server_id == BT_NATIVE_SERVER);
1821
1822                 _bt_convert_addr_string_to_type(dev_address.addr,
1823                                                 address);
1824
1825                 _bt_common_event_cb(BLUETOOTH_EVENT_OBEX_SERVER_CONNECTION_AUTHORIZE,
1826                                 result, &dev_address,
1827                                 event_info->cb, event_info->user_data);
1828         } else if (strcasecmp(signal_name, BT_TRANSFER_CONNECTED) == 0) {
1829                 bt_obex_server_connection_info_t conn_info = {0, };
1830                 char *address = NULL;
1831                 char *name = NULL;
1832                 int transfer_id = -1;
1833                 g_variant_get(parameters, "(i&s&si)", &result,
1834                                 &address, &name, &transfer_id);
1835
1836                 conn_info.address = g_strdup(address);
1837                 conn_info.device_name = g_strdup(name);
1838                 conn_info.transfer_id = transfer_id;
1839
1840                 _bt_common_event_cb(BLUETOOTH_EVENT_OBEX_SERVER_TRANSFER_CONNECTED,
1841                                         result, &conn_info, event_info->cb,
1842                                         event_info->user_data);
1843
1844                 g_free(conn_info.address);
1845                 g_free(conn_info.device_name);
1846         } else if (strcasecmp(signal_name, BT_TRANSFER_DISCONNECTED) == 0) {
1847                 bt_obex_server_transfer_info_t transfer_info = {0, };
1848                 char *address = NULL;
1849                 int transfer_id = -1;
1850                 g_variant_get(parameters, "(i&si)", &result, &address, &transfer_id);
1851                 DBG_SECURE("address: %s, transfer_id: %d", address, transfer_id);
1852
1853                 transfer_info.address = g_strdup(address);
1854                 transfer_info.transfer_id = transfer_id;
1855
1856                 _bt_common_event_cb(BLUETOOTH_EVENT_OBEX_SERVER_TRANSFER_DISCONNECTED,
1857                                         result, &transfer_info, event_info->cb,
1858                                         event_info->user_data);
1859                 g_free(transfer_info.address);
1860         } else if (strcasecmp(signal_name, BT_TRANSFER_STARTED) == 0) {
1861                 const char *device_name = NULL;
1862                 const char *file_name = NULL;
1863                 const char *type = NULL;
1864                 const char *address = NULL;
1865                 GVariantIter *iter = NULL;
1866                 int i = 0;
1867                 guchar byte;
1868                 int transfer_id = 0;
1869                 int server_type = 0; /* bt_server_type_t */
1870                 guint64 size = 0;
1871                 bt_obex_server_transfer_info_t transfer_info;
1872
1873                 g_variant_get(parameters, "(i&s&s&s&stii(ay))", &result, &device_name,
1874                         &file_name, &type, &address, &size, &transfer_id, &server_type, &iter);
1875
1876                 /* Other server's event */
1877                 ret_if(obex_server_id != server_type &&
1878                         server_type != BT_FTP_SERVER);
1879
1880                 memset(&transfer_info, 0x00, sizeof(bt_obex_server_transfer_info_t));
1881
1882                 transfer_info.contact_auth_info = g_malloc0(sizeof(unsigned char) * 5);
1883
1884                 for (i = 0; i < 5 && g_variant_iter_loop(iter, "y", &byte); ++i)
1885                         transfer_info.contact_auth_info[i] = byte;
1886
1887                 transfer_info.device_name = g_strdup(device_name);
1888                 transfer_info.filename = g_strdup(file_name);
1889                 transfer_info.type = g_strdup(type);
1890                 transfer_info.address = g_strdup(address);
1891                 transfer_info.file_size = size;
1892                 transfer_info.transfer_id = transfer_id;
1893                 transfer_info.server_type = (server_type == BT_FTP_SERVER) ?
1894                                                 FTP_SERVER : OPP_SERVER;
1895
1896                 _bt_common_event_cb(BLUETOOTH_EVENT_OBEX_SERVER_TRANSFER_STARTED,
1897                                 result, &transfer_info,
1898                                 event_info->cb, event_info->user_data);
1899
1900                 g_free(transfer_info.filename);
1901                 g_free(transfer_info.type);
1902                 g_free(transfer_info.device_name);
1903                 g_free(transfer_info.address);
1904                 g_free(transfer_info.contact_auth_info);
1905                 g_variant_iter_free(iter);
1906         } else if (strcasecmp(signal_name, BT_TRANSFER_PROGRESS) == 0) {
1907                 const char *file_name = NULL;
1908                 const char *type = NULL;
1909                 const char *device_name = NULL;
1910                 const char *address = NULL;
1911                 int transfer_id = 0;
1912                 int progress = 0;
1913                 int server_type = 0; /* bt_server_type_t */
1914                 guint64 size = 0;
1915                 bt_obex_server_transfer_info_t transfer_info;
1916
1917                 g_variant_get(parameters, "(i&s&s&s&stiii)", &result, &file_name,
1918                                                 &type, &device_name, &address, &size, &transfer_id,
1919                                                 &progress, &server_type);
1920
1921                 /* Other server's event */
1922                 ret_if(obex_server_id != server_type &&
1923                         server_type != BT_FTP_SERVER);
1924
1925                 memset(&transfer_info, 0x00, sizeof(bt_obex_server_transfer_info_t));
1926
1927                 transfer_info.filename = g_strdup(file_name);
1928                 transfer_info.type = g_strdup(type);
1929                 transfer_info.device_name = g_strdup(device_name);
1930                 transfer_info.address = g_strdup(address);
1931                 transfer_info.file_size = size;
1932                 transfer_info.transfer_id = transfer_id;
1933                 transfer_info.percentage = progress;
1934                 transfer_info.server_type = (server_type == BT_FTP_SERVER) ?
1935                                                 FTP_SERVER : OPP_SERVER;
1936
1937                 _bt_common_event_cb(BLUETOOTH_EVENT_OBEX_SERVER_TRANSFER_PROGRESS,
1938                                 result, &transfer_info,
1939                                 event_info->cb, event_info->user_data);
1940
1941                 g_free(transfer_info.filename);
1942                 g_free(transfer_info.device_name);
1943                 g_free(transfer_info.address);
1944                 g_free(transfer_info.type);
1945         } else if (strcasecmp(signal_name, BT_TRANSFER_COMPLETED) == 0) {
1946                 const char *file_name = NULL;
1947                 const char *device_name = NULL;
1948                 const char *address = NULL;
1949                 const char *type = NULL;
1950                 const char *file_path;
1951                 int transfer_id = 0;
1952                 int server_type = 0; /* bt_server_type_t */
1953                 guint64 size = 0;
1954                 bt_obex_server_transfer_info_t transfer_info;
1955
1956                 g_variant_get(parameters, "(i&s&s&s&s&stii)", &result, &file_name,
1957                                         &type, &device_name, &file_path, &address, &size,
1958                                         &transfer_id, &server_type);
1959
1960                 /* Other server's event */
1961                 ret_if(obex_server_id != server_type &&
1962                         server_type != BT_FTP_SERVER);
1963
1964                 memset(&transfer_info, 0x00, sizeof(bt_obex_server_transfer_info_t));
1965
1966                 transfer_info.filename = g_strdup(file_name);
1967                 transfer_info.type = g_strdup(type);
1968                 transfer_info.device_name = g_strdup(device_name);
1969                 transfer_info.file_path = g_strdup(file_path);
1970                 transfer_info.address = g_strdup(address);
1971                 transfer_info.file_size = size;
1972                 transfer_info.transfer_id = transfer_id;
1973                 transfer_info.server_type = (server_type == BT_FTP_SERVER) ?
1974                                                 FTP_SERVER : OPP_SERVER;
1975
1976                 _bt_common_event_cb(BLUETOOTH_EVENT_OBEX_SERVER_TRANSFER_COMPLETED,
1977                                 result, &transfer_info,
1978                                 event_info->cb, event_info->user_data);
1979
1980                 g_free(transfer_info.filename);
1981                 g_free(transfer_info.type);
1982                 g_free(transfer_info.device_name);
1983                 g_free(transfer_info.address);
1984                 g_free(transfer_info.file_path);
1985         }
1986 }
1987
1988 void __bt_pbap_client_event_filter(GDBusConnection *connection,
1989                                                  const gchar *sender_name,
1990                                                  const gchar *object_path,
1991                                                  const gchar *interface_name,
1992                                                  const gchar *signal_name,
1993                                                  GVariant *parameters,
1994                                                  gpointer user_data)
1995 {
1996         bt_event_info_t *event_info;
1997         int result = BLUETOOTH_ERROR_NONE;
1998         event_info = (bt_event_info_t *)user_data;
1999
2000         ret_if(event_info == NULL);
2001
2002         if (strcasecmp(object_path, BT_PBAP_CLIENT_PATH) != 0)
2003                 return;
2004
2005         if (strcasecmp(interface_name, BT_EVENT_SERVICE) != 0)
2006                 return;
2007
2008         ret_if(signal_name == NULL);
2009
2010         BT_DBG("Type: %s", g_variant_get_type_string(parameters));
2011
2012         if (strcasecmp(signal_name, BT_PBAP_CONNECTED) == 0) {
2013                 bt_pbap_connected_t connected = { { { 0 }, }, };
2014                 char *address = NULL;
2015
2016                 g_variant_get(parameters, "(i&s)", &result, &address);
2017                 BT_DBG("address: %s", address);
2018
2019                 _bt_convert_addr_string_to_type(connected.btaddr.addr,
2020                                                 address);
2021                 if (result == 0)
2022                         connected.connected = 1;
2023                 else
2024                         connected.connected = 0;
2025
2026                 _bt_common_event_cb(BLUETOOTH_PBAP_CONNECTED,
2027                                 result, &connected,
2028                                 event_info->cb, event_info->user_data);
2029         } else if (strcasecmp(signal_name, BT_PBAP_DISCONNECTED) == 0) {
2030                 bt_pbap_connected_t disconnected = { { { 0 }, }, };
2031                 char *address = NULL;
2032
2033                 g_variant_get(parameters, "(i&s)", &result, &address);
2034                 BT_DBG("address: %s", address);
2035
2036                 _bt_convert_addr_string_to_type(disconnected.btaddr.addr,
2037                                                 address);
2038                 disconnected.connected = 0;
2039
2040                 _bt_common_event_cb(BLUETOOTH_PBAP_CONNECTED,
2041                                 result, &disconnected,
2042                                 event_info->cb, event_info->user_data);
2043         } else if (strcasecmp(signal_name, BT_PBAP_PHONEBOOK_SIZE) == 0) {
2044                 bt_pbap_phonebook_size_t pb_size = { { { 0 }, }, };
2045                 char *address = NULL;
2046                 int size = 0;
2047
2048                 g_variant_get(parameters, "(i&si)", &result, &address, &size);
2049
2050                 BT_DBG("address: %s, size: %d", address, size);
2051
2052                 _bt_convert_addr_string_to_type(pb_size.btaddr.addr,
2053                                                 address);
2054                 pb_size.size = size;
2055
2056                 _bt_common_event_cb(BLUETOOTH_PBAP_PHONEBOOK_SIZE,
2057                                 result, &pb_size,
2058                                 event_info->cb, event_info->user_data);
2059         } else if (strcasecmp(signal_name, BT_PBAP_PHONEBOOK_PULL) == 0) {
2060                 bt_pbap_phonebook_pull_t pb_pull = { { { 0 } }, };
2061                 char *address = NULL;
2062                 char *vcf_file = NULL;
2063                 int success = -1;
2064
2065                 g_variant_get(parameters, "(i&s&si)", &result, &address, &vcf_file, &success);
2066
2067                 BT_DBG("address: %s, vcf_file: %s, success: %d",
2068                                                 address, vcf_file, success);
2069
2070                 _bt_convert_addr_string_to_type(pb_pull.btaddr.addr,
2071                                                 address);
2072                 pb_pull.vcf_file = vcf_file;
2073                 pb_pull.success = success;
2074                 _bt_common_event_cb(BLUETOOTH_PBAP_PHONEBOOK_PULL,
2075                                 result, &pb_pull,
2076                                 event_info->cb, event_info->user_data);
2077         } else if (strcasecmp(signal_name, BT_PBAP_VCARD_LIST) == 0) {
2078                 bt_pbap_vcard_list_t vc_list = { { { 0 } }, };
2079                 char *address = NULL;
2080                 gsize count = 0;
2081                 gchar **list = NULL;
2082                 GVariant *string_var;
2083                 int success = -1;
2084                 int i = 0;
2085
2086                 g_variant_get(parameters, "(i&sv)", &result, &address, &string_var);
2087
2088                 list = (gchar **)g_variant_get_strv(string_var, &count);
2089
2090                 success = !result;
2091
2092                 for(i = 0; i < count; i++)
2093                         BT_DBG("%s", list[i]);
2094
2095                 BT_DBG("address: %s, result: %d, count: %d, success: %d",
2096                                         address, result, count, success);
2097
2098                 _bt_convert_addr_string_to_type(vc_list.btaddr.addr,
2099                                                 address);
2100                 vc_list.vcards = list;
2101                 vc_list.length = count;
2102                 vc_list.success = success;
2103                 _bt_common_event_cb(BLUETOOTH_PBAP_VCARD_LIST,
2104                                 result, &vc_list,
2105                                 event_info->cb, event_info->user_data);
2106
2107                 g_variant_unref(string_var);
2108                 //free lists
2109         } else if (strcasecmp(signal_name, BT_PBAP_VCARD_PULL) == 0) {
2110                 bt_pbap_vcard_pull_t vc_pull = { { { 0 } }, };
2111                 char *address = NULL;
2112                 char *vcf_file = NULL;
2113                 int success = -1;
2114
2115                 g_variant_get(parameters, "(i&s&si)",
2116                                         &result, &address, &vcf_file, &success);
2117
2118                 BT_DBG("address: %s, vcf_file: %s, success: %d",
2119                                                 address, vcf_file, success);
2120
2121                 _bt_convert_addr_string_to_type(vc_pull.btaddr.addr, address);
2122                 vc_pull.vcf_file = vcf_file;
2123                 vc_pull.success = success;
2124                 _bt_common_event_cb(BLUETOOTH_PBAP_VCARD_PULL,
2125                                 result, &vc_pull,
2126                                 event_info->cb, event_info->user_data);
2127         } else if (strcasecmp(signal_name, BT_PBAP_SEARCH_PHONEBOOK) == 0) {
2128                 bt_pbap_phonebook_search_list_t vc_list = { { { 0 } }, };
2129                 char *address = NULL;
2130                 gsize count = 0;
2131                 gchar **list = NULL;
2132                 GVariant *string_var;
2133                 int success = -1;
2134                 int i = 0;
2135
2136                 g_variant_get(parameters, "(i&s@as)", &result, &address, &string_var);
2137
2138                 list = (gchar **)g_variant_get_strv(string_var, &count);
2139                 success = !result;
2140                 for(i = 0; i < count; i++)
2141                         BT_DBG("%s", list[i]);
2142
2143                 BT_DBG("address: %s success: %d", address, success);
2144
2145                 _bt_convert_addr_string_to_type(vc_list.btaddr.addr, address);
2146                 vc_list.vcards = list;
2147                 vc_list.length = count;
2148                 vc_list.success = success;
2149                 _bt_common_event_cb(BLUETOOTH_PBAP_PHONEBOOK_SEARCH,
2150                                 result, &vc_list,
2151                                 event_info->cb, event_info->user_data);
2152
2153                 g_variant_unref(string_var);
2154                 //free lists
2155         }
2156 }
2157
2158 void __bt_rfcomm_client_event_filter(GDBusConnection *connection,
2159                                                  const gchar *sender_name,
2160                                                  const gchar *object_path,
2161                                                  const gchar *interface_name,
2162                                                  const gchar *signal_name,
2163                                                  GVariant *parameters,
2164                                                  gpointer user_data)
2165 {
2166         bt_event_info_t *event_info;
2167         int result = BLUETOOTH_ERROR_NONE;
2168         event_info = (bt_event_info_t *)user_data;
2169         ret_if(event_info == NULL);
2170
2171         if (strcasecmp(object_path, BT_RFCOMM_CLIENT_PATH) != 0)
2172                 return;
2173         if (strcasecmp(interface_name, BT_EVENT_SERVICE) != 0)
2174                 return;
2175
2176         ret_if(signal_name == NULL);
2177
2178         if (strcasecmp(signal_name, BT_RFCOMM_CONNECTED) == 0) {
2179                 const char *address = NULL;
2180                 const char *uuid = NULL;
2181                 int socket_fd = 0;
2182                 bluetooth_rfcomm_connection_t conn_info;
2183
2184                 g_variant_get(parameters, "(i&s&sn)", &result, &address,
2185                                                         &uuid, &socket_fd);
2186
2187                 memset(&conn_info, 0x00, sizeof(bluetooth_rfcomm_connection_t));
2188                 conn_info.device_role = RFCOMM_ROLE_CLIENT;
2189                 g_strlcpy(conn_info.uuid, uuid, BLUETOOTH_UUID_STRING_MAX);
2190                 conn_info.socket_fd = socket_fd;
2191                 _bt_convert_addr_string_to_type(conn_info.device_addr.addr,
2192                                                 address);
2193
2194                 _bt_common_event_cb(BLUETOOTH_EVENT_RFCOMM_CONNECTED,
2195                                 result, &conn_info,
2196                                 event_info->cb, event_info->user_data);
2197         } else if (strcasecmp(signal_name, BT_RFCOMM_DISCONNECTED) == 0) {
2198                 const char *address = NULL;
2199                 const char *uuid = NULL;
2200                 int socket_fd = 0;
2201                 bluetooth_rfcomm_disconnection_t disconn_info;
2202
2203                 g_variant_get(parameters, "(i&s&sn)", &result, &address,
2204                                                                 &uuid, &socket_fd);
2205
2206                 memset(&disconn_info, 0x00, sizeof(bluetooth_rfcomm_disconnection_t));
2207                 disconn_info.device_role = RFCOMM_ROLE_CLIENT;
2208                 g_strlcpy(disconn_info.uuid, uuid, BLUETOOTH_UUID_STRING_MAX);
2209                 disconn_info.socket_fd = socket_fd;
2210                 _bt_convert_addr_string_to_type(disconn_info.device_addr.addr,
2211                                                 address);
2212
2213                 _bt_common_event_cb(BLUETOOTH_EVENT_RFCOMM_DISCONNECTED,
2214                                 result, &disconn_info,
2215                                 event_info->cb, event_info->user_data);
2216         } else if (strcasecmp(signal_name, BT_RFCOMM_DATA_RECEIVED) == 0) {
2217                 char *buffer;
2218                 int buffer_len = 0;
2219                 int socket_fd = 0;
2220                 bluetooth_rfcomm_received_data_t data_r;
2221                 GVariant *byte_var;
2222
2223                 g_variant_get(parameters, "(in@ay)", &result, &socket_fd,
2224                                                                 &byte_var);
2225
2226                 buffer_len = g_variant_get_size(byte_var);
2227                 buffer = (char *) g_variant_get_data(byte_var);
2228
2229                 data_r.socket_fd = socket_fd;
2230                 data_r.buffer_size = buffer_len;
2231                 data_r.buffer = buffer;
2232
2233                 _bt_common_event_cb(BLUETOOTH_EVENT_RFCOMM_DATA_RECEIVED,
2234                                 result, &data_r,
2235                                 event_info->cb, event_info->user_data);
2236                 g_variant_unref(byte_var);
2237         }
2238 }
2239
2240 void __bt_rfcomm_server_event_filter(GDBusConnection *connection,
2241                                                  const gchar *sender_name,
2242                                                  const gchar *object_path,
2243                                                  const gchar *interface_name,
2244                                                  const gchar *signal_name,
2245                                                  GVariant *parameters,
2246                                                  gpointer user_data)
2247 {
2248         bt_event_info_t *event_info;
2249         int result = BLUETOOTH_ERROR_NONE;
2250         event_info = (bt_event_info_t *)user_data;
2251         ret_if(event_info == NULL);
2252
2253         if (strcasecmp(object_path, BT_RFCOMM_SERVER_PATH) != 0)
2254                 return;
2255         if (strcasecmp(interface_name, BT_EVENT_SERVICE) != 0)
2256                 return;
2257
2258         ret_if(signal_name == NULL);
2259
2260         if (strcasecmp(signal_name, BT_RFCOMM_CONNECTED) == 0) {
2261                 const char *address = NULL;
2262                 const char *uuid = NULL;
2263                 int socket_fd = 0;
2264                 bluetooth_rfcomm_connection_t conn_info;
2265
2266                 g_variant_get(parameters, "(i&s&sn)", &result, &address,
2267                                                         &uuid, &socket_fd);
2268
2269                 memset(&conn_info, 0x00, sizeof(bluetooth_rfcomm_connection_t));
2270                 conn_info.device_role = RFCOMM_ROLE_SERVER;
2271                 g_strlcpy(conn_info.uuid, uuid, BLUETOOTH_UUID_STRING_MAX);
2272                 conn_info.socket_fd = socket_fd;
2273                 _bt_convert_addr_string_to_type(conn_info.device_addr.addr,
2274                                                 address);
2275
2276                 _bt_common_event_cb(BLUETOOTH_EVENT_RFCOMM_CONNECTED,
2277                                 result, &conn_info,
2278                                 event_info->cb, event_info->user_data);
2279         } else if (strcasecmp(signal_name, BT_RFCOMM_DISCONNECTED) == 0) {
2280                 const char *address = NULL;
2281                 const char *uuid = NULL;
2282                 int socket_fd = 0;
2283                 bluetooth_rfcomm_disconnection_t disconn_info;
2284
2285                 g_variant_get(parameters, "(i&s&sn)", &result, &address,
2286                                                                 &uuid, &socket_fd);
2287
2288                 memset(&disconn_info, 0x00, sizeof(bluetooth_rfcomm_disconnection_t));
2289                 disconn_info.device_role = RFCOMM_ROLE_SERVER;
2290                 g_strlcpy(disconn_info.uuid, uuid, BLUETOOTH_UUID_STRING_MAX);
2291                 disconn_info.socket_fd = socket_fd;
2292                 _bt_convert_addr_string_to_type(disconn_info.device_addr.addr,
2293                                                 address);
2294
2295                 _bt_common_event_cb(BLUETOOTH_EVENT_RFCOMM_DISCONNECTED,
2296                                 result, &disconn_info,
2297                                 event_info->cb, event_info->user_data);
2298         } else if (strcasecmp(signal_name, BT_CONNECTION_AUTHORIZED) == 0) {
2299                 /* OSP only event */
2300                 bluetooth_rfcomm_connection_request_t req_ind;
2301                 char *address = NULL;
2302                 char *uuid = NULL;
2303                 char *name = NULL;
2304                 char *path = NULL;
2305                 int socket_fd = 0;
2306
2307                 g_variant_get(parameters, "(i&s&s&s&sn)", &result, &address,
2308                                                 &uuid, &name, &path, &socket_fd);
2309
2310                 if (_check_uuid_path(path, uuid) == FALSE)
2311                         return;
2312
2313                 memset(&req_ind, 0x00, sizeof(bluetooth_rfcomm_connection_request_t));
2314                 _bt_convert_addr_string_to_type(req_ind.device_addr.addr,
2315                                                 address);
2316
2317                 req_ind.socket_fd = socket_fd;
2318
2319                 _bt_common_event_cb(BLUETOOTH_EVENT_RFCOMM_AUTHORIZE,
2320                                 result, &req_ind,
2321                                 event_info->cb, event_info->user_data);
2322         } else if (strcasecmp(signal_name, BT_RFCOMM_SERVER_REMOVED) == 0) {
2323                 /* OSP only event */
2324                 int socket_fd = 0;
2325
2326                 g_variant_get(parameters, "(in)", &result, &socket_fd);
2327
2328                 ret_if(__bt_is_server_exist(socket_fd) == FALSE);
2329
2330                 _bt_remove_server(socket_fd);
2331         } else if (strcasecmp(signal_name, BT_RFCOMM_DATA_RECEIVED) == 0) {
2332                 char *buffer = NULL;
2333                 int buffer_len = 0;
2334                 int socket_fd = 0;
2335                 bluetooth_rfcomm_received_data_t data_r;
2336                 GVariant *byte_var;
2337
2338                 g_variant_get(parameters, "(in@ay)", &result,
2339                                                 &socket_fd, &byte_var);
2340
2341                 buffer_len = g_variant_get_size(byte_var);
2342                 buffer = (char *) g_variant_get_data(byte_var);
2343
2344                 data_r.socket_fd = socket_fd;
2345                 data_r.buffer_size = buffer_len;
2346                 data_r.buffer = buffer;
2347
2348                 _bt_common_event_cb(BLUETOOTH_EVENT_RFCOMM_DATA_RECEIVED,
2349                                 result, &data_r,
2350                                 event_info->cb, event_info->user_data);
2351                 g_variant_unref(byte_var);
2352         }
2353 }
2354
2355 void __bt_hf_agent_event_filter(GDBusConnection *connection,
2356                                                  const gchar *sender_name,
2357                                                  const gchar *object_path,
2358                                                  const gchar *interface_name,
2359                                                  const gchar *signal_name,
2360                                                  GVariant *parameters,
2361                                                  gpointer user_data)
2362 {
2363         BT_DBG("+\n");
2364
2365         bt_event_info_t *event_info;
2366         int result = BLUETOOTH_ERROR_NONE;
2367         event_info = (bt_event_info_t *)user_data;
2368         ret_if(event_info == NULL);
2369
2370         BT_DBG("+\n");
2371         if (strcasecmp(object_path, BT_HF_AGENT_PATH) != 0)
2372                 return;
2373         if (strcasecmp(interface_name, BT_HF_SERVICE_INTERFACE) != 0)
2374                 return;
2375
2376         ret_if(signal_name == NULL);
2377
2378         BT_DBG("%s", signal_name);
2379         if (strcasecmp(signal_name, "Connected") == 0) {
2380                 char *address = NULL;
2381
2382                 g_variant_get(parameters, "(s)", &address);
2383                 _bt_hf_event_cb(BLUETOOTH_EVENT_HF_CONNECTED,
2384                                 result, address,
2385                                 event_info->cb, event_info->user_data);
2386         } else if (strcasecmp(signal_name, "Disconnected") == 0) {
2387                 char *address = NULL;
2388
2389                 g_variant_get(parameters, "(s)", &address);
2390                 _bt_hf_event_cb(BLUETOOTH_EVENT_HF_DISCONNECTED,
2391                                 result, address,
2392                                 event_info->cb, event_info->user_data);
2393         } else if (strcasecmp(signal_name, "AudioConnected") == 0) {
2394                 _bt_hf_event_cb(BLUETOOTH_EVENT_HF_AUDIO_CONNECTED,
2395                                 result, NULL,
2396                                 event_info->cb, event_info->user_data);
2397         } else if (strcasecmp(signal_name, "AudioDisconnected") == 0) {
2398                 _bt_hf_event_cb(BLUETOOTH_EVENT_HF_AUDIO_DISCONNECTED,
2399                                 result, NULL,
2400                                 event_info->cb, event_info->user_data);
2401         } else if (strcasecmp(signal_name, "Ring") == 0) {
2402                 char *phoneno = NULL;
2403
2404                 g_variant_get(parameters, "(&s)", &phoneno);
2405
2406                 _bt_hf_event_cb(BLUETOOTH_EVENT_HF_RING_INDICATOR,
2407                                 result, phoneno,
2408                                 event_info->cb, event_info->user_data);
2409         } else if (strcasecmp(signal_name, "CallWaiting") == 0) {
2410                 char *phoneno = NULL;
2411
2412                 g_variant_get(parameters, "(&s)", &phoneno);
2413
2414                 _bt_hf_event_cb(BLUETOOTH_EVENT_HF_CALL_WAITING,
2415                                 result, phoneno,
2416                                 event_info->cb, event_info->user_data);
2417         }  else if (strcasecmp(signal_name, "CallTerminated") == 0) {
2418                 _bt_hf_event_cb(BLUETOOTH_EVENT_HF_CALL_TERMINATED,
2419                                 result, NULL,
2420                                 event_info->cb, event_info->user_data);
2421         }  else if (strcasecmp(signal_name, "FailedToDial") == 0) {
2422                 _bt_hf_event_cb(BLUETOOTH_EVENT_HF_CALL_FAILED_TO_DIAL,
2423                                 result, NULL,
2424                                 event_info->cb, event_info->user_data);
2425         } else if (strcasecmp(signal_name, "CallIdle") == 0) {
2426                 _bt_hf_event_cb(BLUETOOTH_EVENT_HF_CALL_IDLE,
2427                                 result, NULL,
2428                                 event_info->cb, event_info->user_data);
2429         } else if (strcasecmp(signal_name, "CallSetupIncoming") == 0) {
2430                 _bt_hf_event_cb(BLUETOOTH_EVENT_HF_CALLSETUP_INCOMING,
2431                                 result, NULL,
2432                                 event_info->cb, event_info->user_data);
2433         } else if (strcasecmp(signal_name, "CallSetupDialing") == 0) {
2434                 _bt_hf_event_cb(BLUETOOTH_EVENT_HF_CALLSETUP_DIALING,
2435                                 result, NULL,
2436                                 event_info->cb, event_info->user_data);
2437         } else if (strcasecmp(signal_name, "CallSetupAlerting") == 0) {
2438                 _bt_hf_event_cb(BLUETOOTH_EVENT_HF_CALLSETUP_ALERTING,
2439                                 result, NULL,
2440                                 event_info->cb, event_info->user_data);
2441         } else if (strcasecmp(signal_name, "CallStarted") == 0) {
2442                 _bt_hf_event_cb(BLUETOOTH_EVENT_HF_CALL_STARTED,
2443                                 result, NULL,
2444                                 event_info->cb, event_info->user_data);
2445         } else if (strcasecmp(signal_name, "CallEnded") == 0) {
2446                 _bt_hf_event_cb(BLUETOOTH_EVENT_HF_CALL_ENDED,
2447                                 result, NULL,
2448                                 event_info->cb, event_info->user_data);
2449         }  else if (strcasecmp(signal_name, "NoCallsHeld") == 0) {
2450                 _bt_hf_event_cb(BLUETOOTH_EVENT_HF_CALL_UNHOLD,
2451                                 result, NULL,
2452                                 event_info->cb, event_info->user_data);
2453         } else if (strcasecmp(signal_name, "CallsSwapped") == 0) {
2454                 _bt_hf_event_cb(BLUETOOTH_EVENT_HF_CALL_SWAPPED,
2455                                 result, NULL,
2456                                 event_info->cb, event_info->user_data);
2457         } else if (strcasecmp(signal_name, "CallOnHold") == 0) {
2458                 _bt_hf_event_cb(BLUETOOTH_EVENT_HF_CALL_ON_HOLD,
2459                                 result, NULL,
2460                                 event_info->cb, event_info->user_data);
2461         } else if (strcasecmp(signal_name, "CallStatusUpdate") == 0) {
2462                 int call_count;
2463                 GVariant *var_data = NULL;
2464                 char *number = NULL;
2465                 int idx, dir, status, mpart;
2466                 bt_hf_call_list_s *handle = NULL;
2467
2468                 g_variant_get(parameters, "(i@a(siiii))", &call_count,
2469                                                                 &var_data);
2470                 BT_DBG("call count : %d", call_count);
2471
2472                 if (var_data) {
2473                         GVariantIter *iter = NULL;
2474                         __bt_call_list_create(&handle);
2475
2476                         g_variant_get(var_data, "a(siiii)", &iter);
2477                         while (g_variant_iter_loop(iter, "(siiii)", &number,
2478                                                 &dir, &status, &mpart, &idx)) {
2479                                 BT_DBG("call number:%s, dir:%d, status : %d",
2480                                                         number, dir, status);
2481                                 BT_DBG("call mpart : %d, idx : %d", mpart, idx);
2482                                 __bt_call_list_add(handle, number, dir,
2483                                                         status, mpart, idx);
2484                         }
2485                         g_variant_iter_free(iter);
2486                         g_variant_unref(var_data);
2487                 }
2488
2489                 if (handle && (call_count == g_list_length(handle->list))) {
2490                         handle->count = call_count;
2491                         _bt_hf_event_cb(BLUETOOTH_EVENT_HF_CALL_STATUS,
2492                                         result, handle,
2493                                         event_info->cb, event_info->user_data);
2494                 } else {
2495                         BT_ERR(" Mismatch in call count : %d", call_count);
2496                 }
2497
2498                 __bt_call_list_destroy(handle);
2499         } else if (strcasecmp(signal_name, "VoiceRecognition") == 0) {
2500                 int status;
2501                 g_variant_get(parameters, "(i)", &status);
2502                 BT_DBG("status = [%d]\n", status);
2503                 if (status)
2504                         _bt_hf_event_cb(BLUETOOTH_EVENT_HF_VOICE_RECOGNITION_ENABLED,
2505                                         result, NULL,
2506                                         event_info->cb, event_info->user_data);
2507                 else
2508                         _bt_hf_event_cb(BLUETOOTH_EVENT_HF_VOICE_RECOGNITION_DISABLED,
2509                                         result, NULL,
2510                                         event_info->cb, event_info->user_data);
2511         } else if (strcasecmp(signal_name, "VolumeSpeaker") == 0) {
2512                 int value;
2513                 g_variant_get(parameters, "(i)", &value);
2514                 BT_DBG("Value = [%d]\n", value);
2515                         _bt_hf_event_cb(BLUETOOTH_EVENT_HF_VOLUME_SPEAKER,
2516                                         result, &value,
2517                                         event_info->cb, event_info->user_data);
2518         } else if (strcasecmp(signal_name, "SamsungXSAT") == 0) {
2519                 int value = 0;
2520                 char *msg = NULL;
2521                 bluetooth_vendor_dep_at_cmd_t cmd;
2522                 g_variant_get(parameters, "(i&s)", &value, &msg);
2523                 BT_DBG("Value = [%d], message = %s\n", value, msg);
2524                 cmd.app_id =  value;
2525                 cmd.message = msg;
2526                 _bt_hf_event_cb(BLUETOOTH_EVENT_HF_VENDOR_DEP_CMD,
2527                                 result, &cmd,
2528                                 event_info->cb, event_info->user_data);
2529         } else if (strcasecmp(signal_name, "PropertyChanged") == 0) {
2530                 GVariant *value;
2531                 gchar *property;
2532                 bluetooth_hf_ciev_device_event_t dev_event;
2533
2534                 g_variant_get(parameters, "(&sv)", &property, &value);
2535                 dev_event.value  = g_variant_get_uint16(value);
2536
2537                 BT_DBG("Property: %s , value: %d", property, dev_event.value);
2538                 g_variant_unref(value);
2539
2540                 if (strcasecmp(property, "BatteryCharge") == 0) {
2541                         dev_event.event = BLUETOOTH_HF_CIEV_BATTCHG;
2542                         _bt_hf_event_cb(BLUETOOTH_EVENT_HF_CIEV_DEVICE_STATUS_CHANGED,
2543                                         result, &dev_event,
2544                                         event_info->cb, event_info->user_data);
2545                 } else if       (strcasecmp(property, "SignalStrength") == 0) {
2546                         dev_event.event = BLUETOOTH_HF_CIEV_SIGNAL;
2547                         _bt_hf_event_cb(BLUETOOTH_EVENT_HF_CIEV_DEVICE_STATUS_CHANGED,
2548                                         result, &dev_event,
2549                                         event_info->cb, event_info->user_data);
2550                 } else if       (strcasecmp(property, "RegistrationStatus") == 0) {
2551                         dev_event.event = BLUETOOTH_HF_CIEV_SERVICE;
2552                         _bt_hf_event_cb(BLUETOOTH_EVENT_HF_CIEV_DEVICE_STATUS_CHANGED,
2553                                         result, &dev_event,
2554                                         event_info->cb, event_info->user_data);
2555                 }
2556         }
2557         BT_DBG("-\n");
2558 }
2559
2560 static void __bt_remove_all_events(void)
2561 {
2562         bt_event_info_t *info;
2563
2564         while ((info = g_slist_nth_data(event_list, 0)) != NULL) {
2565                 _bt_unregister_event(info->event_type);
2566         }
2567
2568         if (event_list) {
2569                 g_slist_free(event_list);
2570                 event_list = NULL;
2571         }
2572 }
2573
2574 static gboolean __bt_event_is_registered(int event_type)
2575 {
2576         GSList *l;
2577         bt_event_info_t *info;
2578
2579         for (l = event_list; l != NULL; l = g_slist_next(l)) {
2580                 info = l->data;
2581                 if (info == NULL)
2582                         continue;
2583
2584                 if (info->event_type == event_type)
2585                         return TRUE;
2586         }
2587
2588         return FALSE;
2589 }
2590
2591 bt_event_info_t *_bt_event_get_cb_data(int event_type)
2592 {
2593         GSList *l;
2594         bt_event_info_t *info;
2595
2596         for (l = event_list; l != NULL; l = g_slist_next(l)) {
2597                 info = l->data;
2598                 if (info == NULL)
2599                         continue;
2600
2601                 if (info->event_type == event_type)
2602                         return info;
2603         }
2604
2605         return NULL;
2606 }
2607
2608 void _bt_add_server(int server_fd)
2609 {
2610         bt_server_info_t *info;
2611
2612         info = g_new0(bt_server_info_t, 1);
2613         info->server_fd = server_fd;
2614
2615         server_list = g_slist_append(server_list, info);
2616 }
2617
2618 void _bt_remove_server(int server_fd)
2619 {
2620         GSList *l;
2621         bt_server_info_t *info;
2622
2623         for (l = server_list; l != NULL; l = g_slist_next(l)) {
2624                 info = l->data;
2625                 if (info == NULL)
2626                         continue;
2627
2628                 if (info->server_fd == server_fd) {
2629                         server_list = g_slist_remove(server_list, (void *)info);
2630                 }
2631
2632                 g_free(info);
2633         }
2634 }
2635
2636 void _bt_set_obex_server_id(int server_type)
2637 {
2638         obex_server_id = server_type;
2639 }
2640
2641 int _bt_get_obex_server_id(void)
2642 {
2643         return obex_server_id;
2644 }
2645
2646 int _bt_init_event_handler(void)
2647 {
2648         if (is_initialized == TRUE) {
2649                 BT_ERR("Connection already exist");
2650                 return BLUETOOTH_ERROR_ALREADY_INITIALIZED;
2651         }
2652
2653         __bt_remove_all_events();
2654
2655         is_initialized = TRUE;
2656
2657         return BLUETOOTH_ERROR_NONE;
2658 }
2659
2660 int _bt_deinit_event_handler(void)
2661 {
2662         if (is_initialized == FALSE) {
2663                 BT_ERR("Connection dose not exist");
2664                 return BLUETOOTH_ERROR_INTERNAL;
2665         }
2666
2667         __bt_remove_all_events();
2668
2669         if (disable_timer_id > 0) {
2670                 g_source_remove(disable_timer_id);
2671                 disable_timer_id = 0;
2672         }
2673
2674         is_initialized = FALSE;
2675
2676         return BLUETOOTH_ERROR_NONE;
2677 }
2678
2679 static void __bt_event_data_free(void *data)
2680 {
2681         bt_event_info_t *cb_data = data;
2682
2683         ret_if(cb_data == NULL);
2684
2685         g_free(cb_data);
2686 }
2687
2688 int _bt_register_event(int event_type, void *event_cb, void *user_data)
2689 {
2690         GDBusConnection *connection_type;
2691         GDBusSignalCallback event_func;
2692         bt_event_info_t *cb_data;
2693         const char *path;
2694         const char *interface = BT_EVENT_SERVICE;
2695
2696         if (is_initialized == FALSE)
2697                 _bt_init_event_handler();
2698
2699         if (__bt_event_is_registered(event_type) == TRUE) {
2700                 BT_ERR("The event is already registed");
2701                 return BLUETOOTH_ERROR_ALREADY_INITIALIZED;
2702         }
2703
2704         switch (event_type) {
2705         case BT_ADAPTER_EVENT:
2706                 event_func = __bt_adapter_event_filter;
2707                 path = BT_ADAPTER_PATH;
2708                 break;
2709         case BT_LE_ADAPTER_EVENT:
2710                 event_func = __bt_adapter_le_event_filter;
2711                 path = BT_LE_ADAPTER_PATH;
2712                 break;
2713         case BT_DEVICE_EVENT:
2714                 event_func = __bt_device_event_filter;
2715                 path = BT_DEVICE_PATH;
2716                 break;
2717         case BT_HID_EVENT:
2718                 event_func = __bt_hid_event_filter;
2719                 path = BT_HID_PATH;
2720                 break;
2721         case BT_HEADSET_EVENT:
2722                 event_func = __bt_headset_event_filter;
2723                 path = BT_HEADSET_PATH;
2724                 break;
2725         case BT_NETWORK_EVENT:
2726                 event_func = __bt_network_event_filter;
2727                 path = BT_NETWORK_PATH;
2728                 break;
2729         case BT_AVRCP_EVENT:
2730                 event_func = __bt_avrcp_event_filter;
2731                 path = BT_AVRCP_PATH;
2732                 break;
2733         case BT_AVRCP_CONTROL_EVENT:
2734                 event_func = __bt_avrcp_control_event_filter;
2735                 path = BT_AVRCP_CONTROL_PATH;
2736                 break;
2737         case BT_OPP_CLIENT_EVENT:
2738                 event_func = __bt_opp_client_event_filter;
2739                 path = BT_OPP_CLIENT_PATH;
2740                 break;
2741         case BT_OPP_SERVER_EVENT:
2742                 event_func = __bt_opp_server_event_filter;
2743                 path = BT_OPP_SERVER_PATH;
2744                 break;
2745         case BT_PBAP_CLIENT_EVENT:
2746                 event_func = __bt_pbap_client_event_filter;
2747                 path = BT_PBAP_CLIENT_PATH;
2748                 break;
2749         case BT_RFCOMM_CLIENT_EVENT:
2750                 event_func = __bt_rfcomm_client_event_filter;
2751                 path = BT_RFCOMM_CLIENT_PATH;
2752                 break;
2753         case BT_RFCOMM_SERVER_EVENT:
2754                 event_func = __bt_rfcomm_server_event_filter;
2755                 path = BT_RFCOMM_SERVER_PATH;
2756                 break;
2757         case BT_HF_AGENT_EVENT:
2758                 BT_DBG("BT_HF_AGENT_EVENT\n");
2759                 event_func = __bt_hf_agent_event_filter;
2760                 path = BT_HF_AGENT_PATH;
2761                 interface = BT_HF_SERVICE_INTERFACE;
2762                 break;
2763         case BT_A2DP_SOURCE_EVENT:
2764                 BT_DBG("BT_A2DP_SOURCE_EVENT");
2765                 event_func = __bt_a2dp_source_event_filter;
2766                 path = BT_A2DP_SOURCE_PATH;
2767                 break;
2768         case BT_HID_DEVICE_EVENT:
2769                 BT_DBG("BT_HID_DEVICE_EVENT");
2770                 event_func = __bt_hid_device_event_filter;
2771                 path = BT_HID_DEVICE_PATH;
2772                 break;
2773 #ifdef GATT_NO_RELAY
2774         case BT_GATT_BLUEZ_EVENT:
2775                 BT_DBG("BT_GATT_BLUEZ_EVENT");
2776                 event_func = __bt_device_event_filter;
2777                 interface = BT_GATT_CHARACTERISTIC_INTERFACE;
2778                 path = NULL;
2779                 break;
2780 #endif
2781         default:
2782                 BT_ERR("Unknown event");
2783                 return BLUETOOTH_ERROR_INTERNAL;
2784         }
2785
2786         connection_type = _bt_gdbus_get_system_gconn();
2787         if (connection_type == NULL)
2788                 return BLUETOOTH_ERROR_INTERNAL;
2789
2790         cb_data = g_new0(bt_event_info_t, 1);
2791
2792         cb_data->event_type = event_type;
2793         cb_data->cb = event_cb;
2794         cb_data->user_data = user_data;
2795
2796         cb_data->id = g_dbus_connection_signal_subscribe(connection_type,
2797                                 NULL, interface, NULL, path, NULL, 0,
2798                                 event_func, cb_data, NULL);
2799
2800         event_list = g_slist_append(event_list, cb_data);
2801
2802         return BLUETOOTH_ERROR_NONE;
2803 }
2804
2805 int _bt_unregister_event(int event_type)
2806 {
2807         GDBusConnection *connection_type;
2808         bt_event_info_t *cb_data;
2809
2810         if (is_initialized == FALSE) {
2811                 BT_ERR("Event is not registered");
2812                 return BLUETOOTH_ERROR_NOT_INITIALIZED;
2813         }
2814
2815         if (__bt_event_is_registered(event_type) == FALSE) {
2816                 BT_ERR("Not registered event");
2817                 return BLUETOOTH_ERROR_INTERNAL;
2818         }
2819
2820         cb_data = _bt_event_get_cb_data(event_type);
2821
2822         if (cb_data == NULL) {
2823                 BT_ERR("No matched event data");
2824                 return BLUETOOTH_ERROR_INTERNAL;
2825         }
2826
2827         connection_type = _bt_gdbus_get_system_gconn();
2828
2829         event_list = g_slist_remove(event_list, (void *)cb_data);
2830
2831         retv_if(connection_type == NULL, BLUETOOTH_ERROR_INTERNAL);
2832
2833         g_dbus_connection_signal_unsubscribe(connection_type, cb_data->id);
2834
2835         __bt_event_data_free((void *)cb_data);
2836
2837         return BLUETOOTH_ERROR_NONE;
2838 }
2839
2840 static void __bt_name_owner_changed(GDBusConnection *connection,
2841                                                  const gchar *sender_name,
2842                                                  const gchar *object_path,
2843                                                  const gchar *interface_name,
2844                                                  const gchar *signal_name,
2845                                                  GVariant *parameters,
2846                                                  gpointer user_data)
2847 {
2848         const char *name = NULL;
2849         const char *old_owner = NULL;
2850         const char *new_owner = NULL;
2851         bt_event_info_t *event_info;
2852
2853         g_variant_get(parameters, "(&s&s&s)", &name, &old_owner, &new_owner);
2854
2855         if (g_strcmp0(name, BT_DBUS_NAME) == 0 &&
2856                         (new_owner != NULL && *new_owner == '\0')) {
2857                 BT_DBG("bt-service is terminated");
2858                 event_info = _bt_event_get_cb_data(BT_ADAPTER_EVENT);
2859                 if (event_info == NULL)
2860                         return;
2861
2862                 if (disable_timer_id > 0)
2863                         g_source_remove(disable_timer_id);
2864
2865                 disable_timer_id = g_timeout_add(BT_RELIABLE_DISABLE_TIME,
2866                                 (GSourceFunc)__bt_reliable_disable_cb,
2867                                 event_info);
2868         }
2869 }
2870
2871 void _bt_register_name_owner_changed(void)
2872 {
2873         GDBusConnection *connection_type;
2874
2875         connection_type = _bt_gdbus_get_system_gconn();
2876         if (connection_type == NULL) {
2877                 BT_ERR("Unable to get the bus");
2878                 return;
2879         }
2880         owner_sig_id = g_dbus_connection_signal_subscribe(connection_type,
2881                                 NULL, DBUS_INTERFACE_DBUS,
2882                                 BT_NAME_OWNER_CHANGED, NULL, NULL, 0,
2883                                 __bt_name_owner_changed, NULL, NULL);
2884 }
2885
2886 void _bt_unregister_name_owner_changed(void)
2887 {
2888         GDBusConnection *connection_type;
2889
2890         connection_type = _bt_gdbus_get_system_gconn();
2891         if (connection_type != NULL && owner_sig_id != -1) {
2892                 g_dbus_connection_signal_unsubscribe(connection_type,
2893                                                         owner_sig_id);
2894                 owner_sig_id = -1;
2895         }
2896 }
2897
2898 static void __bt_manager_event_filter(GDBusConnection *connection,
2899                                         const gchar *sender_name,
2900                                         const gchar *object_path,
2901                                         const gchar *interface_name,
2902                                         const gchar *signal_name,
2903                                         GVariant *parameters,
2904                                         gpointer user_data)
2905 {
2906         char *path = NULL;
2907         GVariantIter *interface_iter = NULL;
2908         char *interface_str = NULL;
2909         bt_gatt_service_change_t change;
2910         char address[BT_ADDRESS_STRING_SIZE] = { 0 };
2911         char secure_address[BT_ADDRESS_STRING_SIZE] = { 0 };
2912         bt_user_info_t *user_info = NULL;
2913
2914         if (strcasecmp(signal_name, "GattServiceAdded") == 0) {
2915                 g_variant_get(parameters, "(&s)", &path);
2916
2917                 _bt_convert_device_path_to_address(path, address);
2918                 _bt_convert_addr_string_to_type(change.device_addr.addr, address);
2919                 _bt_convert_addr_string_to_secure_string(secure_address, address);
2920
2921                 if (_bluetooth_gatt_check_service_change_watcher_address(&change.device_addr)
2922                         == FALSE) {
2923                         BT_INFO("GATT Service [%s] added, but no watcher for %s",
2924                                         path, secure_address);
2925                         return;
2926                 } else
2927                         BT_INFO("GATT Service [%s] added : %s",
2928                                         path, secure_address);
2929
2930                 change.svc_path = g_strdup(path);
2931                 change.change_type = BLUETOOTH_GATT_SERVICE_CHANGE_TYPE_ADD;
2932
2933                 user_info = _bt_get_user_data(BT_COMMON);
2934                 if (user_info != NULL) {
2935                         _bt_common_event_cb(
2936                                 BLUETOOTH_EVENT_GATT_CLIENT_SERVICE_CHANGED,
2937                                 BLUETOOTH_ERROR_NONE, &change,
2938                                 user_info->cb, user_info->user_data);
2939                 }
2940
2941                 g_free(change.svc_path);
2942         } else if (strcasecmp(signal_name, "InterfacesRemoved") == 0) {
2943                 g_variant_get(parameters, "(&oas)",
2944                                                         &path, &interface_iter);
2945
2946                 if (!path) {
2947                         BT_ERR("Invalid adapter path");
2948                         return;
2949                 }
2950
2951                 _bt_convert_device_path_to_address(path, address);
2952                 _bt_convert_addr_string_to_type(change.device_addr.addr, address);
2953                 _bt_convert_addr_string_to_secure_string(secure_address, address);
2954
2955                 if (_bluetooth_gatt_check_service_change_watcher_address(&change.device_addr)
2956                         == FALSE) {
2957                         BT_INFO("GATT Service [%s] removed, but no watcher for %s",
2958                                         path, secure_address);
2959                         return;
2960                 }
2961
2962                 while (g_variant_iter_loop(interface_iter, "s", &interface_str)) {
2963                         if (g_strcmp0(interface_str, GATT_SERV_INTERFACE) == 0) {
2964                                 change.svc_path = g_strdup(path);
2965                                 change.change_type = BLUETOOTH_GATT_SERVICE_CHANGE_TYPE_REMOVE;
2966
2967                                 BT_INFO("GATT Service [%s] is removed : %s",
2968                                                 path, secure_address);
2969
2970                                 user_info = _bt_get_user_data(BT_COMMON);
2971                                 if (user_info != NULL) {
2972                                         _bt_common_event_cb(
2973                                                 BLUETOOTH_EVENT_GATT_CLIENT_SERVICE_CHANGED,
2974                                                 BLUETOOTH_ERROR_NONE, &change,
2975                                                 user_info->cb, user_info->user_data);
2976                                 }
2977
2978                                 g_free(change.svc_path);
2979                                 break;
2980                         }
2981                 }
2982                 g_variant_iter_free(interface_iter);
2983         }
2984 }
2985
2986 int _bt_register_manager_subscribe_signal(gboolean subscribe)
2987 {
2988         GDBusConnection *g_conn;
2989         static int service_added_id = -1;
2990         static int interface_removed_id = -1;
2991
2992         g_conn = _bt_gdbus_get_system_gconn();
2993         if (g_conn == NULL)
2994                 return BLUETOOTH_ERROR_INTERNAL;
2995
2996         if (subscribe == TRUE) {
2997                 if (service_added_id == -1) {
2998                         service_added_id = g_dbus_connection_signal_subscribe(g_conn,
2999                                         NULL, GATT_SERV_INTERFACE,
3000                                         "GattServiceAdded", NULL, NULL, 0,
3001                                         __bt_manager_event_filter,
3002                                         NULL, NULL);
3003                 }
3004                 if (interface_removed_id == -1) {
3005                         interface_removed_id = g_dbus_connection_signal_subscribe(g_conn,
3006                                         NULL, BT_MANAGER_INTERFACE,
3007                                         "InterfacesRemoved", NULL, NULL, 0,
3008                                         __bt_manager_event_filter,
3009                                         NULL, NULL);
3010                 }
3011         } else {
3012                 if (service_added_id != -1) {
3013                         g_dbus_connection_signal_unsubscribe(g_conn,
3014                                         service_added_id);
3015                         service_added_id = -1;
3016                 }
3017                 if (interface_removed_id != -1) {
3018                         g_dbus_connection_signal_unsubscribe(g_conn,
3019                                         interface_removed_id);
3020                         interface_removed_id = -1;
3021                 }
3022         }
3023
3024         return BLUETOOTH_ERROR_NONE;
3025 }
3026