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         gboolean gatt_interface = FALSE;
 753
 754         if (strcasecmp(interface_name, BT_GATT_CHARACTERISTIC_INTERFACE) == 0)
 755                 gatt_interface = TRUE;
 756
 757         if (strcasecmp(object_path, BT_DEVICE_PATH) != 0 &&
 758                  gatt_interface == FALSE)
 759                 return;
 760         if (strcasecmp(interface_name, BT_EVENT_SERVICE) != 0 &&
 761                  gatt_interface == FALSE)
 762                 return;
 763
 764         ret_if(signal_name == NULL);
 765
 766         if (strcasecmp(signal_name, BT_GATT_CONNECTED) == 0) {
 767                 const char *address = NULL;
 768                 bluetooth_device_address_t dev_address = { {0} };
 769                 BT_DBG("BT_GATT_CONNECTED");
 770                 g_variant_get(parameters, "(i&s)", &result, &address);
 771
 772                 _bt_convert_addr_string_to_type(dev_address.addr, address);
 773                 _bt_common_event_cb(BLUETOOTH_EVENT_GATT_CONNECTED,
 774                                 result, &dev_address,
 775                                 event_info->cb, event_info->user_data);
 776         } else if (strcasecmp(signal_name, BT_GATT_DISCONNECTED) == 0) {
 777                 const char *address = NULL;
 778                 bluetooth_device_address_t dev_address = { {0} };
 779                 BT_DBG("BT_GATT_DISCONNECTED");
 780                 g_variant_get(parameters, "(i&s)", &result, &address);
 781
 782                 _bt_convert_addr_string_to_type(dev_address.addr, address);
 783                 _bt_common_event_cb(BLUETOOTH_EVENT_GATT_DISCONNECTED,
 784                                 result, &dev_address,
 785                                 event_info->cb, event_info->user_data);
 786         } else if (strcasecmp(signal_name, BT_GATT_REQ_ATT_MTU_CHANGED) == 0) {
 787                 const char *address = NULL;
 788                 bluetooth_device_address_t dev_address = { {0} };
 789                 bluetooth_le_att_mtu_info_t att_mtu_info;
 790                 guint16 mtu;
 791                 guint8 status;
 792                 BT_DBG("BT_GATT_REQ_ATT_MTU_CHANGED");
 793                 g_variant_get(parameters, "(i&sqy)", &result, &address, &mtu, &status);
 794
 795                 _bt_convert_addr_string_to_type(dev_address.addr, address);
 796
 797                 memset(&att_mtu_info, 0x00, sizeof(bluetooth_le_att_mtu_info_t));
 798                 memcpy(att_mtu_info.device_address.addr,
 799                                         dev_address.addr,
 800                                         BLUETOOTH_ADDRESS_LENGTH);
 801
 802                 att_mtu_info.mtu = mtu;
 803                 att_mtu_info.status = status;
 804
 805                 _bt_common_event_cb(BLUETOOTH_EVENT_GATT_ATT_MTU_CHANGED,
 806                                 result, &att_mtu_info,
 807                                 event_info->cb, event_info->user_data);
 808         } else if (strcasecmp(signal_name, BT_GATT_BLUEZ_CHAR_VAL_CHANGED) == 0) {
 809                 const char *char_handle = NULL;
 810                 int len = 0;
 811                 const char * value = NULL;
 812                 GVariant *char_value_var = NULL;
 813                 bt_gatt_char_value_t char_val = { 0, };
 814
 815                 g_variant_get(parameters, "(i&s@ay)", &result, &char_handle, &char_value_var);
 816
 817                 len = g_variant_get_size(char_value_var);
 818                 ret_if(char_value_var == NULL);
 819
 820                 if (len > 0)
 821                         value = (char *)g_variant_get_data(char_value_var);
 822
 823                 char_val.char_handle = g_strdup(char_handle);
 824                 char_val.val_len = len;
 825                 /* Fix : FORWARD_NULL : g_variant_get_data can return NULL */
 826                 if (char_val.val_len > 0 && value != NULL) {
 827                         char_val.char_value = (unsigned char*) g_malloc0(char_val.val_len);
 828                         memcpy(char_val.char_value, value, len);
 829                         _bt_common_event_cb(BLUETOOTH_EVENT_GATT_CHAR_VAL_CHANGED,
 830                                         result, &char_val,
 831                                         event_info->cb, event_info->user_data);
 832                         g_free(char_val.char_value);
 833                         g_variant_unref(char_value_var);
 834                 }
 835                 g_free(char_val.char_handle);
 836         } else if (strcasecmp(signal_name, BT_DEVICE_CONNECTED) == 0) {
 837                 const char *address = NULL;
 838                 unsigned char addr_type;
 839                 bt_connection_info_t conn_info;
 840                 bluetooth_device_address_t dev_address = { {0} };
 841                 BT_DBG("BT_DEVICE_CONNECTED");
 842                 g_variant_get(parameters, "(i&sy)", &result, &address, &addr_type);
 843
 844                 _bt_convert_addr_string_to_type(dev_address.addr,
 845                                                 address);
 846
 847                 memset(&conn_info, 0x00, sizeof(bt_connection_info_t));
 848
 849                 memcpy(conn_info.device_addr.addr,
 850                                         dev_address.addr,
 851                                         BLUETOOTH_ADDRESS_LENGTH);
 852
 853                 conn_info.addr_type = addr_type;
 854                 conn_info.disc_reason = 0;
 855                 _bt_common_event_cb(BLUETOOTH_EVENT_DEVICE_CONNECTED,
 856                                 result, &conn_info,
 857                                 event_info->cb, event_info->user_data);
 858
 859         } else if (strcasecmp(signal_name, BT_DEVICE_DISCONNECTED) == 0) {
 860                 const char *address = NULL;
 861                 unsigned char addr_type;
 862                 bt_connection_info_t conn_info;
 863                 bluetooth_device_address_t dev_address = { {0} };
 864                 BT_DBG("BT_DEVICE_DISCONNECTED");
 865                 g_variant_get(parameters, "(i&sy)", &result, &address, &addr_type);
 866
 867                 _bt_convert_addr_string_to_type(dev_address.addr,
 868                                                 address);
 869
 870                 memset(&conn_info, 0x00, sizeof(bt_connection_info_t));
 871
 872                 memcpy(conn_info.device_addr.addr,
 873                                         dev_address.addr,
 874                                         BLUETOOTH_ADDRESS_LENGTH);
 875
 876                 conn_info.addr_type = addr_type;
 877                 conn_info.disc_reason = result;
 878                 _bt_common_event_cb(BLUETOOTH_EVENT_DEVICE_DISCONNECTED,
 879                                 result, &conn_info,
 880                                 event_info->cb, event_info->user_data);
 881
 882         } else if (strcasecmp(signal_name, BT_RSSI_MONITORING_ENABLED) == 0) {
 883                 bt_rssi_enabled_t enabled = { 0, };
 884                 char *address;
 885                 int link_type;
 886                 gboolean rssi_enabled = FALSE;
 887
 888                 g_variant_get(parameters, "(isib)", &result, &address,
 889                                         &link_type, &rssi_enabled);
 890
 891                 BT_DBG("RSSI Enabled[Address:%s LinkType:%d RSSI_dbm:%d]",
 892                                 address, link_type, rssi_enabled);
 893                 enabled.address = address;
 894                 enabled.link_type = link_type;
 895                 enabled.rssi_enabled = rssi_enabled;
 896
 897                 _bt_common_event_cb(BLUETOOTH_EVENT_RSSI_ENABLED,
 898                                 result, &enabled,
 899                                 event_info->cb, event_info->user_data);
 900         } else if (strcasecmp(signal_name, BT_RSSI_ALERT) == 0) {
 901                 int alert_type;
 902                 int rssi_dbm;
 903                 char *address;
 904                 int link_type;
 905                 bt_rssi_alert_t alert = { 0, };
 906
 907                 g_variant_get(parameters, "(isiii)", &result, &address,
 908                                         &link_type, &alert_type, &rssi_dbm);
 909
 910                 alert.alert_type = alert_type;
 911                 alert.rssi_dbm = rssi_dbm;
 912                 alert.address = address;
 913                 alert.link_type = link_type;
 914                 BT_DBG("Address [%s] LinkType[%d] AlertType[%d] RSSI dBm[%d]",
 915                                 address, link_type, alert_type, rssi_dbm);
 916                 _bt_common_event_cb(BLUETOOTH_EVENT_RSSI_ALERT,
 917                                 result, &alert,
 918                                 event_info->cb, event_info->user_data);
 919         } else if (strcasecmp(signal_name, BT_RAW_RSSI_EVENT) == 0) {
 920                 int rssi_dbm;
 921                 int link_type;
 922                 char *address;
 923                 bt_raw_rssi_t raw_rssi = { 0, };
 924
 925                 g_variant_get(parameters, "(isii)", &result,
 926                                         &address, &link_type, &rssi_dbm);
 927
 928                 BT_DBG("Address [%s] Link Type[%d] dBm[%d]",
 929                                 address, link_type, rssi_dbm);
 930
 931                 raw_rssi.rssi_dbm = rssi_dbm;
 932                 raw_rssi.address = address;
 933                 raw_rssi.link_type = link_type;
 934
 935                 _bt_common_event_cb(BLUETOOTH_EVENT_RAW_RSSI,
 936                                 result, &raw_rssi,
 937                                 event_info->cb, event_info->user_data);
 938         } else if (strcasecmp(signal_name, BT_DEVICE_AUTHORIZED) == 0) {
 939                 const char *address = NULL;
 940                 bluetooth_device_address_t dev_address = { {0} };
 941
 942                 g_variant_get(parameters, "(i&s)", &result, &address);
 943
 944                 _bt_convert_addr_string_to_type(dev_address.addr,
 945                                                 address);
 946
 947                 _bt_common_event_cb(BLUETOOTH_EVENT_DEVICE_AUTHORIZED,
 948                                 result, &dev_address,
 949                                 event_info->cb, event_info->user_data);
 950         } else if (strcasecmp(signal_name, BT_DEVICE_UNAUTHORIZED) == 0) {
 951                 const char *address = NULL;
 952                 bluetooth_device_address_t dev_address = { {0} };
 953
 954                 g_variant_get(parameters, "(i&s)", &result, &address);
 955
 956                 _bt_convert_addr_string_to_type(dev_address.addr,
 957                                                 address);
 958
 959                 _bt_common_event_cb(BLUETOOTH_EVENT_DEVICE_UNAUTHORIZED,
 960                                 result, &dev_address,
 961                                 event_info->cb, event_info->user_data);
 962         } else if (strcasecmp(signal_name, BT_SUPPORTED_PROFILE_TRUSTED) == 0) {
 963                 char *address;
 964                 bt_supported_profile_trusted_t profile_info = { 0, };
 965                 int trust;
 966
 967                 g_variant_get(parameters, "(i&si)", &result,
 968                                         &address, &trust);
 969
 970                 BT_DBG("Address [%s] trust[%d]", address, trust);
 971                 profile_info.address = address;
 972                 if (trust & (PROFILE_SUPPORTED << 0)) { /* Bit 0 & 1 - for PBAP Supported */
 973                         profile_info.profile = TRUSTED_PROFILE_PBAP;
 974                         profile_info.supported = TRUE;
 975                         if (trust & (1 << 1)) /* Bit 1 - for PBAP Trusted */
 976                                 profile_info.trusted = TRUE;
 977                         else
 978                                 profile_info.trusted = FALSE;
 979
 980                         _bt_common_event_cb(BLUETOOTH_EVENT_SUPPORTED_PROFILE_TRUSTED,
 981                                         result, &profile_info,
 982                                         event_info->cb, event_info->user_data);
 983                 }
 984                 if (trust & (PROFILE_SUPPORTED << 2)) { /* Bit 2 & 3 - for MAP Supported */
 985                         profile_info.profile = TRUSTED_PROFILE_MAP;
 986                         profile_info.supported = TRUE;
 987                         if (trust & (1 << 3)) /* Bit 3 - for PBAP Trusted */
 988                                 profile_info.trusted = TRUE;
 989                         else
 990                                 profile_info.trusted = FALSE;
 991
 992                         _bt_common_event_cb(BLUETOOTH_EVENT_SUPPORTED_PROFILE_TRUSTED,
 993                                         result, &profile_info,
 994                                         event_info->cb, event_info->user_data);
 995                 }
 996                 if (trust & (PROFILE_SUPPORTED << 4)) { /* Bit 4 & 5- for SAP Supported */
 997                         profile_info.profile = TRUSTED_PROFILE_SAP;
 998                         profile_info.supported = TRUE;
 999                         if (trust & (1 << 5)) /* Bit 5 - for SAP Trusted */
1000                                 profile_info.trusted = TRUE;
1001                         else
1002                                 profile_info.trusted = FALSE;
1003
1004                         _bt_common_event_cb(BLUETOOTH_EVENT_SUPPORTED_PROFILE_TRUSTED,
1005                                         result, &profile_info,
1006                                         event_info->cb, event_info->user_data);
1007                 }
1008         } else if (strcasecmp(signal_name, BT_IPSP_CONNECTED) == 0) {
1009                 const char *address = NULL;
1010                 const char *if_name = NULL;
1011                 bt_ipsp_connection_info_t bt_ipsp_iface_info;
1012                 memset(&bt_ipsp_iface_info, 0, sizeof(bt_ipsp_iface_info));
1013
1014                 BT_DBG("BT_IPSP_CONNECTED");
1015                 g_variant_get(parameters, "(i&s&s)", &result, &address, &if_name);
1016
1017                 _bt_convert_addr_string_to_type(bt_ipsp_iface_info.btaddr.addr, address);
1018                 memcpy(bt_ipsp_iface_info.if_name, if_name, 16);
1019
1020                 _bt_common_event_cb(BLUETOOTH_EVENT_IPSP_CONNECTED,
1021                                 result, &bt_ipsp_iface_info,
1022                                 event_info->cb, event_info->user_data);
1023         } else if (strcasecmp(signal_name, BT_IPSP_DISCONNECTED) == 0) {
1024                 const char *address = NULL;
1025                 const char *if_name = NULL;
1026                 bt_ipsp_connection_info_t bt_ipsp_iface_info;
1027                 memset(&bt_ipsp_iface_info, 0, sizeof(bt_ipsp_iface_info));
1028
1029                 BT_DBG("BT_IPSP_DISCONNECTED");
1030                 g_variant_get(parameters, "(i&s&s)", &result, &address, &if_name);
1031
1032                 _bt_convert_addr_string_to_type(bt_ipsp_iface_info.btaddr.addr, address);
1033                 memcpy(bt_ipsp_iface_info.if_name, if_name, 16);
1034
1035                 _bt_common_event_cb(BLUETOOTH_EVENT_IPSP_DISCONNECTED,
1036                                 result, &bt_ipsp_iface_info,
1037                                 event_info->cb, event_info->user_data);
1038         } else if (strcasecmp(signal_name, BT_LE_DATA_LENGTH_CHANGED) == 0) {
1039                 const char *address = NULL;
1040                 bluetooth_device_address_t dev_address = { {0} };
1041                 uint tx_octets = 0;
1042                 uint tx_time = 0;
1043                 uint rx_octets = 0;
1044                 uint rx_time = 0;
1045                 bt_le_data_length_params_t params;
1046
1047                 BT_DBG("BT_LE_DATA_LENGTH_CHANGED");
1048
1049                 g_variant_get(parameters, "(i&sqqqq)", &result, &address,
1050                                 &tx_octets, &tx_time, &rx_octets, &rx_time);
1051
1052                 params.max_tx_octets = tx_octets;
1053                 params.max_tx_time = tx_time;
1054                 params.max_rx_octets = rx_octets;
1055                 params.max_rx_time = rx_time;
1056
1057                 _bt_convert_addr_string_to_type(dev_address.addr, address);
1058
1059                 memcpy(&params.device_address,
1060                         &dev_address, BLUETOOTH_ADDRESS_LENGTH);
1061
1062                 _bt_common_event_cb(BLUETOOTH_EVENT_LE_DATA_LENGTH_CHANGED,
1063                                 result, &params, event_info->cb, event_info->user_data);
1064         } else if (strcasecmp(signal_name, BT_PXP_PROPERTY_CHANGED) == 0) {
1065                 const char *address = NULL;
1066                 bluetooth_device_address_t dev_address = { {0} };
1067                 int role, type, level;
1068                 bt_pxp_property_changed_params_t params;
1069
1070                 BT_DBG("BT_PXP_PROPERTY_CHANGED");
1071
1072                 g_variant_get(parameters, "(isiii)", &result, &address, &role, &type, &level);
1073
1074                 _bt_convert_addr_string_to_type(dev_address.addr, address);
1075                 memcpy(&params.device_address, &dev_address, BLUETOOTH_ADDRESS_LENGTH);
1076                 params.role = role;
1077                 params.service_type = type;
1078                 params.alert_lvl = level;
1079
1080                 _bt_common_event_cb(BLUETOOTH_EVENT_PXP_PROPERTY_CHANGED,
1081                                 result, &params, event_info->cb, event_info->user_data);
1082         }
1083 }
1084
1085 void __bt_hid_event_filter(GDBusConnection *connection,
1086                                                  const gchar *sender_name,
1087                                                  const gchar *object_path,
1088                                                  const gchar *interface_name,
1089                                                  const gchar *signal_name,
1090                                                  GVariant *parameters,
1091                                                  gpointer user_data)
1092 {
1093         bt_event_info_t *event_info;
1094         int result = BLUETOOTH_ERROR_NONE;
1095
1096         event_info = (bt_event_info_t *)user_data;
1097         ret_if(event_info == NULL);
1098
1099         if (strcasecmp(object_path, BT_HID_PATH) != 0)
1100                 return;
1101         if (strcasecmp(interface_name, BT_EVENT_SERVICE) != 0)
1102                 return;
1103
1104         ret_if(signal_name == NULL);
1105
1106         if (strcasecmp(signal_name, BT_INPUT_CONNECTED) == 0) {
1107                 const char *address = NULL;
1108                 bluetooth_device_address_t dev_address = { {0} };
1109
1110                 g_variant_get(parameters, "(i&s)", &result, &address);
1111
1112                 _bt_convert_addr_string_to_type(dev_address.addr,
1113                                                 address);
1114
1115                 _bt_input_event_cb(BLUETOOTH_HID_CONNECTED,
1116                                 result, &dev_address,
1117                                 event_info->cb, event_info->user_data);
1118         } else if (strcasecmp(signal_name, BT_INPUT_DISCONNECTED) == 0) {
1119                 const char *address = NULL;
1120                 bluetooth_device_address_t dev_address = { {0} };
1121
1122                 g_variant_get(parameters, "(i&s)", &result, &address);
1123
1124                 BT_DBG("address: %s", address);
1125
1126                 _bt_convert_addr_string_to_type(dev_address.addr,
1127                                                 address);
1128
1129                 _bt_input_event_cb(BLUETOOTH_HID_DISCONNECTED,
1130                                 result, &dev_address,
1131                                 event_info->cb, event_info->user_data);
1132         }
1133 }
1134
1135 void __bt_headset_event_filter(GDBusConnection *connection,
1136                                                  const gchar *sender_name,
1137                                                  const gchar *object_path,
1138                                                  const gchar *interface_name,
1139                                                  const gchar *signal_name,
1140                                                  GVariant *parameters,
1141                                                  gpointer user_data)
1142 {
1143         bt_event_info_t *event_info;
1144         int result = BLUETOOTH_ERROR_NONE;
1145         event_info = (bt_event_info_t *)user_data;
1146         ret_if(event_info == NULL);
1147
1148         if (strcasecmp(object_path, BT_HEADSET_PATH) != 0)
1149                 return;
1150         if (strcasecmp(interface_name, BT_EVENT_SERVICE) != 0)
1151                 return;
1152
1153         ret_if(signal_name == NULL);
1154
1155         if (strcasecmp(signal_name, BT_HEADSET_CONNECTED) == 0) {
1156                 char *address = NULL;
1157
1158                 g_variant_get(parameters, "(i&s)", &result, &address);
1159
1160                 _bt_headset_event_cb(BLUETOOTH_EVENT_AG_CONNECTED,
1161                                 result, address,
1162                                 event_info->cb, event_info->user_data);
1163         } else if (strcasecmp(signal_name, BT_HEADSET_DISCONNECTED) == 0) {
1164                 char *address = NULL;
1165
1166                 g_variant_get(parameters, "(i&s)", &result, &address);
1167
1168                 _bt_headset_event_cb(BLUETOOTH_EVENT_AG_DISCONNECTED,
1169                                 result, address,
1170                                 event_info->cb, event_info->user_data);
1171         } else if (strcasecmp(signal_name, BT_STEREO_HEADSET_CONNECTED) == 0) {
1172                 char *address = NULL;
1173
1174                 g_variant_get(parameters, "(i&s)", &result, &address);
1175
1176                 _bt_headset_event_cb(BLUETOOTH_EVENT_AV_CONNECTED,
1177                                 result, address,
1178                                 event_info->cb, event_info->user_data);
1179         } else if (strcasecmp(signal_name, BT_STEREO_HEADSET_DISCONNECTED) == 0) {
1180                 char *address = NULL;
1181
1182                 g_variant_get(parameters, "(i&s)", &result, &address);
1183
1184                 _bt_headset_event_cb(BLUETOOTH_EVENT_AV_DISCONNECTED,
1185                                 result, address,
1186                                 event_info->cb, event_info->user_data);
1187         } else if (strcasecmp(signal_name, BT_A2DP_SOURCE_CONNECTED) == 0) {
1188                 char *address = NULL;
1189
1190                 g_variant_get(parameters, "(i&s)", &result, &address);
1191                 _bt_a2dp_source_event_cb(BLUETOOTH_EVENT_AV_SOURCE_CONNECTED,
1192                                                 result, address,
1193                                                 event_info->cb, event_info->user_data);
1194         } else if (strcasecmp(signal_name, BT_A2DP_SOURCE_DISCONNECTED) == 0) {
1195                 char *address = NULL;
1196
1197                 g_variant_get(parameters, "(i&s)", &result, &address);
1198
1199                 _bt_a2dp_source_event_cb(BLUETOOTH_EVENT_AV_SOURCE_DISCONNECTED,
1200                                                 result, address,
1201                                                 event_info->cb, event_info->user_data);
1202         } else if (strcasecmp(signal_name, BT_SPEAKER_GAIN) == 0) {
1203                 unsigned int gain;
1204                 guint16 spkr_gain;
1205                 char *address = NULL;
1206
1207                 g_variant_get(parameters, "(i&sq)", &result, &address,
1208                                                                 &spkr_gain);
1209                 gain = (unsigned int)spkr_gain;
1210
1211                 _bt_headset_event_cb(BLUETOOTH_EVENT_AG_SPEAKER_GAIN,
1212                                 result, &gain,
1213                                 event_info->cb, event_info->user_data);
1214         } else if (strcasecmp(signal_name, BT_MICROPHONE_GAIN) == 0) {
1215                 unsigned int gain;
1216                 guint16 mic_gain;
1217                 char *address = NULL;
1218
1219                 g_variant_get(parameters, "(i&sq)", &result,
1220                                                 &address, &mic_gain);
1221                 gain = (unsigned int)mic_gain;
1222
1223                 _bt_headset_event_cb(BLUETOOTH_EVENT_AG_MIC_GAIN,
1224                                 result, &gain,
1225                                 event_info->cb, event_info->user_data);
1226         }
1227 }
1228
1229 void __bt_hid_device_event_filter(GDBusConnection *connection,
1230                                                  const gchar *sender_name,
1231                                                  const gchar *object_path,
1232                                                  const gchar *interface_name,
1233                                                  const gchar *signal_name,
1234                                                  GVariant *parameters,
1235                                                  gpointer user_data)
1236 {
1237         bt_event_info_t *event_info;
1238         int result = BLUETOOTH_ERROR_NONE;
1239
1240         event_info = (bt_event_info_t *)user_data;
1241         ret_if(event_info == NULL);
1242         if (strcasecmp(object_path, BT_HID_DEVICE_PATH) != 0)
1243                 return;
1244         if (strcasecmp(interface_name, BT_EVENT_SERVICE) != 0)
1245                 return;
1246
1247         ret_if(signal_name == NULL);
1248
1249         if (strcasecmp(signal_name, BT_HID_DEVICE_CONNECTED) == 0) {
1250                 const char *address = NULL;
1251                 bluetooth_device_address_t dev_address = { {0} };
1252
1253                 g_variant_get(parameters, "(i&s)", &result, &address);
1254
1255                 _bt_convert_addr_string_to_type(dev_address.addr,
1256                                                 address);
1257
1258                 _bt_input_event_cb(BLUETOOTH_HID_DEVICE_CONNECTED,
1259                                 result, &dev_address,
1260                                 event_info->cb, event_info->user_data);
1261         } else if (strcasecmp(signal_name, BT_HID_DEVICE_DISCONNECTED) == 0) {
1262                 const char *address = NULL;
1263                 bluetooth_device_address_t dev_address = { {0} };
1264
1265                 g_variant_get(parameters, "(i&s)", &result, &address);
1266
1267                 BT_DBG("address: %s", address);
1268
1269                 _bt_convert_addr_string_to_type(dev_address.addr,
1270                                                 address);
1271
1272                 _bt_input_event_cb(BLUETOOTH_HID_DEVICE_DISCONNECTED,
1273                                 result, &dev_address,
1274                                 event_info->cb, event_info->user_data);
1275         } else if (strcasecmp(signal_name, BT_INPUT_HID_DEVICE_CONNECTED) == 0) {
1276                 BT_INFO_C("Type %s", g_variant_get_type_string(parameters));
1277                 const char *address = NULL;
1278                 bluetooth_device_address_t dev_address = { {0} };
1279
1280                 g_variant_get(parameters, "(i&s)", &result, &address);
1281
1282                 BT_DBG("address: %s", address);
1283                 _bt_convert_addr_string_to_type(dev_address.addr,
1284                                                 address);
1285                 int ctrl = -1, intr = -1;
1286                 _bt_hid_device_get_fd(address, &ctrl, &intr);
1287                 if (ctrl != -1 && intr != -1) {
1288                         new_hid_connection(NULL, ctrl, &dev_address);
1289                         new_hid_connection(NULL, intr, &dev_address);
1290                 }
1291         } else if (strcasecmp(signal_name, BT_INPUT_HID_DEVICE_DISCONNECTED) == 0) {
1292                 const char *address = NULL;
1293                 g_variant_get(parameters, "(i&s)", &result, &address);
1294
1295                 BT_DBG("address: %s", address);
1296         }
1297 }
1298 void __bt_a2dp_source_event_filter(GDBusConnection *connection,
1299                                                  const gchar *sender_name,
1300                                                  const gchar *object_path,
1301                                                  const gchar *interface_name,
1302                                                  const gchar *signal_name,
1303                                                  GVariant *parameters,
1304                                                  gpointer user_data)
1305 {
1306         bt_event_info_t *event_info;
1307         int result = BLUETOOTH_ERROR_NONE;
1308         event_info = (bt_event_info_t *)user_data;
1309         ret_if(event_info == NULL);
1310
1311         if (strcasecmp(object_path, BT_A2DP_SOURCE_PATH) != 0)
1312                 return;
1313         if (strcasecmp(interface_name, BT_EVENT_SERVICE) != 0)
1314                 return;
1315
1316         ret_if(signal_name == NULL);
1317
1318         if (strcasecmp(signal_name, BT_A2DP_SOURCE_CONNECTED) == 0) {
1319                 char *address = NULL;
1320
1321                 g_variant_get(parameters, "(i&s)", &result, &address);
1322                 _bt_a2dp_source_event_cb(BLUETOOTH_EVENT_AV_SOURCE_CONNECTED,
1323                                                 result, address,
1324                                                 event_info->cb, event_info->user_data);
1325         } else if (strcasecmp(signal_name, BT_A2DP_SOURCE_DISCONNECTED) == 0) {
1326                 char *address = NULL;
1327
1328                 g_variant_get(parameters, "(i&s)", &result, &address);
1329
1330                 _bt_a2dp_source_event_cb(BLUETOOTH_EVENT_AV_SOURCE_DISCONNECTED,
1331                                                 result, address,
1332                                                 event_info->cb, event_info->user_data);
1333         }
1334 }
1335
1336 void __bt_network_event_filter(GDBusConnection *connection,
1337                                                  const gchar *sender_name,
1338                                                  const gchar *object_path,
1339                                                  const gchar *interface_name,
1340                                                  const gchar *signal_name,
1341                                                  GVariant *parameters,
1342                                                  gpointer user_data)
1343 {
1344         bt_event_info_t *event_info;
1345         int result = BLUETOOTH_ERROR_NONE;
1346         event_info = (bt_event_info_t *)user_data;
1347         ret_if(event_info == NULL);
1348
1349         if (strcasecmp(object_path, BT_NETWORK_PATH) != 0)
1350                 return;
1351         if (strcasecmp(interface_name, BT_EVENT_SERVICE) != 0)
1352                 return;
1353
1354         ret_if(signal_name == NULL);
1355
1356         if (strcasecmp(signal_name, BT_NETWORK_CONNECTED) == 0) {
1357                 const char *address = NULL;
1358                 bluetooth_device_address_t dev_address = { {0} };
1359
1360                 g_variant_get(parameters, "(i&s)", &result, &address);
1361
1362                 _bt_convert_addr_string_to_type(dev_address.addr,
1363                                                 address);
1364
1365                 _bt_common_event_cb(BLUETOOTH_EVENT_NETWORK_CONNECTED,
1366                                 result, &dev_address,
1367                                 event_info->cb, event_info->user_data);
1368         } else if (strcasecmp(signal_name, BT_NETWORK_DISCONNECTED) == 0) {
1369                 const char *address = NULL;
1370                 bluetooth_device_address_t dev_address = { {0} };
1371
1372                 g_variant_get(parameters, "(i&s)", &result, &address);
1373
1374                 _bt_convert_addr_string_to_type(dev_address.addr,
1375                                                 address);
1376
1377                 _bt_common_event_cb(BLUETOOTH_EVENT_NETWORK_DISCONNECTED,
1378                                 result, &dev_address,
1379                                 event_info->cb, event_info->user_data);
1380         } else if (strcasecmp(signal_name, BT_NETWORK_SERVER_CONNECTED) == 0) {
1381                 const char *device = NULL;
1382                 const char *address = NULL;
1383                 bluetooth_network_device_info_t network_info;
1384
1385                 g_variant_get(parameters, "(i&s&s)", &result,
1386                                                         &device, &address);
1387
1388                 memset(&network_info, 0x00, sizeof(bluetooth_network_device_info_t));
1389
1390                 _bt_convert_addr_string_to_type(network_info.device_address.addr,
1391                                                 address);
1392
1393                 _bt_print_device_address_t(&network_info.device_address);
1394                 g_strlcpy(network_info.interface_name, device,
1395                                         sizeof(network_info.interface_name));
1396
1397                 DBG_SECURE("Interface: %s", network_info.interface_name);
1398
1399                 _bt_common_event_cb(BLUETOOTH_EVENT_NETWORK_SERVER_CONNECTED,
1400                                 result, &network_info,
1401                                 event_info->cb, event_info->user_data);
1402         } else if (strcasecmp(signal_name, BT_NETWORK_SERVER_DISCONNECTED) == 0) {
1403                 const char *device = NULL;
1404                 const char *address = NULL;
1405                 bluetooth_network_device_info_t network_info;
1406
1407                 g_variant_get(parameters, "(i&s&s)", &result, &device, &address);
1408
1409                 memset(&network_info, 0x00, sizeof(bluetooth_network_device_info_t));
1410
1411                 _bt_convert_addr_string_to_type(network_info.device_address.addr,
1412                                                 address);
1413
1414                 _bt_print_device_address_t(&network_info.device_address);
1415
1416                 _bt_common_event_cb(BLUETOOTH_EVENT_NETWORK_SERVER_DISCONNECTED,
1417                                 result, &network_info,
1418                                 event_info->cb, event_info->user_data);
1419         }
1420 }
1421
1422 void __bt_avrcp_event_filter(GDBusConnection *connection,
1423                                                  const gchar *sender_name,
1424                                                  const gchar *object_path,
1425                                                  const gchar *interface_name,
1426                                                  const gchar *signal_name,
1427                                                  GVariant *parameters,
1428                                                  gpointer user_data)
1429 {
1430         bt_event_info_t *event_info;
1431         int result = BLUETOOTH_ERROR_NONE;
1432         event_info = (bt_event_info_t *)user_data;
1433         ret_if(event_info == NULL);
1434
1435         if (strcasecmp(object_path, BT_AVRCP_PATH) != 0)
1436                 return;
1437         if (strcasecmp(interface_name, BT_EVENT_SERVICE) != 0)
1438                 return;
1439
1440         ret_if(signal_name == NULL);
1441
1442         if (strcasecmp(signal_name, BT_AVRCP_CONNECTED) == 0) {
1443                 char *address = NULL;
1444
1445                 g_variant_get(parameters, "(i&s)", &result, &address);
1446
1447                 _bt_avrcp_event_cb(BLUETOOTH_EVENT_AVRCP_CONNECTED,
1448                                 result, address,
1449                                 event_info->cb, event_info->user_data);
1450         } else if (strcasecmp(signal_name, BT_AVRCP_DISCONNECTED) == 0) {
1451                 char *address = NULL;
1452
1453                 g_variant_get(parameters, "(i&s)", &result, &address);
1454
1455                 _bt_avrcp_event_cb(BLUETOOTH_EVENT_AVRCP_DISCONNECTED,
1456                                 result, address,
1457                                 event_info->cb, event_info->user_data);
1458         } else if (strcasecmp(signal_name, BT_MEDIA_SHUFFLE_STATUS) == 0) {
1459                 unsigned int status;
1460
1461                 g_variant_get(parameters, "(u)", &status);
1462                 _bt_avrcp_event_cb(BLUETOOTH_EVENT_AVRCP_SETTING_SHUFFLE_STATUS,
1463                                 result, &status,
1464                                 event_info->cb, event_info->user_data);
1465         } else if (strcasecmp(signal_name, BT_MEDIA_EQUALIZER_STATUS) == 0) {
1466                 unsigned int status;
1467
1468                 g_variant_get(parameters, "(u)", &status);
1469                 _bt_avrcp_event_cb(BLUETOOTH_EVENT_AVRCP_SETTING_EQUALIZER_STATUS,
1470                                 result, &status,
1471                                 event_info->cb, event_info->user_data);
1472         } else if (strcasecmp(signal_name, BT_MEDIA_REPEAT_STATUS) == 0) {
1473                 unsigned int status;
1474
1475                 g_variant_get(parameters, "(u)", &status);
1476                 _bt_avrcp_event_cb(BLUETOOTH_EVENT_AVRCP_SETTING_REPEAT_STATUS,
1477                                 result, &status,
1478                                 event_info->cb, event_info->user_data);
1479         }  else if (strcasecmp(signal_name, BT_MEDIA_SCAN_STATUS) == 0) {
1480                 unsigned int status;
1481
1482                 g_variant_get(parameters, "(u)", &status);
1483                 _bt_avrcp_event_cb(BLUETOOTH_EVENT_AVRCP_SETTING_SCAN_STATUS,
1484                                 result, &status,
1485                                 event_info->cb, event_info->user_data);
1486         }
1487 }
1488
1489 void __bt_avrcp_control_event_filter(GDBusConnection *connection,
1490                                                 const gchar *sender_name,
1491                                                 const gchar *object_path,
1492                                                 const gchar *interface_name,
1493                                                 const gchar *signal_name,
1494                                                 GVariant *parameters,
1495                                                 gpointer user_data)
1496 {
1497         bt_event_info_t *event_info;
1498         int result = BLUETOOTH_ERROR_NONE;
1499         event_info = (bt_event_info_t *)user_data;
1500         ret_if(event_info == NULL);
1501
1502         if (strcasecmp(object_path, BT_AVRCP_CONTROL_PATH) != 0)
1503                 return;
1504         if (strcasecmp(interface_name, BT_EVENT_SERVICE) != 0)
1505                 return;
1506
1507         ret_if(signal_name == NULL);
1508
1509         if (strcasecmp(signal_name, BT_AVRCP_CONNECTED) == 0) {
1510                 char *address = NULL;
1511
1512                 g_variant_get(parameters, "(i&s)", &result, &address);
1513
1514                 _bt_avrcp_event_cb(BLUETOOTH_EVENT_AVRCP_CONTROL_CONNECTED,
1515                                 result, address,
1516                                 event_info->cb, event_info->user_data);
1517         } else if (strcasecmp(signal_name, BT_AVRCP_DISCONNECTED) == 0) {
1518                 char *address = NULL;
1519
1520                 g_variant_get(parameters, "(i&s)", &result, &address);
1521
1522                 _bt_avrcp_event_cb(BLUETOOTH_EVENT_AVRCP_CONTROL_DISCONNECTED,
1523                                 result, address,
1524                                 event_info->cb, event_info->user_data);
1525         } else if (strcasecmp(signal_name, BT_MEDIA_SHUFFLE_STATUS) == 0) {
1526                 unsigned int status;
1527
1528                 g_variant_get(parameters, "(u)", &status);
1529                 _bt_avrcp_event_cb(BLUETOOTH_EVENT_AVRCP_CONTROL_SHUFFLE_STATUS,
1530                                 result, &status,
1531                                 event_info->cb, event_info->user_data);
1532         } else if (strcasecmp(signal_name, BT_MEDIA_EQUALIZER_STATUS) == 0) {
1533                 unsigned int status;
1534
1535                 g_variant_get(parameters, "(u)", &status);
1536                 _bt_avrcp_event_cb(BLUETOOTH_EVENT_AVRCP_CONTROL_EQUALIZER_STATUS,
1537                                 result, &status,
1538                                 event_info->cb, event_info->user_data);
1539         } else if (strcasecmp(signal_name, BT_MEDIA_REPEAT_STATUS) == 0) {
1540                 unsigned int status;
1541
1542                 g_variant_get(parameters, "(u)", &status);
1543                 _bt_avrcp_event_cb(BLUETOOTH_EVENT_AVRCP_CONTROL_REPEAT_STATUS,
1544                                 result, &status,
1545                                 event_info->cb, event_info->user_data);
1546         }  else if (strcasecmp(signal_name, BT_MEDIA_SCAN_STATUS) == 0) {
1547                 unsigned int status;
1548
1549                 g_variant_get(parameters, "(u)", &status);
1550                 _bt_avrcp_event_cb(BLUETOOTH_EVENT_AVRCP_CONTROL_SCAN_STATUS,
1551                                 result, &status,
1552                                 event_info->cb, event_info->user_data);
1553         } else if (strcasecmp(signal_name, BT_MEDIA_PLAY_STATUS) == 0) {
1554                 unsigned int status;
1555
1556                 g_variant_get(parameters, "(u)", &status);
1557                 _bt_avrcp_event_cb(BLUETOOTH_EVENT_AVRCP_PLAY_STATUS_CHANGED,
1558                                 result, &status,
1559                                 event_info->cb, event_info->user_data);
1560         } else if (strcasecmp(signal_name, BT_MEDIA_POSITION_STATUS) == 0) {
1561                 unsigned int status;
1562
1563                 g_variant_get(parameters, "(u)", &status);
1564                 _bt_avrcp_event_cb(BLUETOOTH_EVENT_AVRCP_SONG_POSITION_STATUS,
1565                                 result, &status,
1566                                 event_info->cb, event_info->user_data);
1567         } else if (strcasecmp(signal_name, BT_MEDIA_TRACK_CHANGE) == 0) {
1568                 media_metadata_attributes_t metadata;
1569                 const char *title;
1570                 const char *artist;
1571                 const char *album;
1572                 const char *genre;
1573                 unsigned int total_tracks;
1574                 unsigned int number;
1575                 unsigned int duration;
1576
1577                 g_variant_get(parameters, "(&s&s&s&suuu)", &title,
1578                                                 &artist, &album, &genre,
1579                                                 &total_tracks, &number,
1580                                                 &duration);
1581                 memset(&metadata, 0x00, sizeof(media_metadata_attributes_t));
1582
1583                 metadata.title = title;
1584                 metadata.artist = artist;
1585                 metadata.album = album;
1586                 metadata.genre = genre;
1587                 metadata.total_tracks = total_tracks;
1588                 metadata.number = number;
1589                 metadata.duration = duration;
1590
1591                 _bt_avrcp_event_cb(BLUETOOTH_EVENT_AVRCP_TRACK_CHANGED,
1592                                 result, &metadata,
1593                                 event_info->cb, event_info->user_data);
1594         }
1595 }
1596
1597 void __bt_opp_client_event_filter(GDBusConnection *connection,
1598                                                  const gchar *sender_name,
1599                                                  const gchar *object_path,
1600                                                  const gchar *interface_name,
1601                                                  const gchar *signal_name,
1602                                                  GVariant *parameters,
1603                                                  gpointer user_data)
1604 {
1605         bt_event_info_t *event_info;
1606         int result = BLUETOOTH_ERROR_NONE;
1607         event_info = (bt_event_info_t *)user_data;
1608         ret_if(event_info == NULL);
1609
1610         if (strcasecmp(object_path, BT_OPP_CLIENT_PATH) != 0)
1611                 return;
1612         if (strcasecmp(interface_name, BT_EVENT_SERVICE) != 0)
1613                 return;
1614
1615         ret_if(signal_name == NULL);
1616
1617         if (strcasecmp(signal_name, BT_OPP_CONNECTED) == 0) {
1618                 const char *address = NULL;
1619                 int request_id = 0;
1620                 bluetooth_device_address_t dev_address = { {0} };
1621
1622                 g_variant_get(parameters, "(i&si)", &result,
1623                                                 &address, &request_id);
1624
1625                 if (__bt_is_request_id_exist(request_id) == FALSE) {
1626                         BT_ERR("Different request id!");
1627                         return;
1628                 }
1629
1630                 _bt_convert_addr_string_to_type(dev_address.addr,
1631                                                 address);
1632
1633                 _bt_common_event_cb(BLUETOOTH_EVENT_OPC_CONNECTED,
1634                                 result, &dev_address,
1635                                 event_info->cb, event_info->user_data);
1636
1637                 if (result != BLUETOOTH_ERROR_NONE)
1638                         __bt_remove_push_request_id(request_id);
1639
1640         } else if (strcasecmp(signal_name, BT_OPP_DISCONNECTED) == 0) {
1641                 const char *address = NULL;
1642                 int request_id = 0;
1643                 bluetooth_device_address_t dev_address = { {0} };
1644
1645                 g_variant_get(parameters, "(i&si)", &result, &address,
1646                                                         &request_id);
1647
1648                 if (__bt_is_request_id_exist(request_id) == FALSE) {
1649                         BT_ERR("Different request id!");
1650                         return;
1651                 }
1652
1653                 _bt_convert_addr_string_to_type(dev_address.addr,
1654                                                 address);
1655
1656                 _bt_common_event_cb(BLUETOOTH_EVENT_OPC_DISCONNECTED,
1657                                 result, &dev_address,
1658                                 event_info->cb, event_info->user_data);
1659
1660                 __bt_remove_push_request_id(request_id);
1661         } else if (strcasecmp(signal_name, BT_TRANSFER_STARTED) == 0) {
1662                 const char *file_name = NULL;
1663                 const char *device_addr = NULL;
1664                 int request_id = 0;
1665                 guint64 size = 0;
1666                 bt_opc_transfer_info_t transfer_info;
1667
1668                 g_variant_get(parameters, "(i&s&sti)", &result, &device_addr, &file_name,
1669                                                 &size, &request_id);
1670
1671                 if (__bt_is_request_id_exist(request_id) == FALSE) {
1672                         BT_ERR("Different request id!");
1673                         return;
1674                 }
1675
1676                 memset(&transfer_info, 0x00, sizeof(bt_opc_transfer_info_t));
1677
1678                 transfer_info.filename = g_strdup(file_name);
1679                 transfer_info.device_addr = g_strdup(device_addr);
1680                 transfer_info.size = size;
1681
1682                 _bt_common_event_cb(BLUETOOTH_EVENT_OPC_TRANSFER_STARTED,
1683                                 result, &transfer_info,
1684                                 event_info->cb, event_info->user_data);
1685
1686                 g_free(transfer_info.device_addr);
1687                 g_free(transfer_info.filename);
1688         } else if (strcasecmp(signal_name, BT_TRANSFER_PROGRESS) == 0) {
1689                 const char *file_name = NULL;
1690                 int request_id = 0;
1691                 guint64 size = 0;
1692                 int progress = 0;
1693                 bt_opc_transfer_info_t transfer_info;
1694
1695                 g_variant_get(parameters, "(i&stii)", &result,
1696                         &file_name, &size, &progress, &request_id);
1697
1698                 if (__bt_is_request_id_exist(request_id) == FALSE) {
1699                         BT_ERR("Different request id!");
1700                         return;
1701                 }
1702
1703                 memset(&transfer_info, 0x00, sizeof(bt_opc_transfer_info_t));
1704
1705                 transfer_info.filename = g_strdup(file_name);
1706                 transfer_info.size = size;
1707                 transfer_info.percentage = progress;
1708
1709                 _bt_common_event_cb(BLUETOOTH_EVENT_OPC_TRANSFER_PROGRESS,
1710                                 result, &transfer_info,
1711                                 event_info->cb, event_info->user_data);
1712
1713                 g_free(transfer_info.filename);
1714         } else if (strcasecmp(signal_name, BT_TRANSFER_COMPLETED) == 0) {
1715                 const char *file_name = NULL;
1716                 const char *device_addr = NULL;
1717                 int request_id = 0;
1718                 guint64 size = 0;
1719                 bt_opc_transfer_info_t transfer_info;
1720
1721                 g_variant_get(parameters, "(i&s&sti)", &result, &device_addr,
1722                                         &file_name, &size, &request_id);
1723
1724                 if (__bt_is_request_id_exist(request_id) == FALSE) {
1725                         BT_ERR("Different request id!");
1726                         return;
1727                 }
1728
1729                 memset(&transfer_info, 0x00, sizeof(bt_opc_transfer_info_t));
1730
1731                 transfer_info.device_addr = g_strdup(device_addr);
1732                 transfer_info.filename = g_strdup(file_name);
1733                 transfer_info.size = size;
1734
1735                 _bt_common_event_cb(BLUETOOTH_EVENT_OPC_TRANSFER_COMPLETE,
1736                                 result, &transfer_info,
1737                                 event_info->cb, event_info->user_data);
1738
1739                 g_free(transfer_info.device_addr);
1740                 g_free(transfer_info.filename);
1741         }
1742 }
1743
1744 void __bt_opp_server_event_filter(GDBusConnection *connection,
1745                                                  const gchar *sender_name,
1746                                                  const gchar *object_path,
1747                                                  const gchar *interface_name,
1748                                                  const gchar *signal_name,
1749                                                  GVariant *parameters,
1750                                                  gpointer user_data)
1751 {
1752         bt_event_info_t *event_info;
1753         int result = BLUETOOTH_ERROR_NONE;
1754         event_info = (bt_event_info_t *)user_data;
1755         ret_if(event_info == NULL);
1756
1757         if (strcasecmp(object_path, BT_OPP_SERVER_PATH) != 0)
1758                 return;
1759         if (strcasecmp(interface_name, BT_EVENT_SERVICE) != 0)
1760                 return;
1761
1762         ret_if(signal_name == NULL);
1763
1764         if (strcasecmp(signal_name, BT_TRANSFER_AUTHORIZED) == 0) {
1765                 /* Native only event */
1766                 const char *file_name = NULL;
1767                 const char *address = NULL;
1768                 const char *device_name = NULL;
1769                 guint64 size = 0;
1770                 bt_obex_server_authorize_into_t auth_info;
1771
1772                 g_variant_get(parameters, "(i&st&s&s)", &result, &file_name, &size,
1773                                 &address, &device_name);
1774
1775                 /* OSP server: Don't get this event */
1776                 ret_if(obex_server_id == BT_CUSTOM_SERVER);
1777
1778                 memset(&auth_info, 0x00, sizeof(bt_obex_server_authorize_into_t));
1779
1780                 auth_info.filename = g_strdup(file_name);
1781                 auth_info.length = size;
1782                 auth_info.address = g_strdup(address);
1783                 auth_info.name = g_strdup(device_name);
1784                 _bt_common_event_cb(BLUETOOTH_EVENT_OBEX_SERVER_TRANSFER_AUTHORIZE,
1785                                 result, &auth_info,
1786                                 event_info->cb, event_info->user_data);
1787
1788                 g_free(auth_info.filename);
1789                 g_free(auth_info.address);
1790                 g_free(auth_info.name);
1791         } else if (strcasecmp(signal_name, BT_CONNECTION_AUTHORIZED) == 0) {
1792                 /* OSP only event */
1793                 const char *address = NULL;
1794                 const char *name = NULL;
1795                 bluetooth_device_address_t dev_address = { {0} };
1796
1797                 g_variant_get(parameters, "(i&s&s)", &result, &address, &name);
1798
1799                 /* Native server: Don't get this event */
1800                 ret_if(obex_server_id == BT_NATIVE_SERVER);
1801
1802                 _bt_convert_addr_string_to_type(dev_address.addr,
1803                                                 address);
1804
1805                 _bt_common_event_cb(BLUETOOTH_EVENT_OBEX_SERVER_CONNECTION_AUTHORIZE,
1806                                 result, &dev_address,
1807                                 event_info->cb, event_info->user_data);
1808         } else if (strcasecmp(signal_name, BT_TRANSFER_CONNECTED) == 0) {
1809                 bt_obex_server_connection_info_t conn_info = {0, };
1810                 char *address = NULL;
1811                 char *name = NULL;
1812                 int transfer_id = -1;
1813                 g_variant_get(parameters, "(i&s&si)", &result,
1814                                 &address, &name, &transfer_id);
1815
1816                 conn_info.address = g_strdup(address);
1817                 conn_info.device_name = g_strdup(name);
1818                 conn_info.transfer_id = transfer_id;
1819
1820                 _bt_common_event_cb(BLUETOOTH_EVENT_OBEX_SERVER_TRANSFER_CONNECTED,
1821                                         result, &conn_info, event_info->cb,
1822                                         event_info->user_data);
1823
1824                 g_free(conn_info.address);
1825                 g_free(conn_info.device_name);
1826         } else if (strcasecmp(signal_name, BT_TRANSFER_DISCONNECTED) == 0) {
1827                 bt_obex_server_transfer_info_t transfer_info = {0, };
1828                 char *address = NULL;
1829                 int transfer_id = -1;
1830                 g_variant_get(parameters, "(i&si)", &result, &address, &transfer_id);
1831                 DBG_SECURE("address: %s, transfer_id: %d", address, transfer_id);
1832
1833                 transfer_info.address = g_strdup(address);
1834                 transfer_info.transfer_id = transfer_id;
1835
1836                 _bt_common_event_cb(BLUETOOTH_EVENT_OBEX_SERVER_TRANSFER_DISCONNECTED,
1837                                         result, &transfer_info, event_info->cb,
1838                                         event_info->user_data);
1839                 g_free(transfer_info.address);
1840         } else if (strcasecmp(signal_name, BT_TRANSFER_STARTED) == 0) {
1841                 const char *device_name = NULL;
1842                 const char *file_name = NULL;
1843                 const char *type = NULL;
1844                 const char *address = NULL;
1845                 GVariantIter *iter = NULL;
1846                 int i = 0;
1847                 guchar byte;
1848                 int transfer_id = 0;
1849                 int server_type = 0; /* bt_server_type_t */
1850                 guint64 size = 0;
1851                 bt_obex_server_transfer_info_t transfer_info;
1852
1853                 g_variant_get(parameters, "(i&s&s&s&stii(ay))", &result, &device_name,
1854                         &file_name, &type, &address, &size, &transfer_id, &server_type, &iter);
1855
1856                 /* Other server's event */
1857                 ret_if(obex_server_id != server_type &&
1858                         server_type != BT_FTP_SERVER);
1859
1860                 memset(&transfer_info, 0x00, sizeof(bt_obex_server_transfer_info_t));
1861
1862                 transfer_info.contact_auth_info = g_malloc0(sizeof(unsigned char) * 5);
1863
1864                 for (i = 0; i < 5 && g_variant_iter_loop(iter, "y", &byte); ++i)
1865                         transfer_info.contact_auth_info[i] = byte;
1866
1867                 transfer_info.device_name = g_strdup(device_name);
1868                 transfer_info.filename = g_strdup(file_name);
1869                 transfer_info.type = g_strdup(type);
1870                 transfer_info.address = g_strdup(address);
1871                 transfer_info.file_size = size;
1872                 transfer_info.transfer_id = transfer_id;
1873                 transfer_info.server_type = (server_type == BT_FTP_SERVER) ?
1874                                                 FTP_SERVER : OPP_SERVER;
1875
1876                 _bt_common_event_cb(BLUETOOTH_EVENT_OBEX_SERVER_TRANSFER_STARTED,
1877                                 result, &transfer_info,
1878                                 event_info->cb, event_info->user_data);
1879
1880                 g_free(transfer_info.filename);
1881                 g_free(transfer_info.type);
1882                 g_free(transfer_info.device_name);
1883                 g_free(transfer_info.address);
1884                 g_free(transfer_info.contact_auth_info);
1885                 g_variant_iter_free(iter);
1886         } else if (strcasecmp(signal_name, BT_TRANSFER_PROGRESS) == 0) {
1887                 const char *file_name = NULL;
1888                 const char *type = NULL;
1889                 const char *device_name = NULL;
1890                 const char *address = NULL;
1891                 int transfer_id = 0;
1892                 int progress = 0;
1893                 int server_type = 0; /* bt_server_type_t */
1894                 guint64 size = 0;
1895                 bt_obex_server_transfer_info_t transfer_info;
1896
1897                 g_variant_get(parameters, "(i&s&s&s&stiii)", &result, &file_name,
1898                                                 &type, &device_name, &address, &size, &transfer_id,
1899                                                 &progress, &server_type);
1900
1901                 /* Other server's event */
1902                 ret_if(obex_server_id != server_type &&
1903                         server_type != BT_FTP_SERVER);
1904
1905                 memset(&transfer_info, 0x00, sizeof(bt_obex_server_transfer_info_t));
1906
1907                 transfer_info.filename = g_strdup(file_name);
1908                 transfer_info.type = g_strdup(type);
1909                 transfer_info.device_name = g_strdup(device_name);
1910                 transfer_info.address = g_strdup(address);
1911                 transfer_info.file_size = size;
1912                 transfer_info.transfer_id = transfer_id;
1913                 transfer_info.percentage = progress;
1914                 transfer_info.server_type = (server_type == BT_FTP_SERVER) ?
1915                                                 FTP_SERVER : OPP_SERVER;
1916
1917                 _bt_common_event_cb(BLUETOOTH_EVENT_OBEX_SERVER_TRANSFER_PROGRESS,
1918                                 result, &transfer_info,
1919                                 event_info->cb, event_info->user_data);
1920
1921                 g_free(transfer_info.filename);
1922                 g_free(transfer_info.device_name);
1923                 g_free(transfer_info.address);
1924                 g_free(transfer_info.type);
1925         } else if (strcasecmp(signal_name, BT_TRANSFER_COMPLETED) == 0) {
1926                 const char *file_name = NULL;
1927                 const char *device_name = NULL;
1928                 const char *address = NULL;
1929                 const char *type = NULL;
1930                 const char *file_path;
1931                 int transfer_id = 0;
1932                 int server_type = 0; /* bt_server_type_t */
1933                 guint64 size = 0;
1934                 bt_obex_server_transfer_info_t transfer_info;
1935
1936                 g_variant_get(parameters, "(i&s&s&s&s&stii)", &result, &file_name,
1937                                         &type, &device_name, &file_path, &address, &size,
1938                                         &transfer_id, &server_type);
1939
1940                 /* Other server's event */
1941                 ret_if(obex_server_id != server_type &&
1942                         server_type != BT_FTP_SERVER);
1943
1944                 memset(&transfer_info, 0x00, sizeof(bt_obex_server_transfer_info_t));
1945
1946                 transfer_info.filename = g_strdup(file_name);
1947                 transfer_info.type = g_strdup(type);
1948                 transfer_info.device_name = g_strdup(device_name);
1949                 transfer_info.file_path = g_strdup(file_path);
1950                 transfer_info.address = g_strdup(address);
1951                 transfer_info.file_size = size;
1952                 transfer_info.transfer_id = transfer_id;
1953                 transfer_info.server_type = (server_type == BT_FTP_SERVER) ?
1954                                                 FTP_SERVER : OPP_SERVER;
1955
1956                 _bt_common_event_cb(BLUETOOTH_EVENT_OBEX_SERVER_TRANSFER_COMPLETED,
1957                                 result, &transfer_info,
1958                                 event_info->cb, event_info->user_data);
1959
1960                 g_free(transfer_info.filename);
1961                 g_free(transfer_info.type);
1962                 g_free(transfer_info.device_name);
1963                 g_free(transfer_info.address);
1964                 g_free(transfer_info.file_path);
1965         }
1966 }
1967
1968 void __bt_map_client_event_filter(GDBusConnection *connection,
1969                                                  const gchar *sender_name,
1970                                                  const gchar *object_path,
1971                                                  const gchar *interface_name,
1972                                                  const gchar *signal_name,
1973                                                  GVariant *parameters,
1974                                                  gpointer user_data)
1975 {
1976         BT_DBG("Entered __bt_map_client_event_filter");
1977         bt_event_info_t *event_info;
1978         int result = BLUETOOTH_ERROR_NONE;
1979         event_info = (bt_event_info_t *)user_data;
1980         ret_if(event_info == NULL);
1981
1982         if (strcasecmp(object_path, BT_MAP_CLIENT_PATH) != 0)
1983                 return;
1984         if (strcasecmp(interface_name, BT_EVENT_SERVICE) != 0)
1985                 return;
1986
1987         ret_if(signal_name == NULL);
1988
1989         if (strcasecmp(signal_name, BT_MAP_CONNECTED) == 0) {
1990                 const char *address = NULL;
1991                 int request_id = 0;
1992                 bluetooth_device_address_t dev_address = { {0} };
1993
1994                 g_variant_get(parameters, "(i&si)", &result,
1995                                                 &address, &request_id);
1996
1997                 if (__bt_is_request_id_exist(request_id) == FALSE) {
1998                         BT_ERR("Different request id!");
1999                         return;
2000                 }
2001
2002                 _bt_convert_addr_string_to_type(dev_address.addr,
2003                                                 address);
2004
2005                 _bt_common_event_cb(BLUETOOTH_EVENT_MAP_CONNECTED,
2006                                 result, &dev_address,
2007                                 event_info->cb, event_info->user_data);
2008
2009                 if (result != BLUETOOTH_ERROR_NONE)
2010                         __bt_remove_push_request_id(request_id);
2011         } else if (strcasecmp(signal_name, BT_MAP_DISCONNECTED) == 0) {
2012                 const char *address = NULL;
2013                 int request_id = 0;
2014                 bluetooth_device_address_t dev_address = { {0} };
2015
2016                 g_variant_get(parameters, "(i&si)", &result, &address,
2017                                 &request_id);
2018
2019                 if (__bt_is_request_id_exist(request_id) == FALSE) {
2020                         BT_ERR("Different request id!");
2021                         return;
2022                 }
2023
2024                 _bt_convert_addr_string_to_type(dev_address.addr,
2025                                 address);
2026
2027                 _bt_common_event_cb(BLUETOOTH_EVENT_MAP_DISCONNECTED,
2028                                 result, &dev_address,
2029                                 event_info->cb, event_info->user_data);
2030
2031                 __bt_remove_push_request_id(request_id);
2032         } else if (strcasecmp(signal_name, BT_MAP_LIST_FOLDERS_COMPLETE) == 0) {
2033                 int request_id = 0;
2034                 GVariant* folder_list_var = NULL;
2035
2036                 g_variant_get(parameters, "(iiv)", &result, &request_id, &folder_list_var);
2037                 if (__bt_is_request_id_exist(request_id) == FALSE) {
2038                         BT_ERR("Different request id!");
2039                         return;
2040                 }
2041
2042                 GVariantIter* iter;
2043
2044                 bt_map_client_folders_s folders_struct = {0,};
2045                 g_variant_get(folder_list_var, "(aa{sv})", &iter);
2046
2047                 folders_struct.size = g_variant_iter_n_children(iter);
2048                 folders_struct.names = (char**) malloc(folders_struct.size * sizeof(*(folders_struct.names)));
2049                 BT_DBG("g_variant_iter_n_children: %d", folders_struct.size);
2050                 GVariantIter* res = NULL;
2051                 int i = 0;
2052                 while (g_variant_iter_loop(iter, "a{sv}", &res)) {
2053                         char* key = NULL;
2054                         GVariant* value = NULL;
2055                         while (g_variant_iter_loop(res, "{sv}", &key, &value)) {
2056                                 char* string_value = NULL;
2057                                 g_variant_get(value, "s", &string_value);
2058                                 BT_DBG("got folder name: %s", string_value);
2059                                 folders_struct.names[i] = strdup(string_value);
2060                         }
2061                         ++i;
2062                 }
2063                 _bt_common_event_cb(BLUETOOTH_EVENT_MAP_LIST_FOLDERS_COMPLETE,
2064                                 result, &folders_struct,
2065                                 event_info->cb, event_info->user_data);
2066
2067                 __bt_remove_push_request_id(request_id);
2068
2069                 // freeing resources
2070                 while (--i >= 0) {
2071                         free(folders_struct.names[i]);
2072                         folders_struct.names[i] = NULL;
2073                 }
2074                 free(folders_struct.names);
2075
2076                 g_variant_unref(folder_list_var);
2077
2078         } else if (strcasecmp(signal_name, BT_MAP_FILTER_FIELDS_COMPLETE) == 0) {
2079                 BT_DBG("BT_MAP_LIST_FOLDERS_COMPLETE");
2080
2081                 GVariant *value;
2082                 int request_id = 0;
2083                 int i = 0;
2084                 bt_map_list_filter_fields_info_t fields_info = {0,};
2085
2086                 g_variant_get(parameters, "(ivi)", &result, &value, &request_id);
2087
2088                 if (__bt_is_request_id_exist(request_id) == FALSE) {
2089                         BT_ERR("Different request id!");
2090                         return;
2091                 }
2092
2093                 if (value) {
2094                         GVariantIter *iter = NULL;
2095                         g_variant_get(value, "(as)", &iter);
2096                         fields_info.size  = g_variant_iter_n_children(iter);
2097                         char* field = NULL;
2098
2099                         fields_info.fields = malloc(fields_info.size * sizeof(char*));
2100                         while (g_variant_iter_loop(iter, "s", &field)) {
2101                                 fields_info.fields[i] = strdup(field);
2102                                 i++;
2103                         }
2104                 }
2105
2106                 _bt_common_event_cb(BLUETOOTH_EVENT_MAP_LIST_FILTER_FIELD_COMPLETE,
2107                                 request_id, &fields_info,
2108                                 event_info->cb, event_info->user_data);
2109
2110                 while (--i >= 0) {
2111                         free(fields_info.fields[i]);
2112                         fields_info.fields[i] = NULL;
2113                 }
2114                 free(fields_info.fields);
2115
2116                 __bt_remove_push_request_id(request_id);
2117                 g_variant_unref(value);
2118         } else if (strcasecmp(signal_name, BT_MAP_LIST_MESSAGES_COMPLETE) == 0) {
2119                 int request_id = 0;
2120                 GVariant* messages_list_var = NULL;
2121                 g_variant_get(parameters, "(iiv)", &result, &request_id, &messages_list_var);
2122                 if (__bt_is_request_id_exist(request_id) == FALSE) {
2123                         BT_ERR("Different request id!");
2124                         return;
2125                 }
2126
2127                 bt_map_client_message_items_s messages_struct = {0,};
2128
2129                 GVariantIter* iter;
2130                 g_variant_get(messages_list_var, "(a{oa{sv}})", &iter);
2131                 messages_struct.size = g_variant_iter_n_children(iter);
2132                 messages_struct.message_items = (bt_map_client_message_item_t*)
2133                         malloc(messages_struct.size * sizeof(*(messages_struct.message_items)));
2134                 BT_DBG("g_variant_iter_n_children: %d", messages_struct.size);
2135
2136                 char *object = NULL;
2137                 GVariantIter *properites = NULL;
2138                 int i = 0;
2139                 while (g_variant_iter_loop(iter, "{oa{sv}}", &object, &properites)) {
2140                         messages_struct.message_items[i].message_object = strdup(object);
2141                         BT_DBG("Message found: %s", messages_struct.message_items[i].message_object);
2142                         messages_struct.message_items[i].folder = NULL;
2143                         messages_struct.message_items[i].subject = NULL;
2144                         messages_struct.message_items[i].timestamp = NULL;
2145                         messages_struct.message_items[i].sender = NULL;
2146                         messages_struct.message_items[i].sender_address = NULL;
2147                         messages_struct.message_items[i].reply_to = NULL;
2148                         messages_struct.message_items[i].recipient = NULL;
2149                         messages_struct.message_items[i].recipient_address = NULL;
2150                         messages_struct.message_items[i].type = NULL;
2151                         messages_struct.message_items[i].size = -1;
2152                         messages_struct.message_items[i].is_text = -1;
2153                         messages_struct.message_items[i].status = NULL;
2154                         messages_struct.message_items[i].attachment_size = -1;
2155                         messages_struct.message_items[i].is_priority = -1;
2156                         messages_struct.message_items[i].is_read = -1;
2157                         messages_struct.message_items[i].is_sent = -1;
2158                         messages_struct.message_items[i].is_protected = -1;
2159                         char *key = NULL;
2160                         GVariant *value = NULL;
2161                         while (g_variant_iter_loop(properites, "{sv}", &key, &value)) {
2162                                 char *value_string = NULL;
2163                                 uint64_t value_int = -1;
2164                                 bool value_bool = false;
2165                                 if (strcmp(key, "Folder") == 0) {
2166                                         g_variant_get(value, "s", &value_string);
2167                                         messages_struct.message_items[i].folder = strdup(value_string);
2168                                         BT_DBG("  Folder: %s", value_string);
2169                                 } else if (strcmp(key, "Subject") == 0) {
2170                                         g_variant_get(value, "s", &value_string);
2171                                         messages_struct.message_items[i].subject = strdup(value_string);
2172                                         BT_DBG("  Subject: %s", value_string);
2173                                 } else if (strcmp(key, "Timestamp") == 0) {
2174                                         g_variant_get(value, "s", &value_string);
2175                                         messages_struct.message_items[i].timestamp = strdup(value_string);
2176                                         BT_DBG("  Timestamp: %s", value_string);
2177                                 } else if (strcmp(key, "Sender") == 0) {
2178                                         g_variant_get(value, "s", &value_string);
2179                                         messages_struct.message_items[i].sender = strdup(value_string);
2180                                         BT_DBG("  Sender: %s", value_string);
2181                                 } else if (strcmp(key, "SenderAddress") == 0) {
2182                                         g_variant_get(value, "s", &value_string);
2183                                         messages_struct.message_items[i].sender_address = strdup(value_string);
2184                                         BT_DBG("  SenderAddress: %s", value_string);
2185                                 } else if (strcmp(key, "ReplyTo") == 0) {
2186                                         g_variant_get(value, "s", &value_string);
2187                                         messages_struct.message_items[i].reply_to = strdup(value_string);
2188                                         BT_DBG("  ReplyTo: %s", value_string);
2189                                 } else if (strcmp(key, "Recipient") == 0) {
2190                                         g_variant_get(value, "s", &value_string);
2191                                         messages_struct.message_items[i].recipient = strdup(value_string);
2192                                         BT_DBG("  Recipient: %s", value_string);
2193                                 } else if (strcmp(key, "RecipientAddress") == 0) {
2194                                         g_variant_get(value, "s", &value_string);
2195                                         messages_struct.message_items[i].recipient_address = strdup(value_string);
2196                                         BT_DBG("  RecipientAddress: %s", value_string);
2197                                 } else if (strcmp(key, "Type") == 0) {
2198                                         g_variant_get(value, "s", &value_string);
2199                                         messages_struct.message_items[i].type = strdup(value_string);
2200                                         BT_DBG("  Type: %s", value_string);
2201                                 } else if (strcmp(key, "Size") == 0) {
2202                                         g_variant_get(value, "t", &value_int);
2203                                         messages_struct.message_items[i].size = value_int;
2204                                         BT_DBG("  Size: %d", value_int);
2205                                 } else if (strcmp(key, "Text") == 0) {
2206                                         g_variant_get(value, "b", &value_bool);
2207                                         messages_struct.message_items[i].is_text = value_bool ? 1 : 0;
2208                                         BT_DBG("  Text: %s", value_bool ? "true" : "false");
2209                                 } else if (strcmp(key, "Status") == 0) {
2210                                         g_variant_get(value, "s", &value_string);
2211                                         messages_struct.message_items[i].status = strdup(value_string);
2212                                         BT_DBG("  Status: %s", value_string);
2213                                 } else if (strcmp(key, "AttachmentSize") == 0) {
2214                                         g_variant_get(value, "t", &value_int);
2215                                         messages_struct.message_items[i].attachment_size = value_int;
2216                                         BT_DBG("  AttachmentSize: %d", value_int);
2217                                 } else if (strcmp(key, "Priority") == 0) {
2218                                         g_variant_get(value, "b", &value_bool);
2219                                         messages_struct.message_items[i].is_priority = value_bool ? 1 : 0;
2220                                         BT_DBG("  Priority: %s", value_bool ? "true" : "false");
2221                                 } else if (strcmp(key, "Read") == 0) {
2222                                         g_variant_get(value, "b", &value_bool);
2223                                         messages_struct.message_items[i].is_read = value_bool ? 1 : 0;
2224                                         BT_DBG("  Read: %s", value_bool ? "true" : "false");
2225                                 } else if (strcmp(key, "Sent") == 0) {
2226                                         g_variant_get(value, "b", &value_bool);
2227                                         messages_struct.message_items[i].is_sent = value_bool ? 1 : 0;
2228                                         BT_DBG("  Sent: %s", value_bool ? "true" : "false");
2229                                 } else if (strcmp(key, "Protected") == 0) {
2230                                         g_variant_get(value, "b", &value_bool);
2231                                         messages_struct.message_items[i].is_protected = value_bool ? 1 : 0;
2232                                         BT_DBG("  Protected: %s", value_bool ? "true" : "false");
2233                                 }
2234                         }
2235                         ++i;
2236                 }
2237
2238                 _bt_common_event_cb(BLUETOOTH_EVENT_MAP_LIST_MESSAGES_COMPLETE,
2239                                 result, &messages_struct,
2240                                 event_info->cb, event_info->user_data);
2241
2242                 __bt_remove_push_request_id(request_id);
2243
2244                 while (--i >= 0) {
2245                         free(messages_struct.message_items[i].folder);
2246                         free(messages_struct.message_items[i].subject);
2247                         free(messages_struct.message_items[i].timestamp);
2248                         free(messages_struct.message_items[i].sender);
2249                         free(messages_struct.message_items[i].sender_address);
2250                         free(messages_struct.message_items[i].reply_to);
2251                         free(messages_struct.message_items[i].recipient);
2252                         free(messages_struct.message_items[i].recipient_address);
2253                         free(messages_struct.message_items[i].type);
2254                         free(messages_struct.message_items[i].status);
2255                 }
2256                 free(messages_struct.message_items);
2257
2258                 g_variant_unref(messages_list_var);
2259         } else if (strcasecmp(signal_name, BT_MAP_GET_MESSAGE_COMPLETE) == 0) {
2260                 BT_DBG("BT_MAP_GET_MESSAGE_COMPLETE");
2261                 int request_id = 0;
2262
2263                 g_variant_get(parameters, "(ii)", &result, &request_id);
2264                 if (__bt_is_request_id_exist(request_id) == FALSE) {
2265                         BT_ERR("Different request id!");
2266                         return;
2267                 }
2268
2269                 // currently there is no result value passed from here, just passing NULL
2270                 void* some_result_value = NULL;
2271                 _bt_common_event_cb(BLUETOOTH_EVENT_MAP_GET_MESSAGE_COMPLETE,
2272                                 result, some_result_value, event_info->cb, event_info->user_data);
2273
2274                 __bt_remove_push_request_id(request_id);
2275         } else if (strcasecmp(signal_name, BT_MAP_PUSH_MESSAGE_COMPLETE) == 0) {
2276                 BT_DBG("BT_MAP_PUSH_MESSAGE_COMPLETE");
2277                 int request_id = 0;
2278
2279                 g_variant_get(parameters, "(ii)", &result, &request_id);
2280                 if (__bt_is_request_id_exist(request_id) == FALSE) {
2281                         BT_ERR("Different request id!");
2282                         return;
2283                 }
2284
2285                 // currently there is no result value passed from here, just passing NULL
2286                 void* some_result_value = NULL;
2287                 _bt_common_event_cb(BLUETOOTH_EVENT_MAP_PUSH_MESSAGE_COMPLETE,
2288                                 result, some_result_value, event_info->cb, event_info->user_data);
2289
2290                 __bt_remove_push_request_id(request_id);
2291         }
2292
2293 }
2294
2295 void __bt_pbap_client_event_filter(GDBusConnection *connection,
2296                                                  const gchar *sender_name,
2297                                                  const gchar *object_path,
2298                                                  const gchar *interface_name,
2299                                                  const gchar *signal_name,
2300                                                  GVariant *parameters,
2301                                                  gpointer user_data)
2302 {
2303         bt_event_info_t *event_info;
2304         int result = BLUETOOTH_ERROR_NONE;
2305         event_info = (bt_event_info_t *)user_data;
2306
2307         ret_if(event_info == NULL);
2308
2309         if (strcasecmp(object_path, BT_PBAP_CLIENT_PATH) != 0)
2310                 return;
2311
2312         if (strcasecmp(interface_name, BT_EVENT_SERVICE) != 0)
2313                 return;
2314
2315         ret_if(signal_name == NULL);
2316
2317         BT_DBG("Type: %s", g_variant_get_type_string(parameters));
2318
2319         if (strcasecmp(signal_name, BT_PBAP_CONNECTED) == 0) {
2320                 bt_pbap_connected_t connected = { { { 0 }, }, };
2321                 char *address = NULL;
2322
2323                 g_variant_get(parameters, "(i&s)", &result, &address);
2324                 BT_DBG("address: %s", address);
2325
2326                 _bt_convert_addr_string_to_type(connected.btaddr.addr,
2327                                                 address);
2328                 if (result == 0)
2329                         connected.connected = 1;
2330                 else
2331                         connected.connected = 0;
2332
2333                 _bt_common_event_cb(BLUETOOTH_PBAP_CONNECTED,
2334                                 result, &connected,
2335                                 event_info->cb, event_info->user_data);
2336         } else if (strcasecmp(signal_name, BT_PBAP_DISCONNECTED) == 0) {
2337                 bt_pbap_connected_t disconnected = { { { 0 }, }, };
2338                 char *address = NULL;
2339
2340                 g_variant_get(parameters, "(i&s)", &result, &address);
2341                 BT_DBG("address: %s", address);
2342
2343                 _bt_convert_addr_string_to_type(disconnected.btaddr.addr,
2344                                                 address);
2345                 disconnected.connected = 0;
2346
2347                 _bt_common_event_cb(BLUETOOTH_PBAP_DISCONNECTED,
2348                                 result, &disconnected,
2349                                 event_info->cb, event_info->user_data);
2350         } else if (strcasecmp(signal_name, BT_PBAP_PHONEBOOK_SIZE) == 0) {
2351                 bt_pbap_phonebook_size_t pb_size = { { { 0 }, }, };
2352                 char *address = NULL;
2353                 int size = 0;
2354
2355                 g_variant_get(parameters, "(i&si)", &result, &address, &size);
2356
2357                 BT_DBG("address: %s, size: %d", address, size);
2358
2359                 _bt_convert_addr_string_to_type(pb_size.btaddr.addr,
2360                                                 address);
2361                 pb_size.size = size;
2362
2363                 _bt_common_event_cb(BLUETOOTH_PBAP_PHONEBOOK_SIZE,
2364                                 result, &pb_size,
2365                                 event_info->cb, event_info->user_data);
2366         } else if (strcasecmp(signal_name, BT_PBAP_PHONEBOOK_PULL) == 0) {
2367                 bt_pbap_phonebook_pull_t pb_pull = { { { 0 } }, };
2368                 char *address = NULL;
2369                 char *vcf_file = NULL;
2370                 int success = -1;
2371
2372                 g_variant_get(parameters, "(i&s&si)", &result, &address, &vcf_file, &success);
2373
2374                 BT_DBG("address: %s, vcf_file: %s, success: %d",
2375                                                 address, vcf_file, success);
2376
2377                 _bt_convert_addr_string_to_type(pb_pull.btaddr.addr,
2378                                                 address);
2379                 pb_pull.vcf_file = vcf_file;
2380                 pb_pull.success = success;
2381                 _bt_common_event_cb(BLUETOOTH_PBAP_PHONEBOOK_PULL,
2382                                 result, &pb_pull,
2383                                 event_info->cb, event_info->user_data);
2384         } else if (strcasecmp(signal_name, BT_PBAP_VCARD_LIST) == 0) {
2385                 bt_pbap_vcard_list_t vc_list = { { { 0 } }, };
2386                 char *address = NULL;
2387                 gsize count = 0;
2388                 gchar **list = NULL;
2389                 GVariant *string_var;
2390                 int success = -1;
2391                 int i = 0;
2392
2393                 g_variant_get(parameters, "(i&sv)", &result, &address, &string_var);
2394
2395                 list = (gchar **)g_variant_get_strv(string_var, &count);
2396
2397                 success = !result;
2398
2399                 for (i = 0; i < count; i++)
2400                         BT_DBG("%s", list[i]);
2401
2402                 BT_DBG("address: %s, result: %d, count: %d, success: %d",
2403                                         address, result, count, success);
2404
2405                 _bt_convert_addr_string_to_type(vc_list.btaddr.addr,
2406                                                 address);
2407                 vc_list.vcards = list;
2408                 vc_list.length = count;
2409                 vc_list.success = success;
2410                 _bt_common_event_cb(BLUETOOTH_PBAP_VCARD_LIST,
2411                                 result, &vc_list,
2412                                 event_info->cb, event_info->user_data);
2413
2414                 g_variant_unref(string_var);
2415                 //free lists
2416         } else if (strcasecmp(signal_name, BT_PBAP_VCARD_PULL) == 0) {
2417                 bt_pbap_vcard_pull_t vc_pull = { { { 0 } }, };
2418                 char *address = NULL;
2419                 char *vcf_file = NULL;
2420                 int success = -1;
2421
2422                 g_variant_get(parameters, "(i&s&si)",
2423                                         &result, &address, &vcf_file, &success);
2424
2425                 BT_DBG("address: %s, vcf_file: %s, success: %d",
2426                                                 address, vcf_file, success);
2427
2428                 _bt_convert_addr_string_to_type(vc_pull.btaddr.addr, address);
2429                 vc_pull.vcf_file = vcf_file;
2430                 vc_pull.success = success;
2431                 _bt_common_event_cb(BLUETOOTH_PBAP_VCARD_PULL,
2432                                 result, &vc_pull,
2433                                 event_info->cb, event_info->user_data);
2434         } else if (strcasecmp(signal_name, BT_PBAP_SEARCH_PHONEBOOK) == 0) {
2435                 bt_pbap_phonebook_search_list_t vc_list = { { { 0 } }, };
2436                 char *address = NULL;
2437                 gsize count = 0;
2438                 gchar **list = NULL;
2439                 GVariant *string_var;
2440                 int success = -1;
2441                 int i = 0;
2442
2443                 g_variant_get(parameters, "(i&s@as)", &result, &address, &string_var);
2444
2445                 list = (gchar **)g_variant_get_strv(string_var, &count);
2446                 success = !result;
2447                 for (i = 0; i < count; i++)
2448                         BT_DBG("%s", list[i]);
2449
2450                 BT_DBG("address: %s success: %d", address, success);
2451
2452                 _bt_convert_addr_string_to_type(vc_list.btaddr.addr, address);
2453                 vc_list.vcards = list;
2454                 vc_list.length = count;
2455                 vc_list.success = success;
2456                 _bt_common_event_cb(BLUETOOTH_PBAP_PHONEBOOK_SEARCH,
2457                                 result, &vc_list,
2458                                 event_info->cb, event_info->user_data);
2459
2460                 g_variant_unref(string_var);
2461                 //free lists
2462         }
2463 }
2464
2465 void __bt_rfcomm_client_event_filter(GDBusConnection *connection,
2466                                                  const gchar *sender_name,
2467                                                  const gchar *object_path,
2468                                                  const gchar *interface_name,
2469                                                  const gchar *signal_name,
2470                                                  GVariant *parameters,
2471                                                  gpointer user_data)
2472 {
2473         bt_event_info_t *event_info;
2474         int result = BLUETOOTH_ERROR_NONE;
2475         event_info = (bt_event_info_t *)user_data;
2476         ret_if(event_info == NULL);
2477
2478         if (strcasecmp(object_path, BT_RFCOMM_CLIENT_PATH) != 0)
2479                 return;
2480         if (strcasecmp(interface_name, BT_EVENT_SERVICE) != 0)
2481                 return;
2482
2483         ret_if(signal_name == NULL);
2484
2485         if (strcasecmp(signal_name, BT_RFCOMM_CONNECTED) == 0) {
2486                 const char *address = NULL;
2487                 const char *uuid = NULL;
2488                 int socket_fd = 0;
2489                 bluetooth_rfcomm_connection_t conn_info;
2490
2491                 g_variant_get(parameters, "(i&s&sn)", &result, &address,
2492                                                         &uuid, &socket_fd);
2493
2494                 memset(&conn_info, 0x00, sizeof(bluetooth_rfcomm_connection_t));
2495                 conn_info.device_role = RFCOMM_ROLE_CLIENT;
2496                 g_strlcpy(conn_info.uuid, uuid, BLUETOOTH_UUID_STRING_MAX);
2497                 conn_info.socket_fd = socket_fd;
2498                 _bt_convert_addr_string_to_type(conn_info.device_addr.addr,
2499                                                 address);
2500
2501                 _bt_common_event_cb(BLUETOOTH_EVENT_RFCOMM_CONNECTED,
2502                                 result, &conn_info,
2503                                 event_info->cb, event_info->user_data);
2504         } else if (strcasecmp(signal_name, BT_RFCOMM_DISCONNECTED) == 0) {
2505                 const char *address = NULL;
2506                 const char *uuid = NULL;
2507                 int socket_fd = 0;
2508                 bluetooth_rfcomm_disconnection_t disconn_info;
2509
2510                 g_variant_get(parameters, "(i&s&sn)", &result, &address,
2511                                                                 &uuid, &socket_fd);
2512
2513                 memset(&disconn_info, 0x00, sizeof(bluetooth_rfcomm_disconnection_t));
2514                 disconn_info.device_role = RFCOMM_ROLE_CLIENT;
2515                 g_strlcpy(disconn_info.uuid, uuid, BLUETOOTH_UUID_STRING_MAX);
2516                 disconn_info.socket_fd = socket_fd;
2517                 _bt_convert_addr_string_to_type(disconn_info.device_addr.addr,
2518                                                 address);
2519
2520                 _bt_common_event_cb(BLUETOOTH_EVENT_RFCOMM_DISCONNECTED,
2521                                 result, &disconn_info,
2522                                 event_info->cb, event_info->user_data);
2523         } else if (strcasecmp(signal_name, BT_RFCOMM_DATA_RECEIVED) == 0) {
2524                 char *buffer;
2525                 int buffer_len = 0;
2526                 int socket_fd = 0;
2527                 bluetooth_rfcomm_received_data_t data_r;
2528                 GVariant *byte_var;
2529
2530                 g_variant_get(parameters, "(in@ay)", &result, &socket_fd,
2531                                                                 &byte_var);
2532
2533                 buffer_len = g_variant_get_size(byte_var);
2534                 buffer = (char *) g_variant_get_data(byte_var);
2535
2536                 data_r.socket_fd = socket_fd;
2537                 data_r.buffer_size = buffer_len;
2538                 data_r.buffer = buffer;
2539
2540                 _bt_common_event_cb(BLUETOOTH_EVENT_RFCOMM_DATA_RECEIVED,
2541                                 result, &data_r,
2542                                 event_info->cb, event_info->user_data);
2543                 g_variant_unref(byte_var);
2544         }
2545 }
2546
2547 void __bt_rfcomm_server_event_filter(GDBusConnection *connection,
2548                                                  const gchar *sender_name,
2549                                                  const gchar *object_path,
2550                                                  const gchar *interface_name,
2551                                                  const gchar *signal_name,
2552                                                  GVariant *parameters,
2553                                                  gpointer user_data)
2554 {
2555         bt_event_info_t *event_info;
2556         int result = BLUETOOTH_ERROR_NONE;
2557         event_info = (bt_event_info_t *)user_data;
2558         ret_if(event_info == NULL);
2559
2560         if (strcasecmp(object_path, BT_RFCOMM_SERVER_PATH) != 0)
2561                 return;
2562         if (strcasecmp(interface_name, BT_EVENT_SERVICE) != 0)
2563                 return;
2564
2565         ret_if(signal_name == NULL);
2566
2567         if (strcasecmp(signal_name, BT_RFCOMM_CONNECTED) == 0) {
2568                 const char *address = NULL;
2569                 const char *uuid = NULL;
2570                 int socket_fd = 0;
2571                 bluetooth_rfcomm_connection_t conn_info;
2572
2573                 g_variant_get(parameters, "(i&s&sn)", &result, &address,
2574                                                         &uuid, &socket_fd);
2575
2576                 memset(&conn_info, 0x00, sizeof(bluetooth_rfcomm_connection_t));
2577                 conn_info.device_role = RFCOMM_ROLE_SERVER;
2578                 g_strlcpy(conn_info.uuid, uuid, BLUETOOTH_UUID_STRING_MAX);
2579                 conn_info.socket_fd = socket_fd;
2580                 _bt_convert_addr_string_to_type(conn_info.device_addr.addr,
2581                                                 address);
2582
2583                 _bt_common_event_cb(BLUETOOTH_EVENT_RFCOMM_CONNECTED,
2584                                 result, &conn_info,
2585                                 event_info->cb, event_info->user_data);
2586         } else if (strcasecmp(signal_name, BT_RFCOMM_DISCONNECTED) == 0) {
2587                 const char *address = NULL;
2588                 const char *uuid = NULL;
2589                 int socket_fd = 0;
2590                 bluetooth_rfcomm_disconnection_t disconn_info;
2591
2592                 g_variant_get(parameters, "(i&s&sn)", &result, &address,
2593                                                                 &uuid, &socket_fd);
2594
2595                 memset(&disconn_info, 0x00, sizeof(bluetooth_rfcomm_disconnection_t));
2596                 disconn_info.device_role = RFCOMM_ROLE_SERVER;
2597                 g_strlcpy(disconn_info.uuid, uuid, BLUETOOTH_UUID_STRING_MAX);
2598                 disconn_info.socket_fd = socket_fd;
2599                 _bt_convert_addr_string_to_type(disconn_info.device_addr.addr,
2600                                                 address);
2601
2602                 _bt_common_event_cb(BLUETOOTH_EVENT_RFCOMM_DISCONNECTED,
2603                                 result, &disconn_info,
2604                                 event_info->cb, event_info->user_data);
2605         } else if (strcasecmp(signal_name, BT_CONNECTION_AUTHORIZED) == 0) {
2606                 /* OSP only event */
2607                 bluetooth_rfcomm_connection_request_t req_ind;
2608                 char *address = NULL;
2609                 char *uuid = NULL;
2610                 char *name = NULL;
2611                 char *path = NULL;
2612                 int socket_fd = 0;
2613
2614                 g_variant_get(parameters, "(i&s&s&s&sn)", &result, &address,
2615                                                 &uuid, &name, &path, &socket_fd);
2616
2617                 if (_check_uuid_path(path, uuid) == FALSE)
2618                         return;
2619
2620                 memset(&req_ind, 0x00, sizeof(bluetooth_rfcomm_connection_request_t));
2621                 _bt_convert_addr_string_to_type(req_ind.device_addr.addr,
2622                                                 address);
2623
2624                 req_ind.socket_fd = socket_fd;
2625
2626                 _bt_common_event_cb(BLUETOOTH_EVENT_RFCOMM_AUTHORIZE,
2627                                 result, &req_ind,
2628                                 event_info->cb, event_info->user_data);
2629         } else if (strcasecmp(signal_name, BT_RFCOMM_SERVER_REMOVED) == 0) {
2630                 /* OSP only event */
2631                 int socket_fd = 0;
2632
2633                 g_variant_get(parameters, "(in)", &result, &socket_fd);
2634
2635                 ret_if(__bt_is_server_exist(socket_fd) == FALSE);
2636
2637                 _bt_remove_server(socket_fd);
2638         } else if (strcasecmp(signal_name, BT_RFCOMM_DATA_RECEIVED) == 0) {
2639                 char *buffer = NULL;
2640                 int buffer_len = 0;
2641                 int socket_fd = 0;
2642                 bluetooth_rfcomm_received_data_t data_r;
2643                 GVariant *byte_var;
2644
2645                 g_variant_get(parameters, "(in@ay)", &result,
2646                                                 &socket_fd, &byte_var);
2647
2648                 buffer_len = g_variant_get_size(byte_var);
2649                 buffer = (char *) g_variant_get_data(byte_var);
2650
2651                 data_r.socket_fd = socket_fd;
2652                 data_r.buffer_size = buffer_len;
2653                 data_r.buffer = buffer;
2654
2655                 _bt_common_event_cb(BLUETOOTH_EVENT_RFCOMM_DATA_RECEIVED,
2656                                 result, &data_r,
2657                                 event_info->cb, event_info->user_data);
2658                 g_variant_unref(byte_var);
2659         }
2660 }
2661
2662 void __bt_hf_agent_event_filter(GDBusConnection *connection,
2663                                                  const gchar *sender_name,
2664                                                  const gchar *object_path,
2665                                                  const gchar *interface_name,
2666                                                  const gchar *signal_name,
2667                                                  GVariant *parameters,
2668                                                  gpointer user_data)
2669 {
2670         BT_DBG("+\n");
2671
2672         bt_event_info_t *event_info;
2673         int result = BLUETOOTH_ERROR_NONE;
2674         event_info = (bt_event_info_t *)user_data;
2675         ret_if(event_info == NULL);
2676
2677         BT_DBG("+\n");
2678         if (strcasecmp(object_path, BT_HF_AGENT_PATH) != 0)
2679                 return;
2680         if (strcasecmp(interface_name, BT_HF_SERVICE_INTERFACE) != 0)
2681                 return;
2682
2683         ret_if(signal_name == NULL);
2684
2685         BT_DBG("%s", signal_name);
2686         if (strcasecmp(signal_name, "Connected") == 0) {
2687                 char *address = NULL;
2688
2689                 g_variant_get(parameters, "(s)", &address);
2690                 _bt_hf_event_cb(BLUETOOTH_EVENT_HF_CONNECTED,
2691                                 result, address,
2692                                 event_info->cb, event_info->user_data);
2693         } else if (strcasecmp(signal_name, "Disconnected") == 0) {
2694                 char *address = NULL;
2695
2696                 g_variant_get(parameters, "(s)", &address);
2697                 _bt_hf_event_cb(BLUETOOTH_EVENT_HF_DISCONNECTED,
2698                                 result, address,
2699                                 event_info->cb, event_info->user_data);
2700         } else if (strcasecmp(signal_name, "AudioConnected") == 0) {
2701                 _bt_hf_event_cb(BLUETOOTH_EVENT_HF_AUDIO_CONNECTED,
2702                                 result, NULL,
2703                                 event_info->cb, event_info->user_data);
2704         } else if (strcasecmp(signal_name, "AudioDisconnected") == 0) {
2705                 _bt_hf_event_cb(BLUETOOTH_EVENT_HF_AUDIO_DISCONNECTED,
2706                                 result, NULL,
2707                                 event_info->cb, event_info->user_data);
2708         } else if (strcasecmp(signal_name, "Ring") == 0) {
2709                 char *phoneno = NULL;
2710
2711                 g_variant_get(parameters, "(&s)", &phoneno);
2712
2713                 _bt_hf_event_cb(BLUETOOTH_EVENT_HF_RING_INDICATOR,
2714                                 result, phoneno,
2715                                 event_info->cb, event_info->user_data);
2716         } else if (strcasecmp(signal_name, "CallWaiting") == 0) {
2717                 char *phoneno = NULL;
2718
2719                 g_variant_get(parameters, "(&s)", &phoneno);
2720
2721                 _bt_hf_event_cb(BLUETOOTH_EVENT_HF_CALL_WAITING,
2722                                 result, phoneno,
2723                                 event_info->cb, event_info->user_data);
2724         }  else if (strcasecmp(signal_name, "CallTerminated") == 0) {
2725                 _bt_hf_event_cb(BLUETOOTH_EVENT_HF_CALL_TERMINATED,
2726                                 result, NULL,
2727                                 event_info->cb, event_info->user_data);
2728         }  else if (strcasecmp(signal_name, "FailedToDial") == 0) {
2729                 _bt_hf_event_cb(BLUETOOTH_EVENT_HF_CALL_FAILED_TO_DIAL,
2730                                 result, NULL,
2731                                 event_info->cb, event_info->user_data);
2732         } else if (strcasecmp(signal_name, "CallIdle") == 0) {
2733                 _bt_hf_event_cb(BLUETOOTH_EVENT_HF_CALL_IDLE,
2734                                 result, NULL,
2735                                 event_info->cb, event_info->user_data);
2736         } else if (strcasecmp(signal_name, "CallSetupIncoming") == 0) {
2737                 _bt_hf_event_cb(BLUETOOTH_EVENT_HF_CALLSETUP_INCOMING,
2738                                 result, NULL,
2739                                 event_info->cb, event_info->user_data);
2740         } else if (strcasecmp(signal_name, "CallSetupDialing") == 0) {
2741                 _bt_hf_event_cb(BLUETOOTH_EVENT_HF_CALLSETUP_DIALING,
2742                                 result, NULL,
2743                                 event_info->cb, event_info->user_data);
2744         } else if (strcasecmp(signal_name, "CallSetupAlerting") == 0) {
2745                 _bt_hf_event_cb(BLUETOOTH_EVENT_HF_CALLSETUP_ALERTING,
2746                                 result, NULL,
2747                                 event_info->cb, event_info->user_data);
2748         } else if (strcasecmp(signal_name, "CallStarted") == 0) {
2749                 _bt_hf_event_cb(BLUETOOTH_EVENT_HF_CALL_STARTED,
2750                                 result, NULL,
2751                                 event_info->cb, event_info->user_data);
2752         } else if (strcasecmp(signal_name, "CallEnded") == 0) {
2753                 _bt_hf_event_cb(BLUETOOTH_EVENT_HF_CALL_ENDED,
2754                                 result, NULL,
2755                                 event_info->cb, event_info->user_data);
2756         }  else if (strcasecmp(signal_name, "NoCallsHeld") == 0) {
2757                 _bt_hf_event_cb(BLUETOOTH_EVENT_HF_CALL_UNHOLD,
2758                                 result, NULL,
2759                                 event_info->cb, event_info->user_data);
2760         } else if (strcasecmp(signal_name, "CallsSwapped") == 0) {
2761                 _bt_hf_event_cb(BLUETOOTH_EVENT_HF_CALL_SWAPPED,
2762                                 result, NULL,
2763                                 event_info->cb, event_info->user_data);
2764         } else if (strcasecmp(signal_name, "CallOnHold") == 0) {
2765                 _bt_hf_event_cb(BLUETOOTH_EVENT_HF_CALL_ON_HOLD,
2766                                 result, NULL,
2767                                 event_info->cb, event_info->user_data);
2768         } else if (strcasecmp(signal_name, "CallStatusUpdate") == 0) {
2769                 int call_count;
2770                 GVariant *var_data = NULL;
2771                 char *number = NULL;
2772                 int idx, dir, status, mpart;
2773                 bt_hf_call_list_s *handle = NULL;
2774
2775                 g_variant_get(parameters, "(i@a(siiii))", &call_count,
2776                                                                 &var_data);
2777                 BT_DBG("call count : %d", call_count);
2778
2779                 if (var_data) {
2780                         GVariantIter *iter = NULL;
2781                         __bt_call_list_create(&handle);
2782
2783                         g_variant_get(var_data, "a(siiii)", &iter);
2784                         while (g_variant_iter_loop(iter, "(siiii)", &number,
2785                                                 &dir, &status, &mpart, &idx)) {
2786                                 BT_DBG("call number:%s, dir:%d, status : %d",
2787                                                         number, dir, status);
2788                                 BT_DBG("call mpart : %d, idx : %d", mpart, idx);
2789                                 __bt_call_list_add(handle, number, dir,
2790                                                         status, mpart, idx);
2791                         }
2792                         g_variant_iter_free(iter);
2793                         g_variant_unref(var_data);
2794                 }
2795
2796                 if (handle && (call_count == g_list_length(handle->list))) {
2797                         handle->count = call_count;
2798                         _bt_hf_event_cb(BLUETOOTH_EVENT_HF_CALL_STATUS,
2799                                         result, handle,
2800                                         event_info->cb, event_info->user_data);
2801                 } else {
2802                         BT_ERR(" Mismatch in call count : %d", call_count);
2803                 }
2804
2805                 __bt_call_list_destroy(handle);
2806         } else if (strcasecmp(signal_name, "VoiceRecognition") == 0) {
2807                 int status;
2808                 g_variant_get(parameters, "(i)", &status);
2809                 BT_DBG("status = [%d]\n", status);
2810                 if (status)
2811                         _bt_hf_event_cb(BLUETOOTH_EVENT_HF_VOICE_RECOGNITION_ENABLED,
2812                                         result, NULL,
2813                                         event_info->cb, event_info->user_data);
2814                 else
2815                         _bt_hf_event_cb(BLUETOOTH_EVENT_HF_VOICE_RECOGNITION_DISABLED,
2816                                         result, NULL,
2817                                         event_info->cb, event_info->user_data);
2818         } else if (strcasecmp(signal_name, "VolumeSpeaker") == 0) {
2819                 int value;
2820                 g_variant_get(parameters, "(i)", &value);
2821                 BT_DBG("Value = [%d]\n", value);
2822                         _bt_hf_event_cb(BLUETOOTH_EVENT_HF_VOLUME_SPEAKER,
2823                                         result, &value,
2824                                         event_info->cb, event_info->user_data);
2825         } else if (strcasecmp(signal_name, "SamsungXSAT") == 0) {
2826                 int value = 0;
2827                 char *msg = NULL;
2828                 bluetooth_vendor_dep_at_cmd_t cmd;
2829                 g_variant_get(parameters, "(i&s)", &value, &msg);
2830                 BT_DBG("Value = [%d], message = %s\n", value, msg);
2831                 cmd.app_id =  value;
2832                 cmd.message = msg;
2833                 _bt_hf_event_cb(BLUETOOTH_EVENT_HF_VENDOR_DEP_CMD,
2834                                 result, &cmd,
2835                                 event_info->cb, event_info->user_data);
2836         } else if (strcasecmp(signal_name, "PropertyChanged") == 0) {
2837                 GVariant *value;
2838                 gchar *property;
2839                 bluetooth_hf_ciev_device_event_t dev_event;
2840
2841                 g_variant_get(parameters, "(&sv)", &property, &value);
2842                 dev_event.value  = g_variant_get_uint16(value);
2843
2844                 BT_DBG("Property: %s , value: %d", property, dev_event.value);
2845                 g_variant_unref(value);
2846
2847                 if (strcasecmp(property, "BatteryCharge") == 0) {
2848                         dev_event.event = BLUETOOTH_HF_CIEV_BATTCHG;
2849                         _bt_hf_event_cb(BLUETOOTH_EVENT_HF_CIEV_DEVICE_STATUS_CHANGED,
2850                                         result, &dev_event,
2851                                         event_info->cb, event_info->user_data);
2852                 } else if (strcasecmp(property, "SignalStrength") == 0) {
2853                         dev_event.event = BLUETOOTH_HF_CIEV_SIGNAL;
2854                         _bt_hf_event_cb(BLUETOOTH_EVENT_HF_CIEV_DEVICE_STATUS_CHANGED,
2855                                         result, &dev_event,
2856                                         event_info->cb, event_info->user_data);
2857                 } else if (strcasecmp(property, "RegistrationStatus") == 0) {
2858                         dev_event.event = BLUETOOTH_HF_CIEV_SERVICE;
2859                         _bt_hf_event_cb(BLUETOOTH_EVENT_HF_CIEV_DEVICE_STATUS_CHANGED,
2860                                         result, &dev_event,
2861                                         event_info->cb, event_info->user_data);
2862                 }
2863         }
2864         BT_DBG("-\n");
2865 }
2866
2867 static void __bt_tds_event_filter(GDBusConnection *connection,
2868                 const gchar *sender_name,
2869                 const gchar *object_path,
2870                 const gchar *interface_name,
2871                 const gchar *signal_name,
2872                 GVariant *parameters,
2873                 gpointer user_data)
2874 {
2875         bt_event_info_t *event_info;
2876         event_info = (bt_event_info_t *)user_data;
2877         int result = BLUETOOTH_ERROR_NONE;
2878
2879         ret_if(event_info == NULL);
2880
2881         if (strcasecmp(object_path, BT_TDS_PATH) != 0)
2882                 return;
2883         if (strcasecmp(interface_name, BT_EVENT_SERVICE) != 0)
2884                 return;
2885
2886         ret_if(signal_name == NULL);
2887
2888         BT_DBG("+");
2889
2890         if (strcasecmp(signal_name, BT_TDS_ACTIVATION_REQUESTED) == 0) {
2891                 bluetooth_tds_activation_req_t act_req;
2892                 const char *address = NULL;
2893                 char *buffer = NULL;
2894                 int transport = 0;
2895                 GVariant *byte_var;
2896
2897                 g_variant_get(parameters, "(&si@ay)", &address,
2898                                 &transport, &byte_var);
2899
2900                 memset(&act_req, 0x00, sizeof(bluetooth_tds_activation_req_t));
2901
2902                 act_req.transport = transport;
2903
2904                 act_req.tds_data.length = g_variant_get_size(byte_var);
2905                 if (act_req.tds_data.length > BLUETOOTH_TDS_DATA_LENGTH_MAX) {
2906                         BT_INFO("tds data length > BLUETOOTH_TDS_DATA_LENGTH_MAX");
2907                         act_req.tds_data.length = BLUETOOTH_TDS_DATA_LENGTH_MAX;
2908                 }
2909                 buffer = (char *) g_variant_get_data(byte_var);
2910                 memcpy(act_req.tds_data.data, buffer, act_req.tds_data.length);
2911
2912                 _bt_convert_addr_string_to_type(act_req.rem_addr.addr, address);
2913
2914                 _bt_common_event_cb(BLUETOOTH_EVENT_TDS_ACTIVATION_REQUESTED,
2915                                 BLUETOOTH_ERROR_NONE, &act_req,
2916                                 event_info->cb, event_info->user_data);
2917         } else if (strcasecmp(signal_name, BT_TDS_TRANSPORT_DATA_RECEIVED) == 0) {
2918                 BT_DBG("TDS Complete Block Data received");
2919                 const char *address = NULL;
2920                 char *data;
2921                 int data_len = 0;
2922                 int k;
2923                 GVariant *var = NULL;
2924                 bluetooth_tds_transport_data_info_t *info = NULL;
2925
2926                 /* Extract data from DBUS params */
2927                 g_variant_get(parameters, "(i&sn@ay)", &result, &address, &data_len, &var);
2928                 data = (char *)g_variant_get_data(var);
2929
2930                 BT_DBG("Address [%s]", address);
2931                 BT_DBG("Data len [%d]", data_len);
2932
2933                 /* DEBUG */
2934                 for (k = 0; k < data_len ; k++)
2935                         BT_DBG("Data[%d] [0x%x]", k, data[k]);
2936
2937                 if (data_len == 0) {
2938                         BT_ERR("No data");
2939                         g_variant_unref(var);
2940                         return;
2941                 }
2942
2943                 info = g_malloc0(sizeof(bluetooth_tds_transport_data_info_t));
2944                 info->data_length = data_len;
2945                 info->data = g_memdup(data, data_len);
2946
2947                 _bt_convert_addr_string_to_type(info->device_address.addr,
2948                                 address);
2949
2950                 _bt_common_event_cb(BLUETOOTH_EVENT_TDS_TRANSPORT_DATA_RECEIVED,
2951                                 result, info,
2952                                 event_info->cb, event_info->user_data);
2953
2954                 if (info->data) {
2955                         g_free(info->data);
2956                         g_free(info);
2957                 }
2958
2959                 g_variant_unref(var);
2960         } else if (strcasecmp(signal_name, BT_TDS_ACTIVATION_RESULT) == 0) {
2961                 BT_DBG("TDS Control point Activation result");
2962                 const char *address = NULL;
2963                 bluetooth_device_address_t dev_address = { {0} };
2964
2965                 /* Extract data from DBUS params */
2966                 g_variant_get(parameters, "(i&s)", &result, &address);
2967                 BT_DBG("Address [%s]", address);
2968                 BT_DBG("Result  [%d]", result);
2969
2970                 _bt_convert_addr_string_to_type(dev_address.addr,
2971                                 address);
2972
2973                 _bt_common_event_cb(BLUETOOTH_EVENT_TDS_ACTIVATION_RESULT,
2974                                 result, &dev_address,
2975                                 event_info->cb, event_info->user_data);
2976         } else if (strcasecmp(signal_name, BT_TDS_ACTIVATION_INDICATION) == 0) {
2977                 BT_DBG("TDS Control point Indication Response");
2978                 bluetooth_tds_indication_res_t ind_res;
2979                 const char *address = NULL;
2980                 char *buffer = NULL;
2981                 GVariant *byte_var = NULL;
2982
2983                 g_variant_get(parameters, "(&s@ay)", &address, &byte_var);
2984
2985                 memset(&ind_res, 0x00, sizeof(bluetooth_tds_indication_res_t));
2986
2987                 ind_res.tds_data.length = g_variant_get_size(byte_var);
2988
2989                 buffer = (char *) g_variant_get_data(byte_var);
2990                 memcpy(ind_res.tds_data.data, buffer, ind_res.tds_data.length);
2991
2992                 _bt_convert_addr_string_to_type(ind_res.rem_addr.addr, address);
2993
2994                 _bt_common_event_cb(BLUETOOTH_EVENT_TDS_ACTIVATION_INDICATION,
2995                                 BLUETOOTH_ERROR_NONE,  &ind_res,
2996                                 event_info->cb, event_info->user_data);
2997
2998                 g_variant_unref(byte_var);
2999         } else if (strcasecmp(signal_name, BT_TDS_CONTROL_POINT_ENABLED) == 0) {
3000                 BT_DBG("TDS Control point Enabled event");
3001                 const char *address = NULL;
3002                 bluetooth_device_address_t dev_address = { {0} };
3003
3004                 /* Extract data from DBUS params */
3005                 g_variant_get(parameters, "(i&s)", &result, &address);
3006                 BT_DBG("Address [%s]", address);
3007                 BT_DBG("Result  [%d]", result);
3008
3009                 _bt_convert_addr_string_to_type(dev_address.addr,
3010                                 address);
3011
3012                 _bt_common_event_cb(BLUETOOTH_EVENT_TDS_CONTROL_POINT_ENABLED,
3013                                 result, &dev_address,
3014                                 event_info->cb, event_info->user_data);
3015         }
3016
3017         BT_DBG("-");
3018 }
3019
3020 static void __bt_otp_event_filter(GDBusConnection *connection,
3021                 const gchar *sender_name,
3022                 const gchar *object_path,
3023                 const gchar *interface_name,
3024                 const gchar *signal_name,
3025                 GVariant *parameters,
3026                 gpointer user_data)
3027 {
3028         bt_event_info_t *event_info;
3029         event_info = (bt_event_info_t *)user_data;
3030         int result = BLUETOOTH_ERROR_NONE;
3031
3032         ret_if(event_info == NULL);
3033
3034         if (strcasecmp(object_path, BT_OTP_PATH) != 0)
3035                 return;
3036         if (strcasecmp(interface_name, BT_EVENT_SERVICE) != 0)
3037                 return;
3038
3039         ret_if(signal_name == NULL);
3040
3041         BT_DBG("+");
3042
3043         if (strcasecmp(signal_name, BT_OTP_SERVER_STATE_CHANGED) == 0) {
3044                 BT_DBG("OTP Server State Changed Event");
3045                 bool status = FALSE;
3046
3047                 /* Extract data from DBUS params */
3048                 g_variant_get(parameters, "(ib)", &result, &status);
3049                 BT_DBG("Result [%d]", result);
3050                 BT_DBG("Status  [%s]", status ? "enabled" : "disabled");
3051
3052                 _bt_common_event_cb(BLUETOOTH_EVENT_OTP_SERVER_STATE_CHANGED,
3053                                 result, &status, event_info->cb, event_info->user_data);
3054         } else if (strcasecmp(signal_name, BT_OTP_READ_CHAR_VAL) == 0) {
3055                 BT_DBG("OTP Read Data received");
3056                 const char *handle = NULL;
3057                 char *data;
3058                 int data_len = 0;
3059                 GVariant *var = NULL;
3060                 bluetooth_otp_resp_info_t *info = NULL;
3061
3062                 /* Extract data from DBUS params */
3063                 g_variant_get(parameters, "(i&sn@ay)", &result, &handle, &data_len, &var);
3064                 data = (char *)g_variant_get_data(var);
3065
3066                 BT_DBG("Handle [%s]", handle);
3067                 BT_DBG("Data len [%d]", data_len);
3068
3069                 if (data_len == 0) {
3070                         BT_ERR("No data");
3071                         if (var)
3072                                 g_variant_unref(var);
3073                         return;
3074                 }
3075
3076                 info = g_malloc0(sizeof(bluetooth_otp_resp_info_t));
3077                 info->data_length = data_len;
3078                 info->data = g_memdup(data, data_len);
3079                 info->handle = g_strdup(handle);
3080
3081                 _bt_common_event_cb(BLUETOOTH_EVENT_OTP_READ_CHAR_VAL,
3082                                 result, info,
3083                                 event_info->cb, event_info->user_data);
3084
3085                 if (info->handle) {
3086                         g_free(info->handle);
3087                 }
3088
3089                 if (info->data) {
3090                         g_free(info->data);
3091                         g_free(info);
3092                 }
3093                 if (var)
3094                         g_variant_unref(var);
3095         } else if (strcasecmp(signal_name, BT_OTP_NOTIFICATION_ENABLED) == 0) {
3096                 BT_DBG("OTP Notification Enabled event");
3097                 char *handle = NULL;
3098
3099                 /* Extract data from DBUS params */
3100                 g_variant_get(parameters, "(i&s)", &result, &handle);
3101                 BT_DBG("Handle [%s]", handle);
3102                 BT_DBG("Result  [%d]", result);
3103
3104                 _bt_common_event_cb(BLUETOOTH_EVENT_OTP_NOTIFICATION_ENABLED,
3105                                 result, handle,
3106                                 event_info->cb, event_info->user_data);
3107         }
3108
3109         BT_DBG("-");
3110 }
3111
3112 static void __bt_remove_all_events(void)
3113 {
3114         bt_event_info_t *info;
3115
3116         while ((info = g_slist_nth_data(event_list, 0)) != NULL)
3117                 _bt_unregister_event(info->event_type);
3118
3119         if (event_list) {
3120                 g_slist_free(event_list);
3121                 event_list = NULL;
3122         }
3123 }
3124
3125 static gboolean __bt_event_is_registered(int event_type)
3126 {
3127         GSList *l;
3128         bt_event_info_t *info;
3129
3130         for (l = event_list; l != NULL; l = g_slist_next(l)) {
3131                 info = l->data;
3132                 if (info == NULL)
3133                         continue;
3134
3135                 if (info->event_type == event_type)
3136                         return TRUE;
3137         }
3138
3139         return FALSE;
3140 }
3141
3142 bt_event_info_t *_bt_event_get_cb_data(int event_type)
3143 {
3144         GSList *l;
3145         bt_event_info_t *info;
3146
3147         for (l = event_list; l != NULL; l = g_slist_next(l)) {
3148                 info = l->data;
3149                 if (info == NULL)
3150                         continue;
3151
3152                 if (info->event_type == event_type)
3153                         return info;
3154         }
3155
3156         return NULL;
3157 }
3158
3159 void _bt_add_server(int server_fd)
3160 {
3161         bt_server_info_t *info;
3162
3163         info = g_new0(bt_server_info_t, 1);
3164         info->server_fd = server_fd;
3165
3166         server_list = g_slist_append(server_list, info);
3167 }
3168
3169 void _bt_remove_server(int server_fd)
3170 {
3171         GSList *l;
3172         bt_server_info_t *info;
3173
3174         for (l = server_list; l != NULL; l = g_slist_next(l)) {
3175                 info = l->data;
3176                 if (info == NULL)
3177                         continue;
3178
3179                 if (info->server_fd == server_fd)
3180                         server_list = g_slist_remove(server_list, (void *)info);
3181
3182                 g_free(info);
3183         }
3184 }
3185
3186 void _bt_set_obex_server_id(int server_type)
3187 {
3188         obex_server_id = server_type;
3189 }
3190
3191 int _bt_get_obex_server_id(void)
3192 {
3193         return obex_server_id;
3194 }
3195
3196 int _bt_init_event_handler(void)
3197 {
3198         if (is_initialized == TRUE) {
3199                 BT_ERR("Connection already exist");
3200                 return BLUETOOTH_ERROR_ALREADY_INITIALIZED;
3201         }
3202
3203         __bt_remove_all_events();
3204
3205         is_initialized = TRUE;
3206
3207         return BLUETOOTH_ERROR_NONE;
3208 }
3209
3210 int _bt_deinit_event_handler(void)
3211 {
3212         if (is_initialized == FALSE) {
3213                 BT_ERR("Connection dose not exist");
3214                 return BLUETOOTH_ERROR_INTERNAL;
3215         }
3216
3217         __bt_remove_all_events();
3218
3219         if (disable_timer_id > 0) {
3220                 g_source_remove(disable_timer_id);
3221                 disable_timer_id = 0;
3222         }
3223
3224         is_initialized = FALSE;
3225
3226         return BLUETOOTH_ERROR_NONE;
3227 }
3228
3229 static void __bt_event_data_free(void *data)
3230 {
3231         bt_event_info_t *cb_data = data;
3232
3233         ret_if(cb_data == NULL);
3234
3235         g_free(cb_data);
3236 }
3237
3238 int _bt_register_event(int event_type, void *event_cb, void *user_data)
3239 {
3240         GDBusConnection *connection_type;
3241         GDBusSignalCallback event_func;
3242         bt_event_info_t *cb_data;
3243         const char *path;
3244         const char *interface = BT_EVENT_SERVICE;
3245
3246         if (is_initialized == FALSE)
3247                 _bt_init_event_handler();
3248
3249         if (__bt_event_is_registered(event_type) == TRUE) {
3250                 BT_ERR("The event is already registed");
3251                 return BLUETOOTH_ERROR_ALREADY_INITIALIZED;
3252         }
3253
3254         switch (event_type) {
3255         case BT_ADAPTER_EVENT:
3256                 event_func = __bt_adapter_event_filter;
3257                 path = BT_ADAPTER_PATH;
3258                 break;
3259         case BT_LE_ADAPTER_EVENT:
3260                 event_func = __bt_adapter_le_event_filter;
3261                 path = BT_LE_ADAPTER_PATH;
3262                 break;
3263         case BT_DEVICE_EVENT:
3264                 event_func = __bt_device_event_filter;
3265                 path = BT_DEVICE_PATH;
3266                 break;
3267         case BT_HID_EVENT:
3268                 event_func = __bt_hid_event_filter;
3269                 path = BT_HID_PATH;
3270                 break;
3271         case BT_HEADSET_EVENT:
3272                 event_func = __bt_headset_event_filter;
3273                 path = BT_HEADSET_PATH;
3274                 break;
3275         case BT_NETWORK_EVENT:
3276                 event_func = __bt_network_event_filter;
3277                 path = BT_NETWORK_PATH;
3278                 break;
3279         case BT_AVRCP_EVENT:
3280                 event_func = __bt_avrcp_event_filter;
3281                 path = BT_AVRCP_PATH;
3282                 break;
3283         case BT_AVRCP_CONTROL_EVENT:
3284                 event_func = __bt_avrcp_control_event_filter;
3285                 path = BT_AVRCP_CONTROL_PATH;
3286                 break;
3287         case BT_OPP_CLIENT_EVENT:
3288                 event_func = __bt_opp_client_event_filter;
3289                 path = BT_OPP_CLIENT_PATH;
3290                 break;
3291         case BT_OPP_SERVER_EVENT:
3292                 event_func = __bt_opp_server_event_filter;
3293                 path = BT_OPP_SERVER_PATH;
3294                 break;
3295         case BT_MAP_CLIENT_EVENT:
3296                 event_func = __bt_map_client_event_filter;
3297                 path = BT_MAP_CLIENT_PATH;
3298                 break;
3299         case BT_PBAP_CLIENT_EVENT:
3300                 event_func = __bt_pbap_client_event_filter;
3301                 path = BT_PBAP_CLIENT_PATH;
3302                 break;
3303         case BT_RFCOMM_CLIENT_EVENT:
3304                 event_func = __bt_rfcomm_client_event_filter;
3305                 path = BT_RFCOMM_CLIENT_PATH;
3306                 break;
3307         case BT_RFCOMM_SERVER_EVENT:
3308                 event_func = __bt_rfcomm_server_event_filter;
3309                 path = BT_RFCOMM_SERVER_PATH;
3310                 break;
3311         case BT_HF_AGENT_EVENT:
3312                 BT_DBG("BT_HF_AGENT_EVENT\n");
3313                 event_func = __bt_hf_agent_event_filter;
3314                 path = BT_HF_AGENT_PATH;
3315                 interface = BT_HF_SERVICE_INTERFACE;
3316                 break;
3317         case BT_A2DP_SOURCE_EVENT:
3318                 BT_DBG("BT_A2DP_SOURCE_EVENT");
3319                 event_func = __bt_a2dp_source_event_filter;
3320                 path = BT_A2DP_SOURCE_PATH;
3321                 break;
3322         case BT_HID_DEVICE_EVENT:
3323                 BT_DBG("BT_HID_DEVICE_EVENT");
3324                 event_func = __bt_hid_device_event_filter;
3325                 path = BT_HID_DEVICE_PATH;
3326                 break;
3327         case BT_GATT_BLUEZ_EVENT:
3328                 BT_DBG("BT_GATT_BLUEZ_EVENT");
3329                 event_func = __bt_device_event_filter;
3330                 interface = BT_GATT_CHARACTERISTIC_INTERFACE;
3331                 path = NULL;
3332                 break;
3333         case BT_TDS_EVENT:
3334                 BT_DBG("BT_TDS_EVENT");
3335                 event_func = __bt_tds_event_filter;
3336                 path = BT_TDS_PATH;
3337                 break;
3338         case BT_OTP_EVENT:
3339                 BT_DBG("BT_OTP_EVENT");
3340                 event_func = __bt_otp_event_filter;
3341                 path = BT_OTP_PATH;
3342                 break;
3343         default:
3344                 BT_ERR("Unknown event");
3345                 return BLUETOOTH_ERROR_INTERNAL;
3346         }
3347
3348         connection_type = _bt_gdbus_get_system_gconn();
3349         if (connection_type == NULL)
3350                 return BLUETOOTH_ERROR_INTERNAL;
3351
3352         cb_data = g_new0(bt_event_info_t, 1);
3353
3354         cb_data->event_type = event_type;
3355         cb_data->cb = event_cb;
3356         cb_data->user_data = user_data;
3357
3358         cb_data->id = g_dbus_connection_signal_subscribe(connection_type,
3359                                 NULL, interface, NULL, path, NULL, 0,
3360                                 event_func, cb_data, NULL);
3361
3362         event_list = g_slist_append(event_list, cb_data);
3363
3364         return BLUETOOTH_ERROR_NONE;
3365 }
3366
3367 int _bt_unregister_event(int event_type)
3368 {
3369         GDBusConnection *connection_type;
3370         bt_event_info_t *cb_data;
3371
3372         if (is_initialized == FALSE) {
3373                 BT_ERR("Event is not registered");
3374                 return BLUETOOTH_ERROR_NOT_INITIALIZED;
3375         }
3376
3377         if (__bt_event_is_registered(event_type) == FALSE) {
3378                 BT_ERR("Not registered event");
3379                 return BLUETOOTH_ERROR_INTERNAL;
3380         }
3381
3382         cb_data = _bt_event_get_cb_data(event_type);
3383
3384         if (cb_data == NULL) {
3385                 BT_ERR("No matched event data");
3386                 return BLUETOOTH_ERROR_INTERNAL;
3387         }
3388
3389         connection_type = _bt_gdbus_get_system_gconn();
3390
3391         event_list = g_slist_remove(event_list, (void *)cb_data);
3392
3393         retv_if(connection_type == NULL, BLUETOOTH_ERROR_INTERNAL);
3394
3395         g_dbus_connection_signal_unsubscribe(connection_type, cb_data->id);
3396
3397         __bt_event_data_free((void *)cb_data);
3398
3399         return BLUETOOTH_ERROR_NONE;
3400 }
3401
3402 static void __bt_name_owner_changed(GDBusConnection *connection,
3403                                                  const gchar *sender_name,
3404                                                  const gchar *object_path,
3405                                                  const gchar *interface_name,
3406                                                  const gchar *signal_name,
3407                                                  GVariant *parameters,
3408                                                  gpointer user_data)
3409 {
3410         const char *name = NULL;
3411         const char *old_owner = NULL;
3412         const char *new_owner = NULL;
3413         bt_event_info_t *event_info;
3414
3415         g_variant_get(parameters, "(&s&s&s)", &name, &old_owner, &new_owner);
3416
3417         if (g_strcmp0(name, BT_DBUS_NAME) == 0 &&
3418                         (new_owner != NULL && *new_owner == '\0')) {
3419                 BT_DBG("bt-service is terminated");
3420                 event_info = _bt_event_get_cb_data(BT_ADAPTER_EVENT);
3421                 if (event_info == NULL)
3422                         return;
3423
3424                 if (disable_timer_id > 0)
3425                         g_source_remove(disable_timer_id);
3426
3427                 disable_timer_id = g_timeout_add(BT_RELIABLE_DISABLE_TIME,
3428                                 (GSourceFunc)__bt_reliable_disable_cb,
3429                                 event_info);
3430         }
3431 }
3432
3433 void _bt_register_name_owner_changed(void)
3434 {
3435         GDBusConnection *connection_type;
3436
3437         connection_type = _bt_gdbus_get_system_gconn();
3438         if (connection_type == NULL) {
3439                 BT_ERR("Unable to get the bus");
3440                 return;
3441         }
3442         owner_sig_id = g_dbus_connection_signal_subscribe(connection_type,
3443                                 NULL, BT_EVENT_FREEDESKTOP,
3444                                 BT_NAME_OWNER_CHANGED, NULL, NULL, 0,
3445                                 __bt_name_owner_changed, NULL, NULL);
3446 }
3447
3448 void _bt_unregister_name_owner_changed(void)
3449 {
3450         GDBusConnection *connection_type;
3451
3452         connection_type = _bt_gdbus_get_system_gconn();
3453         if (connection_type != NULL && owner_sig_id != -1) {
3454                 g_dbus_connection_signal_unsubscribe(connection_type,
3455                                                         owner_sig_id);
3456                 owner_sig_id = -1;
3457         }
3458 }
3459
3460 static void __bt_manager_event_filter(GDBusConnection *connection,
3461                                         const gchar *sender_name,
3462                                         const gchar *object_path,
3463                                         const gchar *interface_name,
3464                                         const gchar *signal_name,
3465                                         GVariant *parameters,
3466                                         gpointer user_data)
3467 {
3468         char *path = NULL;
3469         GVariantIter *interface_iter = NULL;
3470         char *interface_str = NULL;
3471         bt_gatt_service_change_t change;
3472         char address[BT_ADDRESS_STRING_SIZE] = { 0 };
3473         char secure_address[BT_ADDRESS_STRING_SIZE] = { 0 };
3474         bt_user_info_t *user_info = NULL;
3475
3476         if (strcasecmp(signal_name, "GattServiceAdded") == 0) {
3477                 g_variant_get(parameters, "(&s)", &path);
3478
3479                 _bt_convert_device_path_to_address(path, address);
3480                 _bt_convert_addr_string_to_type(change.device_addr.addr, address);
3481                 _bt_convert_addr_string_to_secure_string(secure_address, address);
3482
3483                 if (_bluetooth_gatt_check_service_change_watcher_address(&change.device_addr)
3484                         == FALSE) {
3485                         BT_INFO("GATT Service [%s] added, but no watcher for %s",
3486                                         path, secure_address);
3487                         return;
3488                 } else
3489                         BT_INFO(" ### GATT Service added [%s] [%s]",
3490                                         path, secure_address);
3491
3492                 change.svc_path = g_strdup(path);
3493                 change.change_type = BLUETOOTH_GATT_SERVICE_CHANGE_TYPE_ADD;
3494
3495                 user_info = _bt_get_user_data(BT_COMMON);
3496                 if (user_info != NULL) {
3497                         _bt_common_event_cb(
3498                                 BLUETOOTH_EVENT_GATT_CLIENT_SERVICE_CHANGED,
3499                                 BLUETOOTH_ERROR_NONE, &change,
3500                                 user_info->cb, user_info->user_data);
3501                 }
3502
3503                 g_free(change.svc_path);
3504         } else if (strcasecmp(signal_name, "InterfacesRemoved") == 0) {
3505                 g_variant_get(parameters, "(&oas)",
3506                                                         &path, &interface_iter);
3507
3508                 if (!path) {
3509                         BT_ERR("Invalid adapter path");
3510                         return;
3511                 }
3512
3513                 _bt_convert_device_path_to_address(path, address);
3514                 _bt_convert_addr_string_to_type(change.device_addr.addr, address);
3515                 _bt_convert_addr_string_to_secure_string(secure_address, address);
3516
3517                 if (_bluetooth_gatt_check_service_change_watcher_address(&change.device_addr)
3518                         == FALSE) {
3519                         BT_INFO("GATT Service [%s] removed, but no watcher for %s",
3520                                         path, secure_address);
3521                         return;
3522                 }
3523
3524                 while (g_variant_iter_loop(interface_iter, "s", &interface_str)) {
3525                         if (g_strcmp0(interface_str, GATT_SERV_INTERFACE) == 0) {
3526                                 change.svc_path = g_strdup(path);
3527                                 change.change_type = BLUETOOTH_GATT_SERVICE_CHANGE_TYPE_REMOVE;
3528
3529                                 BT_INFO(" ### GATT Service removed [%s] [%s]",
3530                                                 path, secure_address);
3531
3532                                 user_info = _bt_get_user_data(BT_COMMON);
3533                                 if (user_info != NULL) {
3534                                         _bt_common_event_cb(
3535                                                 BLUETOOTH_EVENT_GATT_CLIENT_SERVICE_CHANGED,
3536                                                 BLUETOOTH_ERROR_NONE, &change,
3537                                                 user_info->cb, user_info->user_data);
3538                                 }
3539
3540                                 g_free(change.svc_path);
3541                                 break;
3542                         }
3543                 }
3544                 g_variant_iter_free(interface_iter);
3545         }
3546 }
3547
3548 int _bt_register_manager_subscribe_signal(gboolean subscribe)
3549 {
3550         GDBusConnection *g_conn;
3551         static int service_added_id = -1;
3552         static int interface_removed_id = -1;
3553
3554         g_conn = _bt_gdbus_get_system_gconn();
3555         if (g_conn == NULL)
3556                 return BLUETOOTH_ERROR_INTERNAL;
3557
3558         if (subscribe == TRUE) {
3559                 if (service_added_id == -1) {
3560                         service_added_id = g_dbus_connection_signal_subscribe(g_conn,
3561                                         NULL, GATT_SERV_INTERFACE,
3562                                         "GattServiceAdded", NULL, NULL, 0,
3563                                         __bt_manager_event_filter,
3564                                         NULL, NULL);
3565                 }
3566                 if (interface_removed_id == -1) {
3567                         interface_removed_id = g_dbus_connection_signal_subscribe(g_conn,
3568                                         NULL, BT_MANAGER_INTERFACE,
3569                                         "InterfacesRemoved", NULL, NULL, 0,
3570                                         __bt_manager_event_filter,
3571                                         NULL, NULL);
3572                 }
3573         } else {
3574                 if (service_added_id != -1) {
3575                         g_dbus_connection_signal_unsubscribe(g_conn,
3576                                         service_added_id);
3577                         service_added_id = -1;
3578                 }
3579                 if (interface_removed_id != -1) {
3580                         g_dbus_connection_signal_unsubscribe(g_conn,
3581                                         interface_removed_id);
3582                         interface_removed_id = -1;
3583                 }
3584         }
3585
3586         return BLUETOOTH_ERROR_NONE;
3587 }
3588