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