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