bt-api/bt-event-handler.c

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