bt-api/bt-event-handler.c

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