bt-api/bt-event-handler.c

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