bt-api/bt-event-handler.c

   1 /*
   2  * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *              http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  *
  16  */
  17
  18 #include <string.h>
  19 #include <glib.h>
  20 #include <dlog.h>
  21 #include <vconf.h>
  22
  23 #include "bluetooth-api.h"
  24 #include "bluetooth-audio-api.h"
  25 #include "bluetooth-hid-api.h"
  26 #include "bt-internal-types.h"
  27 #include "bluetooth-media-control.h"
  28
  29 #ifndef GATT_DIRECT
  30 #include "bluetooth-gatt-server-api.h"
  31 #endif
  32
  33 #include "bt-common.h"
  34 #include "bt-event-handler.h"
  35 #include "bt-gatt-client.h"
  36 #include "bt-request-sender.h"
  37 #include "bt-gatt-server.h"
  38
  39 #define PROFILE_SUPPORTED 0x3 /* This corresponds to binary 0b11*/
  40 #define BT_RELIABLE_DISABLE_TIME 300 /* 300 ms */
  41
  42 typedef struct {
  43         int server_fd;
  44 } bt_server_info_t;
  45
  46 typedef struct {
  47         int request_id;
  48 } bt_sending_info_t;
  49
  50 static int obex_server_id;
  51 static guint disable_timer_id;
  52 static gboolean is_initialized;
  53 static GSList *sending_list;
  54 static GSList *server_list;
  55 static GSList *event_list;
  56 static guint owner_sig_id;
  57
  58 void _bt_add_push_request_id(int request_id)
  59 {
  60         bt_sending_info_t *info;
  61
  62         info = g_new0(bt_sending_info_t, 1);
  63         info->request_id = request_id;
  64
  65         sending_list = g_slist_append(sending_list, info);
  66 }
  67
  68 static gboolean __bt_is_request_id_exist(int request_id)
  69 {
  70         GSList *l;
  71         bt_sending_info_t *info;
  72
  73         for (l = sending_list; l != NULL; l = g_slist_next(l)) {
  74                 info = l->data;
  75                 if (info == NULL)
  76                         continue;
  77
  78                 BT_DBG("compare %d  with %d", info->request_id, request_id);
  79                 if (info->request_id == request_id)
  80                         return TRUE;
  81         }
  82
  83         return FALSE;
  84 }
  85
  86 static void __bt_remove_push_request_id(int request_id)
  87 {
  88         GSList *l;
  89         bt_sending_info_t *info;
  90
  91         for (l = sending_list; l != NULL; l = g_slist_next(l)) {
  92                 info = l->data;
  93                 if (info == NULL)
  94                         continue;
  95
  96                 BT_DBG("info->request_id = %d\n", info->request_id);
  97                 BT_DBG("request_id = %d\n", request_id);
  98                 if (info->request_id == request_id) {
  99                         sending_list = g_slist_remove(sending_list, (void *)info);
 100                         g_free(info);
 101                         break;
 102                 }
 103         }
 104 }
 105
 106 static void __bt_remove_all_push_request_id(void)
 107 {
 108         GSList *l;
 109         bt_sending_info_t *info;
 110
 111         for (l = sending_list; l != NULL; l = g_slist_next(l)) {
 112                 info = l->data;
 113                 g_free(info);
 114         }
 115
 116         g_slist_free(sending_list);
 117         sending_list = NULL;
 118 }
 119
 120 static void __bt_remove_all_server(void)
 121 {
 122         GSList *l;
 123         bt_server_info_t *info;
 124
 125         for (l = server_list; l != NULL; l = g_slist_next(l)) {
 126                 info = l->data;
 127                 g_free(info);
 128         }
 129
 130         g_slist_free(server_list);
 131         server_list = NULL;
 132 }
 133
 134 static gboolean __bt_is_server_exist(int server_fd)
 135 {
 136         GSList *l;
 137         bt_server_info_t *info;
 138
 139         for (l = server_list; l != NULL; l = g_slist_next(l)) {
 140                 info = l->data;
 141                 if (info == NULL)
 142                         continue;
 143
 144                 retv_if(info->server_fd == server_fd, TRUE);
 145         }
 146
 147         return FALSE;
 148 }
 149
 150 static void __bt_get_uuid_info(bluetooth_device_info_t *dev_info,
 151                                 char **uuids,
 152                                 int uuid_count)
 153 {
 154         int i;
 155         char **parts;
 156
 157         ret_if(dev_info == NULL);
 158         ret_if(uuids == NULL);
 159         ret_if(uuid_count <= 0);
 160
 161         dev_info->service_index = uuid_count;
 162
 163         for (i = 0; i < uuid_count && uuids[i] != NULL; i++) {
 164                 g_strlcpy(dev_info->uuids[i], uuids[i], BLUETOOTH_UUID_STRING_MAX);
 165
 166                 parts = g_strsplit(uuids[i], "-", -1);
 167
 168                 if (parts == NULL || parts[0] == NULL) {
 169                         g_strfreev(parts);
 170                         continue;
 171                 }
 172
 173                 dev_info->service_list_array[i] = g_ascii_strtoull(parts[0], NULL, 16);
 174                 g_strfreev(parts);
 175         }
 176 }
 177 static int __bt_call_list_create(bt_hf_call_list_s **list)
 178 {
 179         bt_hf_call_list_s *handle;
 180
 181         if (*list != NULL) {
 182                 BT_DBG("Already Initialized");
 183                 return BLUETOOTH_ERROR_NONE;
 184         }
 185         handle = g_malloc0(sizeof(bt_hf_call_list_s));
 186         *list = handle;
 187         return BLUETOOTH_ERROR_NONE;
 188 }
 189
 190 static int __bt_call_list_reset(bt_hf_call_list_s *list)
 191 {
 192         bt_hf_call_list_s *handle;
 193         bt_hf_call_status_info_t *call_status;
 194
 195         if (list == NULL) {
 196                 BT_ERR("invalid parameter");
 197                 return BLUETOOTH_ERROR_INVALID_PARAM;
 198         }
 199         handle = (bt_hf_call_list_s *)list;
 200         do  {
 201                 call_status = (bt_hf_call_status_info_t *)g_list_nth_data(handle->list, 0);
 202                 if (call_status == NULL)
 203                         break;
 204                 handle->list = g_list_remove(handle->list, call_status);
 205                 g_free(call_status->number);
 206                 g_free(call_status);
 207         } while (1);
 208         return BLUETOOTH_ERROR_NONE;
 209 }
 210
 211 static int __bt_call_list_destroy(bt_hf_call_list_s *list)
 212 {
 213         int result;
 214         bt_hf_call_list_s *handle;
 215
 216         if (list == NULL) {
 217                 BT_ERR("invalid parameter");
 218                 return BLUETOOTH_ERROR_INVALID_PARAM;
 219         }
 220         handle = (bt_hf_call_list_s *)list;
 221         result = __bt_call_list_reset(list);
 222         g_free(handle);
 223         return result;
 224 }
 225 static int __bt_call_list_add(bt_hf_call_list_s *list, char * number,
 226                                                                 int dir, int status, int mpart, int idx)
 227 {
 228         bt_hf_call_list_s *handle;
 229         bt_hf_call_status_info_t *call_status;
 230
 231         if (list == NULL) {
 232                 BT_ERR("invalid parameter");
 233                 return BLUETOOTH_ERROR_INVALID_PARAM;
 234         }
 235         handle = (bt_hf_call_list_s *)list;
 236         call_status = g_malloc0(sizeof(bt_hf_call_status_info_t));
 237         call_status->number = g_strdup(number);
 238         call_status->direction = dir;
 239         call_status->status = status;
 240         call_status->mpart = mpart;
 241         call_status->idx = idx;
 242         handle->list = g_list_append(handle->list, (gpointer)call_status);
 243         return BLUETOOTH_ERROR_NONE;
 244 }
 245
 246 static bluetooth_device_info_t *__bt_get_device_info_in_message(GVariant *parameters, int *ret)
 247 {
 248         bluetooth_device_info_t *dev_info;
 249         const char *address = NULL;
 250         const char *name = NULL;
 251         gchar **uuids = NULL;
 252         unsigned int dev_class = 0;
 253         short rssi = 0;
 254         gboolean paired = FALSE;
 255         guint connected = 0;
 256         gboolean trust = FALSE;
 257         gsize uuid_count;
 258         int result = BLUETOOTH_ERROR_NONE;
 259         GVariant *string_var;
 260         int i = 0, len = 0;
 261         int manufacturer_data_len = 0;
 262         GVariant *manufacturer_var = NULL;
 263         const char *manufacturer_data = NULL;
 264
 265         g_variant_get(parameters, "(i&sun&sbub@asn@ay)", &result, &address,
 266                         &dev_class, &rssi, &name, &paired,
 267                         &connected, &trust,  &string_var, &manufacturer_data_len, &manufacturer_var);
 268
 269         if (string_var == NULL) {
 270                 BT_ERR("invalid parameters in signal");
 271                 return NULL;
 272         }
 273
 274         uuids = (gchar **)g_variant_get_strv(string_var, &uuid_count);
 275
 276         len = g_variant_get_size(manufacturer_var);
 277         if (len > 0)
 278                 manufacturer_data = (char *)g_variant_get_data(manufacturer_var);
 279
 280         dev_info = g_malloc0(sizeof(bluetooth_device_info_t));
 281         dev_info->rssi = rssi;
 282         dev_info->paired = paired;
 283         dev_info->connected = connected;
 284         dev_info->trust = trust;
 285
 286         g_strlcpy(dev_info->device_name.name, name,
 287                 BLUETOOTH_DEVICE_NAME_LENGTH_MAX + 1);
 288
 289         _bt_divide_device_class(&dev_info->device_class, dev_class);
 290
 291         _bt_convert_addr_string_to_type(dev_info->device_address.addr,
 292                                         address);
 293
 294         if (uuid_count > 0)
 295                 __bt_get_uuid_info(dev_info, uuids, uuid_count);
 296
 297         if (manufacturer_data_len > BLUETOOTH_MANUFACTURER_DATA_LENGTH_MAX) {
 298                 BT_ERR("manufacturer_data_len is too long(len = %d)", manufacturer_data_len);
 299                 manufacturer_data_len = BLUETOOTH_MANUFACTURER_DATA_LENGTH_MAX;
 300         }
 301         dev_info->manufacturer_data.data_len = manufacturer_data_len;
 302         if (manufacturer_data)
 303                 for (i = 0; i < manufacturer_data_len; i++)
 304                         dev_info->manufacturer_data.data[i] = manufacturer_data[i];
 305         *ret = result;
 306         g_free(uuids);
 307         g_variant_unref(string_var);
 308         g_variant_unref(manufacturer_var);
 309         return dev_info;
 310 }
 311
 312 static bluetooth_le_device_info_t *__bt_get_le_device_info_in_message(GVariant *parameters, int *ret)
 313 {
 314         bluetooth_le_device_info_t *le_dev_info;
 315         const char *address = NULL;
 316         int i;
 317         short addr_type = 0;
 318         short rssi = 0;
 319         int len = 0;
 320         int adv_data_len = 0;
 321         GVariant *adv_var = NULL;
 322         const char *adv_data = NULL;
 323         int scan_data_len = 0;
 324         GVariant *scan_var = NULL;
 325         const char *scan_data = NULL;
 326         int result = BLUETOOTH_ERROR_NONE;
 327
 328         g_variant_get(parameters, "(i&snnn@ayn@ay)", &result, &address,
 329                         &addr_type, &rssi, &adv_data_len, &adv_var, &scan_data_len, &scan_var);
 330
 331         len = g_variant_get_size(adv_var);
 332         if (len > 0)
 333                 adv_data = (char *)g_variant_get_data(adv_var);
 334
 335         len = g_variant_get_size(scan_var);
 336         if (len > 0)
 337                 scan_data = (char *)g_variant_get_data(scan_var);
 338
 339         le_dev_info = g_malloc0(sizeof(bluetooth_le_device_info_t));
 340         _bt_convert_addr_string_to_type(le_dev_info->device_address.addr, address);
 341         le_dev_info->addr_type = addr_type;
 342         le_dev_info->rssi = rssi;
 343         le_dev_info->adv_ind_data.data_len = adv_data_len;
 344
 345         for (i = 0; i < adv_data_len; i++)
 346                 if (adv_data)
 347                         le_dev_info->adv_ind_data.data.data[i] = adv_data[i];
 348
 349         le_dev_info->scan_resp_data.data_len = scan_data_len;
 350
 351         for (i = 0; i < scan_data_len; i++)
 352                 if (scan_data)
 353                         le_dev_info->scan_resp_data.data.data[i] = scan_data[i];
 354
 355         *ret = result;
 356         g_variant_unref(adv_var);
 357         g_variant_unref(scan_var);
 358         return le_dev_info;
 359 }
 360
 361 gboolean __bt_reliable_disable_cb(gpointer user_data)
 362 {
 363         BT_DBG("+");
 364         bt_event_info_t *event_info = user_data;
 365
 366         _bt_set_le_scan_status(FALSE);
 367
 368         _bt_set_adapter_internal_status(FALSE);
 369
 370         if (is_initialized != FALSE) {
 371                 _bt_common_event_cb(BLUETOOTH_EVENT_DISABLED,
 372                                 BLUETOOTH_ERROR_NONE, NULL,
 373                                 event_info->cb, event_info->user_data);
 374         }
 375
 376         obex_server_id = BT_NO_SERVER;
 377         __bt_remove_all_server();
 378         __bt_remove_all_push_request_id();
 379 #ifdef TIZEN_FEATURE_BT_RFCOMM_DIRECT
 380          _bt_rfcomm_server_free_all();
 381 #endif
 382
 383         _bt_hid_free_hid_info();
 384
 385         BT_DBG("-");
 386         return FALSE;
 387 }
 388
 389 static void __bt_fill_garray_from_variant(GVariant *var, GArray *param)
 390 {
 391         char *data;
 392         int size;
 393
 394         size = g_variant_get_size(var);
 395         if (size > 0) {
 396                 data = (char *)g_variant_get_data(var);
 397                 if (data)
 398                         param = g_array_append_vals(param, data, size);
 399
 400         }
 401 }
 402
 403 void __bt_adapter_event_filter(GDBusConnection *connection,
 404                                                  const gchar *sender_name,
 405                                                  const gchar *object_path,
 406                                                  const gchar *interface_name,
 407                                                  const gchar *signal_name,
 408                                                  GVariant *parameters,
 409                                                  gpointer user_data)
 410 {
 411         bt_event_info_t *event_info;
 412         int result = BLUETOOTH_ERROR_NONE;
 413
 414         event_info = (bt_event_info_t *)user_data;
 415         ret_if(event_info == NULL);
 416
 417         if (strcasecmp(object_path, BT_ADAPTER_PATH) != 0)
 418                 return;
 419         if (strcasecmp(interface_name, BT_EVENT_SERVICE) != 0)
 420                 return;
 421
 422         if (strcasecmp(signal_name, BT_ENABLED) == 0) {
 423                 BT_INFO("BT_ENABLED");
 424                 g_variant_get(parameters, "(i)", &result);
 425
 426                 _bt_common_event_cb(BLUETOOTH_EVENT_ENABLED,
 427                                 result, NULL,
 428                                 event_info->cb, event_info->user_data);
 429         } else if (strcasecmp(signal_name, BT_DISABLED) == 0) {
 430                 BT_INFO("BT_DISABLED");
 431
 432                 /* Wait for the termining time of bt-service  */
 433                 if (disable_timer_id > 0)
 434                         g_source_remove(disable_timer_id);
 435
 436                 disable_timer_id = g_timeout_add(BT_RELIABLE_DISABLE_TIME,
 437                                 (GSourceFunc)__bt_reliable_disable_cb,
 438                                 event_info);
 439         } else if (strcasecmp(signal_name, BT_DISABLED_BATTERY_DATA) == 0) {
 440                 BT_INFO("BT_DISABLED_BATTERY_DATA");
 441
 442                 int result;
 443                 GVariant *param = NULL;
 444                 GArray *dbus_data = NULL;
 445                 bt_battery_dbus_data_t *info = NULL;
 446                 bt_battery_data *data = NULL;
 447
 448                 g_variant_get(parameters, "(iv)", &result, &param);
 449
 450                 if (!param) {
 451                         result = BLUETOOTH_ERROR_INTERNAL;
 452                         BT_ERR("No data reveived");
 453                         _bt_common_event_cb(BLUETOOTH_EVENT_DISABLED_BATTERY_DATA,
 454                                 result, data,
 455                                 event_info->cb, event_info->user_data);
 456                         return;
 457                 }
 458
 459                 dbus_data = g_array_new(TRUE, TRUE, sizeof(gchar));
 460                 __bt_fill_garray_from_variant(param, dbus_data);
 461                 g_variant_unref(param);
 462
 463                 info = &g_array_index(dbus_data, bt_battery_dbus_data_t, 0);
 464
 465                 data = g_new0(bt_battery_data, 1);
 466
 467                 data->session_start_time = info->session_start_time;
 468                 data->session_end_time = info->session_end_time;
 469                 data->session_scan_time = info->session_scan_time;
 470                 data->session_connected_time = info->session_connected_time;
 471                 data->atm_list = NULL;
 472
 473                 BT_INFO("Received battery data in bt-api: %ld %ld %d %d.",
 474                 data->session_start_time, data->session_end_time,
 475                         data->session_scan_time, data->session_connected_time);
 476
 477                 /*Copying app wise details*/
 478                 int n = NUM_APP_MAX < info->num_app ? NUM_APP_MAX : info->num_app; //Maximum NUM_APP_MAX details will be fetched
 479
 480                 for (int i = 0; i < n; i++) {
 481                         bt_battery_app_data *app_data = NULL;
 482                         app_data = g_malloc0(sizeof(bt_battery_app_data));
 483                         memcpy(app_data, &(info->app_data[i]), sizeof(bt_battery_app_data));
 484                         data->atm_list = g_slist_append(data->atm_list, app_data);
 485                 }
 486
 487                 if (data->atm_list == NULL) {
 488                         BT_INFO("No app data transaction in this session");
 489                 }
 490                 else {
 491                         BT_INFO("App-wise data transaction details:");
 492                         for (GSList *l = data->atm_list; l != NULL; l = g_slist_next(l)) {
 493                                 bt_battery_app_data *t = (bt_battery_app_data *)(l->data);
 494                                 BT_DBG("%ld %ld %d %d", (long int)(t->uid), (long int)(t->pid), t->rx_bytes, t->tx_bytes);
 495                         }
 496                 }
 497
 498                 _bt_common_event_cb(BLUETOOTH_EVENT_DISABLED_BATTERY_DATA,
 499                                 result, data,
 500                                 event_info->cb, event_info->user_data);
 501                 g_slist_free(data->atm_list);
 502                 g_free(data);
 503         } else if (strcasecmp(signal_name, BT_DISCOVERABLE_MODE_CHANGED) == 0) {
 504                 int mode = 0;
 505
 506                 g_variant_get(parameters, "(in)", &result, &mode);
 507                 _bt_common_event_cb(BLUETOOTH_EVENT_DISCOVERABLE_MODE_CHANGED,
 508                                 result, &mode,
 509                                 event_info->cb, event_info->user_data);
 510         } else if (strcasecmp(signal_name, BT_DISCOVERABLE_TIMEOUT_CHANGED) == 0) {
 511                 int timeout = 0;
 512
 513                 g_variant_get(parameters, "(in)", &result, &timeout);
 514                 _bt_common_event_cb(BLUETOOTH_EVENT_DISCOVERABLE_TIMEOUT_CHANGED,
 515                                 result, &timeout,
 516                                 event_info->cb, event_info->user_data);
 517         } else if (strcasecmp(signal_name, BT_CONNECTABLE_CHANGED) == 0) {
 518                 gboolean connectable = FALSE;
 519
 520                 g_variant_get(parameters, "(b)", &connectable);
 521                 BT_DBG("Connectable is changed : %d", connectable);
 522
 523                 _bt_common_event_cb(BLUETOOTH_EVENT_CONNECTABLE_CHANGED,
 524                                 result, &connectable,
 525                                 event_info->cb, event_info->user_data);
 526         } else if (strcasecmp(signal_name, BT_ADAPTER_NAME_CHANGED) == 0) {
 527                 char *adapter_name = NULL;
 528
 529                 g_variant_get(parameters, "(i&s)", &result, &adapter_name);
 530                 _bt_common_event_cb(BLUETOOTH_EVENT_LOCAL_NAME_CHANGED,
 531                                 result, adapter_name,
 532                                 event_info->cb, event_info->user_data);
 533         } else if (strcasecmp(signal_name, BT_DISCOVERY_STARTED) == 0) {
 534                 _bt_common_event_cb(BLUETOOTH_EVENT_DISCOVERY_STARTED,
 535                                 BLUETOOTH_ERROR_NONE, NULL,
 536                                 event_info->cb, event_info->user_data);
 537         } else if (strcasecmp(signal_name, BT_DISCOVERY_FINISHED) == 0) {
 538                 g_variant_get(parameters, "(i)", &result);
 539                 _bt_common_event_cb(BLUETOOTH_EVENT_DISCOVERY_FINISHED,
 540                                 result, NULL,
 541                                 event_info->cb, event_info->user_data);
 542         } else if (strcasecmp(signal_name, BT_ADVERTISING_STARTED) == 0) {
 543                 int adv_handle;
 544
 545                 g_variant_get(parameters, "(ii)", &result, &adv_handle);
 546                 _bt_common_event_cb(BLUETOOTH_EVENT_ADVERTISING_STARTED,
 547                                 result, &adv_handle,
 548                                 event_info->cb, event_info->user_data);
 549         } else if (strcasecmp(signal_name, BT_ADVERTISING_STOPPED) == 0) {
 550                 int adv_handle;
 551
 552                 g_variant_get(parameters, "(ii)", &result, &adv_handle);
 553                 _bt_common_event_cb(BLUETOOTH_EVENT_ADVERTISING_STOPPED,
 554                                 result, &adv_handle,
 555                                 event_info->cb, event_info->user_data);
 556         } else if (strcasecmp(signal_name, BT_ADVERTISING_MANUFACTURER_DATA_CHANGED) == 0) {
 557                 GVariant *var = NULL;
 558                 char *data;
 559                 int len;
 560
 561                 g_variant_get(parameters, "(@ay)", &var);
 562                 len = g_variant_get_size(var);
 563                 data = (char *)g_variant_get_data(var);
 564
 565                 _bt_common_event_cb(BLUETOOTH_EVENT_ADVERTISING_MANUFACTURER_DATA_CHANGED,
 566                                 len, data,
 567                                 event_info->cb, event_info->user_data);
 568
 569                 g_variant_unref(var);
 570         }  else if (strcasecmp(signal_name, BT_SCAN_RESPONSE_MANUFACTURER_DATA_CHANGED) == 0) {
 571                 GVariant *var = NULL;
 572                 char *data;
 573                 int len;
 574
 575                 g_variant_get(parameters, "(@ay)", &var);
 576                 len = g_variant_get_size(var);
 577                 data = (char *)g_variant_get_data(var);
 578
 579                 _bt_common_event_cb(BLUETOOTH_EVENT_SCAN_RESPONSE_MANUFACTURER_DATA_CHANGED,
 580                                 len, data,
 581                                 event_info->cb, event_info->user_data);
 582
 583                 g_variant_unref(var);
 584         } else if (strcasecmp(signal_name, BT_MANUFACTURER_DATA_CHANGED) == 0) {
 585                 GVariant *var = NULL;
 586                 char *data;
 587                 int len;
 588
 589                 g_variant_get(parameters, "(@ay)", &var);
 590                 len = g_variant_get_size(var);
 591                 data = (char *)g_variant_get_data(var);
 592
 593                 _bt_common_event_cb(BLUETOOTH_EVENT_MANUFACTURER_DATA_CHANGED,
 594                                 len, data,
 595                                 event_info->cb, event_info->user_data);
 596
 597                 g_variant_unref(var);
 598         } else if (strcasecmp(signal_name, BT_PASSKEY_NOTIFICATION) == 0) {
 599                 const char *address = NULL;
 600                 const char *passkey = NULL;
 601                 const char *passkey_info[2];
 602
 603                 g_variant_get(parameters, "(&s&s)", &address, &passkey);
 604                 passkey_info[0] = address;
 605                 passkey_info[1] = passkey;
 606
 607                 _bt_common_event_cb(BLUETOOTH_EVENT_PASSKEY_NOTIFICATION,
 608                                 BLUETOOTH_ERROR_NONE, (void*)passkey_info,
 609                                 event_info->cb, event_info->user_data);
 610         } else if (strcasecmp(signal_name, BT_DEVICE_FOUND) == 0) {
 611                 int event;
 612                 bluetooth_device_info_t *device_info;
 613
 614                 device_info = __bt_get_device_info_in_message(parameters,
 615                                                                 &result);
 616                 ret_if(device_info == NULL);
 617
 618                 if (strlen(device_info->device_name.name) > 0)
 619                         event = BLUETOOTH_EVENT_REMOTE_DEVICE_NAME_UPDATED;
 620                 else
 621                         event = BLUETOOTH_EVENT_REMOTE_DEVICE_FOUND;
 622
 623                 _bt_common_event_cb(event,
 624                                 result, device_info,
 625                                 event_info->cb, event_info->user_data);
 626
 627                 g_free(device_info);
 628         } else if (strcasecmp(signal_name, BT_BOND_CREATED) == 0) {
 629                 bluetooth_device_info_t *device_info;
 630
 631                 device_info = __bt_get_device_info_in_message(parameters,
 632                                                                 &result);
 633                 ret_if(device_info == NULL);
 634
 635                 _bt_common_event_cb(BLUETOOTH_EVENT_BONDING_FINISHED,
 636                                 result, device_info,
 637                                 event_info->cb, event_info->user_data);
 638
 639                 g_free(device_info);
 640         } else if (strcasecmp(signal_name, BT_BOND_DESTROYED) == 0) {
 641                 const char *address = NULL;
 642                 bluetooth_device_address_t dev_address = { {0} };
 643
 644                 g_variant_get(parameters, "(i&s)", &result, &address);
 645
 646                 _bt_convert_addr_string_to_type(dev_address.addr,
 647                                                 address);
 648
 649                 _bt_common_event_cb(BLUETOOTH_EVENT_BONDED_DEVICE_REMOVED,
 650                                 result, &dev_address,
 651                                 event_info->cb, event_info->user_data);
 652         } else if (strcasecmp(signal_name, BT_SERVICE_SEARCHED) == 0) {
 653                 bluetooth_device_info_t *device_info;
 654                 bt_sdp_info_t sdp_info;
 655
 656                 device_info = __bt_get_device_info_in_message(parameters,
 657                                                                 &result);
 658                 ret_if(device_info == NULL);
 659
 660                 memset(&sdp_info, 0x00, sizeof(bt_sdp_info_t));
 661
 662                 sdp_info.service_index = device_info->service_index;
 663
 664                 memcpy(&sdp_info.device_addr,
 665                         &device_info->device_address,
 666                         BLUETOOTH_ADDRESS_LENGTH);
 667
 668                 memcpy(sdp_info.service_list_array,
 669                         device_info->service_list_array,
 670                         BLUETOOTH_MAX_SERVICES_FOR_DEVICE);
 671
 672                 memcpy(sdp_info.uuids,
 673                         device_info->uuids,
 674                         BLUETOOTH_MAX_SERVICES_FOR_DEVICE * BLUETOOTH_UUID_STRING_MAX);
 675
 676                 _bt_common_event_cb(BLUETOOTH_EVENT_SERVICE_SEARCHED,
 677                                 result, &sdp_info,
 678                                 event_info->cb, event_info->user_data);
 679
 680                 g_free(device_info);
 681         } else if (strcasecmp(signal_name, BT_IPSP_INITIALIZED) == 0) {
 682                 gboolean ipsp_intialized = FALSE;
 683                 g_variant_get(parameters, "(b)", &ipsp_intialized);
 684
 685                 BT_DBG("IPSP init state changed to : %d", ipsp_intialized);
 686
 687                 _bt_common_event_cb(BLUETOOTH_EVENT_IPSP_INIT_STATE_CHANGED,
 688                                 BLUETOOTH_ERROR_NONE, &ipsp_intialized,
 689                                 event_info->cb, event_info->user_data);
 690         } else if (strcasecmp(signal_name, BT_KBD_PASSKEY_DISPLAY_REQ_RECEIVED) == 0) {
 691                 const char *address =  NULL;
 692                 const char *name =  NULL;
 693                 const char *str_passkey = NULL;
 694                 bool incoming = false;
 695
 696                 bluetooth_authentication_request_info_t auth_info;
 697                 memset(&auth_info, 0x00, sizeof(bluetooth_authentication_request_info_t));
 698
 699                 g_variant_get(parameters, "(b&s&s&s)", &incoming, &address, &name, &str_passkey);
 700
 701                 g_strlcpy(auth_info.device_name.name, name,
 702                         BLUETOOTH_DEVICE_NAME_LENGTH_MAX + 1);
 703                 _bt_convert_addr_string_to_type(auth_info.device_address.addr,
 704                         address);
 705                 g_strlcpy(auth_info.str_passkey, str_passkey, strlen(str_passkey)+1);
 706                 auth_info.incoming = incoming;
 707
 708                 BT_INFO("BLUETOOTH_EVENT_KEYBOARD_PASSKEY_DISPLAY");
 709                 _bt_common_event_cb(BLUETOOTH_EVENT_KEYBOARD_PASSKEY_DISPLAY,
 710                         result, &auth_info,
 711                         event_info->cb, event_info->user_data);
 712         } else if (strcasecmp(signal_name, BT_PIN_REQ_RECEIVED) == 0) {
 713                 const char *address =  NULL;
 714                 const char *name =  NULL;
 715                 bool incoming = false;
 716
 717                 bluetooth_authentication_request_info_t auth_info;
 718                 memset(&auth_info, 0x00, sizeof(bluetooth_authentication_request_info_t));
 719
 720                 g_variant_get(parameters, "(b&s&s)", &incoming, &address, &name);
 721
 722                 g_strlcpy(auth_info.device_name.name, name,
 723                         BLUETOOTH_DEVICE_NAME_LENGTH_MAX + 1);
 724                 _bt_convert_addr_string_to_type(auth_info.device_address.addr,
 725                         address);
 726                 auth_info.incoming = incoming;
 727
 728                 BT_INFO("BLUETOOTH_EVENT_PIN_REQUEST");
 729
 730                 _bt_common_event_cb(BLUETOOTH_EVENT_PIN_REQUEST,
 731                         result, &auth_info,
 732                         event_info->cb, event_info->user_data);
 733         } else if (strcasecmp(signal_name, BT_PASSKEY_REQ_RECEIVED) == 0) {
 734                 const char *address = NULL;
 735                 const char *name =  NULL;
 736                 bool incoming = false;
 737
 738                 bluetooth_authentication_request_info_t auth_info;
 739                 memset(&auth_info, 0x00, sizeof(bluetooth_authentication_request_info_t));
 740
 741                 g_variant_get(parameters, "(b&s&s)", &incoming, &address, &name);
 742
 743                 g_strlcpy(auth_info.device_name.name, name,
 744                         BLUETOOTH_DEVICE_NAME_LENGTH_MAX + 1);
 745                 _bt_convert_addr_string_to_type(auth_info.device_address.addr,
 746                         address);
 747                 auth_info.incoming = incoming;
 748
 749                 BT_INFO("BLUETOOTH_EVENT_PASSKEY_REQUEST");
 750
 751                 _bt_common_event_cb(BLUETOOTH_EVENT_PASSKEY_REQUEST,
 752                         result, &auth_info,
 753                         event_info->cb, event_info->user_data);
 754         } else if (strcasecmp(signal_name, BT_PASSKEY_CFM_REQ_RECEIVED) == 0) {
 755                 const char *address =  NULL;
 756                 const char *name =  NULL;
 757                 const char *str_passkey = NULL;
 758                 bool incoming = false;
 759
 760                 bluetooth_authentication_request_info_t auth_info;
 761                 memset(&auth_info, 0x00, sizeof(bluetooth_authentication_request_info_t));
 762
 763                 g_variant_get(parameters, "(b&s&s&s)", &incoming, &address, &name, &str_passkey);
 764
 765                 g_strlcpy(auth_info.device_name.name, name,
 766                         BLUETOOTH_DEVICE_NAME_LENGTH_MAX + 1);
 767                 _bt_convert_addr_string_to_type(auth_info.device_address.addr,
 768                         address);
 769                 g_strlcpy(auth_info.str_passkey, str_passkey, strlen(str_passkey)+1);
 770                 auth_info.incoming = incoming;
 771
 772                 BT_INFO("BLUETOOTH_EVENT_PASSKEY_CONFIRM_REQUEST");
 773
 774                 _bt_common_event_cb(BLUETOOTH_EVENT_PASSKEY_CONFIRM_REQUEST,
 775                         result, &auth_info,
 776                         event_info->cb, event_info->user_data);
 777         }
 778 }
 779
 780 void __bt_adapter_le_event_filter(GDBusConnection *connection,
 781                                                  const gchar *sender_name,
 782                                                  const gchar *object_path,
 783                                                  const gchar *interface_name,
 784                                                  const gchar *signal_name,
 785                                                  GVariant *parameters,
 786                                                  gpointer user_data)
 787 {
 788         bt_event_info_t *event_info;
 789         int result = BLUETOOTH_ERROR_NONE;
 790
 791         event_info = (bt_event_info_t *)user_data;
 792         ret_if(event_info == NULL);
 793
 794         if (strcasecmp(object_path, BT_LE_ADAPTER_PATH) != 0)
 795                 return;
 796         if (strcasecmp(interface_name, BT_EVENT_SERVICE) != 0)
 797                 return;
 798
 799         if (strcasecmp(signal_name, BT_LE_ENABLED) == 0) {
 800                 BT_INFO("BT_LE_ENABLED");
 801                 g_variant_get(parameters, "(i)", &result);
 802                 _bt_common_event_cb(BLUETOOTH_EVENT_LE_ENABLED,
 803                                 result, NULL,
 804                                 event_info->cb, event_info->user_data);
 805         } else if (strcasecmp(signal_name, BT_LE_DISABLED) == 0) {
 806                 BT_INFO("BT_LE_DISABLED");
 807                 _bt_common_event_cb(BLUETOOTH_EVENT_LE_DISABLED,
 808                                 result, NULL,
 809                                 event_info->cb, event_info->user_data);
 810         } else if (strcasecmp(signal_name, BT_LE_DISCOVERY_STARTED) == 0) {
 811                 _bt_common_event_cb(BLUETOOTH_EVENT_LE_DISCOVERY_STARTED,
 812                                 BLUETOOTH_ERROR_NONE, NULL,
 813                                 event_info->cb, event_info->user_data);
 814         } else if (strcasecmp(signal_name, BT_LE_DISCOVERY_FINISHED) == 0) {
 815                 g_variant_get(parameters, "(i)", &result);
 816                 _bt_common_event_cb(BLUETOOTH_EVENT_LE_DISCOVERY_FINISHED,
 817                                 result, NULL,
 818                                 event_info->cb, event_info->user_data);
 819         } else if (strcasecmp(signal_name, BT_LE_DEVICE_FOUND) == 0) {
 820                 bluetooth_le_device_info_t *le_device_info;
 821
 822                 le_device_info = __bt_get_le_device_info_in_message(parameters,
 823                                                                 &result);
 824                 ret_if(le_device_info == NULL);
 825
 826                 if (bluetooth_is_le_scanning() == TRUE) {
 827                         _bt_common_event_cb(BLUETOOTH_EVENT_REMOTE_LE_DEVICE_FOUND,
 828                                 result, le_device_info,
 829                                 event_info->cb, event_info->user_data);
 830                 }
 831
 832                 g_free(le_device_info);
 833         }
 834 }
 835
 836 void __bt_device_event_filter(GDBusConnection *connection,
 837                                                  const gchar *sender_name,
 838                                                  const gchar *object_path,
 839                                                  const gchar *interface_name,
 840                                                  const gchar *signal_name,
 841                                                  GVariant *parameters,
 842                                                  gpointer user_data)
 843 {
 844         bt_event_info_t *event_info;
 845         int result = BLUETOOTH_ERROR_NONE;
 846
 847         event_info = (bt_event_info_t *)user_data;
 848         ret_if(event_info == NULL);
 849
 850 #ifdef GATT_NO_RELAY
 851         gboolean gatt_interface = FALSE;
 852
 853         if (strcasecmp(interface_name, BT_GATT_CHARACTERISTIC_INTERFACE) == 0)
 854                 gatt_interface = TRUE;
 855
 856         if (strcasecmp(object_path, BT_DEVICE_PATH) != 0 &&
 857                  gatt_interface == FALSE)
 858                 return;
 859         if (strcasecmp(interface_name, BT_EVENT_SERVICE) != 0 &&
 860                  gatt_interface == FALSE)
 861                 return;
 862 #else
 863         if (strcasecmp(object_path, BT_DEVICE_PATH) != 0)
 864                 return;
 865         if (strcasecmp(interface_name, BT_EVENT_SERVICE) != 0)
 866                 return;
 867 #endif
 868
 869         ret_if(signal_name == NULL);
 870 #ifdef TIZEN_GATT_CLIENT
 871         if (strcasecmp(signal_name, BT_GATT_SERVER_CONNECTED) == 0) {
 872                 const char *address = NULL;
 873                 bluetooth_device_address_t dev_address = { {0} };
 874                 BT_DBG("BT_GATT_SERVER_CONNECTED");
 875                 g_variant_get(parameters, "(i&s)", &result, &address);
 876
 877                 _bt_convert_addr_string_to_type(dev_address.addr, address);
 878                 BT_DBG("Sending Event to Framework");
 879                 _bt_common_event_cb(BLUETOOTH_EVENT_GATT_SERVER_CONNECTED,
 880                                 result, &dev_address,
 881                                 event_info->cb, event_info->user_data);
 882         } else if (strcasecmp(signal_name, BT_GATT_SERVER_DISCONNECTED) == 0) {
 883                 const char *address = NULL;
 884                 bluetooth_device_address_t dev_address = { {0} };
 885                 BT_DBG("BT_GATT_SERVER_DISCONNECTED");
 886                 g_variant_get(parameters, "(i&s)", &result, &address);
 887
 888                 _bt_convert_addr_string_to_type(dev_address.addr, address);
 889                 BT_DBG("Sending Event to Framework");
 890                 _bt_common_event_cb(BLUETOOTH_EVENT_GATT_SERVER_DISCONNECTED,
 891                                 result, &dev_address,
 892                                 event_info->cb, event_info->user_data);
 893         } else if (strcasecmp(signal_name, BT_GATT_CLIENT_CONNECTED) == 0) {
 894                 const char *address = NULL;
 895                 bluetooth_device_address_t dev_address = { {0} };
 896                 BT_DBG("BT_GATT_CLIENT_CONNECTED");
 897                 g_variant_get(parameters, "(i&s)", &result, &address);
 898
 899                 _bt_convert_addr_string_to_type(dev_address.addr, address);
 900                 BT_DBG("Sending Event to Framework");
 901                 _bt_common_event_cb(BLUETOOTH_EVENT_GATT_CLIENT_CONNECTED,
 902                                 result, &dev_address,
 903                                 event_info->cb, event_info->user_data);
 904         } else if (strcasecmp(signal_name, BT_GATT_CLIENT_DISCONNECTED) == 0) {
 905                 const char *address = NULL;
 906                 bluetooth_device_address_t dev_address = { {0} };
 907                 BT_DBG("BT_GATT_CLIENT_DISCONNECTED");
 908                 g_variant_get(parameters, "(i&s)", &result, &address);
 909
 910                 _bt_convert_addr_string_to_type(dev_address.addr, address);
 911                 BT_DBG("Sending Event to Framework");
 912                 _bt_common_event_cb(BLUETOOTH_EVENT_GATT_CLIENT_DISCONNECTED,
 913                                 result, &dev_address,
 914                                 event_info->cb, event_info->user_data);
 915 #else
 916         if (strcasecmp(signal_name, BT_GATT_CONNECTED) == 0) {
 917                 const char *address = NULL;
 918                 bluetooth_device_address_t dev_address = { {0} };
 919                 BT_DBG("BT_GATT_CONNECTED");
 920                 g_variant_get(parameters, "(i&s)", &result, &address);
 921
 922                 _bt_convert_addr_string_to_type(dev_address.addr, address);
 923                 BT_DBG("Sending Event to Framework");
 924                 _bt_common_event_cb(BLUETOOTH_EVENT_GATT_CONNECTED,
 925                                 result, &dev_address,
 926                                 event_info->cb, event_info->user_data);
 927         } else if (strcasecmp(signal_name, BT_GATT_DISCONNECTED) == 0) {
 928                 const char *address = NULL;
 929                 bluetooth_device_address_t dev_address = { {0} };
 930                 BT_DBG("BT_GATT_DISCONNECTED");
 931                 g_variant_get(parameters, "(i&s)", &result, &address);
 932
 933                 _bt_convert_addr_string_to_type(dev_address.addr, address);
 934                 BT_DBG("Sending Event to Framework");
 935                 _bt_common_event_cb(BLUETOOTH_EVENT_GATT_DISCONNECTED,
 936                                 result, &dev_address,
 937                                 event_info->cb, event_info->user_data);
 938 #endif
 939         } else if (strcasecmp(signal_name, BT_GATT_REQ_ATT_MTU_CHANGED) == 0) {
 940                 const char *address = NULL;
 941                 bluetooth_device_address_t dev_address = { {0} };
 942                 bluetooth_le_att_mtu_info_t att_mtu_info;
 943                 guint16 mtu;
 944                 guint8 status;
 945                 BT_DBG("BT_GATT_REQ_ATT_MTU_CHANGED");
 946                 g_variant_get(parameters, "(i&sqy)", &result, &address, &mtu, &status);
 947                 BT_DBG("Result [%d] Address [%s] MTU [%d] status [%d]", result, address, mtu, status);
 948
 949                 _bt_convert_addr_string_to_type(dev_address.addr, address);
 950
 951                 memset(&att_mtu_info, 0x00, sizeof(bluetooth_le_att_mtu_info_t));
 952                 memcpy(att_mtu_info.device_address.addr,
 953                                         dev_address.addr,
 954                                         BLUETOOTH_ADDRESS_LENGTH);
 955
 956                 att_mtu_info.mtu = mtu;
 957                 att_mtu_info.status = status;
 958
 959                 _bt_common_event_cb(BLUETOOTH_EVENT_GATT_ATT_MTU_CHANGED,
 960                                 result, &att_mtu_info,
 961                                 event_info->cb, event_info->user_data);
 962 #ifdef GATT_NO_RELAY
 963         } else if (strcasecmp(signal_name, BT_GATT_BLUEZ_CHAR_VAL_CHANGED) == 0) {
 964 #else
 965         } else if (strcasecmp(signal_name, BT_GATT_CHAR_VAL_CHANGED) == 0) {
 966 #endif
 967                 const char *char_handle = NULL;
 968                 int len = 0;
 969                 const char * value = NULL;
 970                 GVariant *char_value_var = NULL;
 971                 bt_gatt_char_value_t char_val = { 0, };
 972                 BT_DBG("BT_GATT_CHAR_VAL_CHANGED");
 973
 974                 g_variant_get(parameters, "(i&s@ay)", &result, &char_handle, &char_value_var);
 975
 976                 len = g_variant_get_size(char_value_var);
 977                 ret_if(char_value_var == NULL);
 978
 979                 if (len > 0)
 980                         value = (char *)g_variant_get_data(char_value_var);
 981
 982                 char_val.char_handle = g_strdup(char_handle);
 983                 char_val.val_len = len;
 984                 /* Fix : FORWARD_NULL : g_variant_get_data can return NULL */
 985                 if (char_val.val_len > 0 && value != NULL) {
 986                         char_val.char_value = (unsigned char*) g_malloc0(char_val.val_len);
 987                         memcpy(char_val.char_value, value, len);
 988                         _bt_common_event_cb(BLUETOOTH_EVENT_GATT_CHAR_VAL_CHANGED,
 989                                         result, &char_val,
 990                                         event_info->cb, event_info->user_data);
 991                         g_free(char_val.char_value);
 992                         g_variant_unref(char_value_var);
 993                 }
 994                 g_free(char_val.char_handle);
 995         } else if (strcasecmp(signal_name, BT_DEVICE_CONNECTED) == 0) {
 996                 const char *address = NULL;
 997                 unsigned char addr_type;
 998                 bt_connection_info_t conn_info;
 999                 bluetooth_device_address_t dev_address = { {0} };
1000                 BT_DBG("BT_DEVICE_CONNECTED");
1001                 g_variant_get(parameters, "(i&sy)", &result, &address, &addr_type);
1002
1003                 _bt_convert_addr_string_to_type(dev_address.addr,
1004                                                 address);
1005
1006                 memset(&conn_info, 0x00, sizeof(bt_connection_info_t));
1007
1008                 memcpy(conn_info.device_addr.addr,
1009                                         dev_address.addr,
1010                                         BLUETOOTH_ADDRESS_LENGTH);
1011
1012                 conn_info.addr_type = addr_type;
1013                 conn_info.disc_reason = 0;
1014                 BT_DBG("Sending Event to Framework");
1015                 _bt_common_event_cb(BLUETOOTH_EVENT_DEVICE_CONNECTED,
1016                                 result, &conn_info,
1017                                 event_info->cb, event_info->user_data);
1018
1019         } else if (strcasecmp(signal_name, BT_DEVICE_DISCONNECTED) == 0) {
1020                 const char *address = NULL;
1021                 unsigned char addr_type;
1022                 bt_connection_info_t conn_info;
1023                 bluetooth_device_address_t dev_address = { {0} };
1024                 BT_DBG("BT_DEVICE_DISCONNECTED");
1025                 g_variant_get(parameters, "(i&sy)", &result, &address, &addr_type);
1026
1027                 _bt_convert_addr_string_to_type(dev_address.addr,
1028                                                 address);
1029
1030                 memset(&conn_info, 0x00, sizeof(bt_connection_info_t));
1031
1032                 memcpy(conn_info.device_addr.addr,
1033                                         dev_address.addr,
1034                                         BLUETOOTH_ADDRESS_LENGTH);
1035
1036                 conn_info.addr_type = addr_type;
1037                 conn_info.disc_reason = result;
1038                 BT_DBG("Sending Event to Framework, disconnect reason [0x%x]", result);
1039                 _bt_common_event_cb(BLUETOOTH_EVENT_DEVICE_DISCONNECTED,
1040                                 result, &conn_info,
1041                                 event_info->cb, event_info->user_data);
1042
1043         } else if (strcasecmp(signal_name, BT_RSSI_MONITORING_ENABLED) == 0) {
1044                 bt_rssi_enabled_t enabled = { 0, };
1045                 char *address;
1046                 int link_type;
1047                 gboolean rssi_enabled = FALSE;
1048
1049                 g_variant_get(parameters, "(isib)", &result, &address,
1050                                         &link_type, &rssi_enabled);
1051
1052                 BT_DBG("RSSI Enabled[Address:%s LinkType:%d RSSI_dbm:%d]",
1053                                 address, link_type, rssi_enabled);
1054                 enabled.address = address;
1055                 enabled.link_type = link_type;
1056                 enabled.rssi_enabled = rssi_enabled;
1057
1058                 _bt_common_event_cb(BLUETOOTH_EVENT_RSSI_ENABLED,
1059                                 result, &enabled,
1060                                 event_info->cb, event_info->user_data);
1061         } else if (strcasecmp(signal_name, BT_RSSI_ALERT) == 0) {
1062                 int alert_type;
1063                 int rssi_dbm;
1064                 char *address;
1065                 int link_type;
1066                 bt_rssi_alert_t alert = { 0, };
1067
1068                 g_variant_get(parameters, "(isiii)", &result, &address,
1069                                         &link_type, &alert_type, &rssi_dbm);
1070
1071                 alert.alert_type = alert_type;
1072                 alert.rssi_dbm = rssi_dbm;
1073                 alert.address = address;
1074                 alert.link_type = link_type;
1075                 BT_DBG("Address [%s] LinkType[%d] AlertType[%d] RSSI dBm[%d]",
1076                                 address, link_type, alert_type, rssi_dbm);
1077                 _bt_common_event_cb(BLUETOOTH_EVENT_RSSI_ALERT,
1078                                 result, &alert,
1079                                 event_info->cb, event_info->user_data);
1080         } else if (strcasecmp(signal_name, BT_RAW_RSSI_EVENT) == 0) {
1081                 int rssi_dbm;
1082                 int link_type;
1083                 char *address;
1084                 bt_raw_rssi_t raw_rssi = { 0, };
1085
1086                 g_variant_get(parameters, "(isii)", &result,
1087                                         &address, &link_type, &rssi_dbm);
1088
1089                 BT_DBG("Address [%s] Link Type[%d] dBm[%d]",
1090                                 address, link_type, rssi_dbm);
1091
1092                 raw_rssi.rssi_dbm = rssi_dbm;
1093                 raw_rssi.address = address;
1094                 raw_rssi.link_type = link_type;
1095
1096                 _bt_common_event_cb(BLUETOOTH_EVENT_RAW_RSSI,
1097                                 result, &raw_rssi,
1098                                 event_info->cb, event_info->user_data);
1099         } else if (strcasecmp(signal_name, BT_DEVICE_AUTHORIZED) == 0) {
1100                 const char *address = NULL;
1101                 bluetooth_device_address_t dev_address = { {0} };
1102
1103                 g_variant_get(parameters, "(i&s)", &result, &address);
1104
1105                 _bt_convert_addr_string_to_type(dev_address.addr,
1106                                                 address);
1107
1108                 _bt_common_event_cb(BLUETOOTH_EVENT_DEVICE_AUTHORIZED,
1109                                 result, &dev_address,
1110                                 event_info->cb, event_info->user_data);
1111         } else if (strcasecmp(signal_name, BT_DEVICE_UNAUTHORIZED) == 0) {
1112                 const char *address = NULL;
1113                 bluetooth_device_address_t dev_address = { {0} };
1114
1115                 g_variant_get(parameters, "(i&s)", &result, &address);
1116
1117                 _bt_convert_addr_string_to_type(dev_address.addr,
1118                                                 address);
1119
1120                 _bt_common_event_cb(BLUETOOTH_EVENT_DEVICE_UNAUTHORIZED,
1121                                 result, &dev_address,
1122                                 event_info->cb, event_info->user_data);
1123         } else if (strcasecmp(signal_name, BT_SUPPORTED_PROFILE_TRUSTED) == 0) {
1124                 char *address;
1125                 bt_supported_profile_trusted_t profile_info = { 0, };
1126                 int trust;
1127
1128                 g_variant_get(parameters, "(i&si)", &result,
1129                                         &address, &trust);
1130
1131                 BT_DBG("Address [%s] trust[%d]", address, trust);
1132                 profile_info.address = address;
1133                 if (trust & (PROFILE_SUPPORTED << 0)) { /* Bit 0 & 1 - for PBAP Supported */
1134                         profile_info.profile = TRUSTED_PROFILE_PBAP;
1135                         profile_info.supported = TRUE;
1136                         if (trust & (1 << 1)) /* Bit 1 - for PBAP Trusted */
1137                                 profile_info.trusted = TRUE;
1138                         else
1139                                 profile_info.trusted = FALSE;
1140
1141                         _bt_common_event_cb(BLUETOOTH_EVENT_SUPPORTED_PROFILE_TRUSTED,
1142                                         result, &profile_info,
1143                                         event_info->cb, event_info->user_data);
1144                 }
1145                 if (trust & (PROFILE_SUPPORTED << 2)) { /* Bit 2 & 3 - for MAP Supported */
1146                         profile_info.profile = TRUSTED_PROFILE_MAP;
1147                         profile_info.supported = TRUE;
1148                         if (trust & (1 << 3)) /* Bit 3 - for PBAP Trusted */
1149                                 profile_info.trusted = TRUE;
1150                         else
1151                                 profile_info.trusted = FALSE;
1152
1153                         _bt_common_event_cb(BLUETOOTH_EVENT_SUPPORTED_PROFILE_TRUSTED,
1154                                         result, &profile_info,
1155                                         event_info->cb, event_info->user_data);
1156                 }
1157                 if (trust & (PROFILE_SUPPORTED << 4)) { /* Bit 4 & 5- for SAP Supported */
1158                         profile_info.profile = TRUSTED_PROFILE_SAP;
1159                         profile_info.supported = TRUE;
1160                         if (trust & (1 << 5)) /* Bit 5 - for SAP Trusted */
1161                                 profile_info.trusted = TRUE;
1162                         else
1163                                 profile_info.trusted = FALSE;
1164
1165                         _bt_common_event_cb(BLUETOOTH_EVENT_SUPPORTED_PROFILE_TRUSTED,
1166                                         result, &profile_info,
1167                                         event_info->cb, event_info->user_data);
1168                 }
1169         } else if (strcasecmp(signal_name, BT_IPSP_CONNECTED) == 0) {
1170                 const char *address = NULL;
1171                 const char *if_name = NULL;
1172                 bt_ipsp_connection_info_t bt_ipsp_iface_info;
1173                 memset(&bt_ipsp_iface_info, 0, sizeof(bt_ipsp_iface_info));
1174
1175                 BT_DBG("BT_IPSP_CONNECTED");
1176                 g_variant_get(parameters, "(i&s&s)", &result, &address, &if_name);
1177
1178                 _bt_convert_addr_string_to_type(bt_ipsp_iface_info.btaddr.addr, address);
1179                 memcpy(bt_ipsp_iface_info.if_name, if_name, 16);
1180
1181                 _bt_common_event_cb(BLUETOOTH_EVENT_IPSP_CONNECTED,
1182                                 result, &bt_ipsp_iface_info,
1183                                 event_info->cb, event_info->user_data);
1184         } else if (strcasecmp(signal_name, BT_IPSP_DISCONNECTED) == 0) {
1185                 const char *address = NULL;
1186                 const char *if_name = NULL;
1187                 bt_ipsp_connection_info_t bt_ipsp_iface_info;
1188                 memset(&bt_ipsp_iface_info, 0, sizeof(bt_ipsp_iface_info));
1189
1190                 BT_DBG("BT_IPSP_DISCONNECTED");
1191                 g_variant_get(parameters, "(i&s&s)", &result, &address, &if_name);
1192
1193                 _bt_convert_addr_string_to_type(bt_ipsp_iface_info.btaddr.addr, address);
1194                 memcpy(bt_ipsp_iface_info.if_name, if_name, 16);
1195
1196                 _bt_common_event_cb(BLUETOOTH_EVENT_IPSP_DISCONNECTED,
1197                                 result, &bt_ipsp_iface_info,
1198                                 event_info->cb, event_info->user_data);
1199         } else if (strcasecmp(signal_name, BT_LE_DATA_LENGTH_CHANGED) == 0) {
1200                 const char *address = NULL;
1201                 bluetooth_device_address_t dev_address = { {0} };
1202                 uint tx_octets = 0;
1203                 uint tx_time = 0;
1204                 uint rx_octets = 0;
1205                 uint rx_time = 0;
1206                 bt_le_data_length_params_t params;
1207
1208                 BT_DBG("BT_LE_DATA_LENGTH_CHANGED");
1209
1210                 g_variant_get(parameters, "(i&sqqqq)", &result, &address,
1211                                 &tx_octets, &tx_time, &rx_octets, &rx_time);
1212
1213                 params.max_tx_octets = tx_octets;
1214                 params.max_tx_time = tx_time;
1215                 params.max_rx_octets = rx_octets;
1216                 params.max_rx_time = rx_time;
1217
1218                 _bt_convert_addr_string_to_type(dev_address.addr, address);
1219
1220                 memcpy(&params.device_address,
1221                         &dev_address, BLUETOOTH_ADDRESS_LENGTH);
1222
1223                 _bt_common_event_cb(BLUETOOTH_EVENT_LE_DATA_LENGTH_CHANGED,
1224                                 result, &params, event_info->cb, event_info->user_data);
1225         } else if (strcasecmp(signal_name, BT_PXP_PROPERTY_CHANGED) == 0) {
1226                 const char *address = NULL;
1227                 bluetooth_device_address_t dev_address = { {0} };
1228                 int role, type, level;
1229                 bt_pxp_property_changed_params_t params;
1230
1231                 BT_DBG("BT_PXP_PROPERTY_CHANGED");
1232
1233                 g_variant_get(parameters, "(isiii)", &result, &address, &role, &type, &level);
1234
1235                 _bt_convert_addr_string_to_type(dev_address.addr, address);
1236                 memcpy(&params.device_address, &dev_address, BLUETOOTH_ADDRESS_LENGTH);
1237                 params.role = role;
1238                 params.service_type = type;
1239                 params.alert_lvl = level;
1240
1241                 _bt_common_event_cb(BLUETOOTH_EVENT_PXP_PROPERTY_CHANGED,
1242                                 result, &params, event_info->cb, event_info->user_data);
1243         }
1244 }
1245
1246 void __bt_hid_event_filter(GDBusConnection *connection,
1247                                                  const gchar *sender_name,
1248                                                  const gchar *object_path,
1249                                                  const gchar *interface_name,
1250                                                  const gchar *signal_name,
1251                                                  GVariant *parameters,
1252                                                  gpointer user_data)
1253 {
1254         bt_event_info_t *event_info;
1255         int result = BLUETOOTH_ERROR_NONE;
1256
1257         event_info = (bt_event_info_t *)user_data;
1258         ret_if(event_info == NULL);
1259
1260         if (strcasecmp(object_path, BT_HID_PATH) != 0)
1261                 return;
1262         if (strcasecmp(interface_name, BT_EVENT_SERVICE) != 0)
1263                 return;
1264
1265         ret_if(signal_name == NULL);
1266
1267         if (strcasecmp(signal_name, BT_INPUT_CONNECTED) == 0) {
1268                 const char *address = NULL;
1269                 bluetooth_device_address_t dev_address = { {0} };
1270
1271                 g_variant_get(parameters, "(i&s)", &result, &address);
1272
1273                 _bt_convert_addr_string_to_type(dev_address.addr,
1274                                                 address);
1275
1276                 _bt_input_event_cb(BLUETOOTH_HID_CONNECTED,
1277                                 result, &dev_address,
1278                                 event_info->cb, event_info->user_data);
1279         } else if (strcasecmp(signal_name, BT_INPUT_DISCONNECTED) == 0) {
1280                 const char *address = NULL;
1281                 bluetooth_device_address_t dev_address = { {0} };
1282
1283                 g_variant_get(parameters, "(i&s)", &result, &address);
1284
1285                 BT_DBG("address: %s", address);
1286
1287                 _bt_convert_addr_string_to_type(dev_address.addr,
1288                                                 address);
1289
1290                 _bt_input_event_cb(BLUETOOTH_HID_DISCONNECTED,
1291                                 result, &dev_address,
1292                                 event_info->cb, event_info->user_data);
1293         }
1294 }
1295
1296 void __bt_headset_event_filter(GDBusConnection *connection,
1297                                                  const gchar *sender_name,
1298                                                  const gchar *object_path,
1299                                                  const gchar *interface_name,
1300                                                  const gchar *signal_name,
1301                                                  GVariant *parameters,
1302                                                  gpointer user_data)
1303 {
1304         bt_event_info_t *event_info;
1305         int result = BLUETOOTH_ERROR_NONE;
1306         event_info = (bt_event_info_t *)user_data;
1307         ret_if(event_info == NULL);
1308
1309         if (strcasecmp(object_path, BT_HEADSET_PATH) != 0)
1310                 return;
1311         if (strcasecmp(interface_name, BT_EVENT_SERVICE) != 0)
1312                 return;
1313
1314         ret_if(signal_name == NULL);
1315
1316         if (strcasecmp(signal_name, BT_HEADSET_CONNECTED) == 0) {
1317                 char *address = NULL;
1318
1319                 g_variant_get(parameters, "(i&s)", &result, &address);
1320
1321                 _bt_headset_event_cb(BLUETOOTH_EVENT_AG_CONNECTED,
1322                                 result, address,
1323                                 event_info->cb, event_info->user_data);
1324         } else if (strcasecmp(signal_name, BT_HEADSET_DISCONNECTED) == 0) {
1325                 char *address = NULL;
1326
1327                 g_variant_get(parameters, "(i&s)", &result, &address);
1328
1329                 _bt_headset_event_cb(BLUETOOTH_EVENT_AG_DISCONNECTED,
1330                                 result, address,
1331                                 event_info->cb, event_info->user_data);
1332         } else if (strcasecmp(signal_name, BT_STEREO_HEADSET_CONNECTED) == 0) {
1333                 char *address = NULL;
1334
1335                 g_variant_get(parameters, "(i&s)", &result, &address);
1336
1337                 _bt_headset_event_cb(BLUETOOTH_EVENT_AV_CONNECTED,
1338                                 result, address,
1339                                 event_info->cb, event_info->user_data);
1340         } else if (strcasecmp(signal_name, BT_STEREO_HEADSET_DISCONNECTED) == 0) {
1341                 char *address = NULL;
1342
1343                 g_variant_get(parameters, "(i&s)", &result, &address);
1344
1345                 _bt_headset_event_cb(BLUETOOTH_EVENT_AV_DISCONNECTED,
1346                                 result, address,
1347                                 event_info->cb, event_info->user_data);
1348         } else if (strcasecmp(signal_name, BT_A2DP_SOURCE_CONNECTED) == 0) {
1349                 char *address = NULL;
1350
1351                 g_variant_get(parameters, "(i&s)", &result, &address);
1352                 _bt_a2dp_source_event_cb(BLUETOOTH_EVENT_AV_SOURCE_CONNECTED,
1353                                                 result, address,
1354                                                 event_info->cb, event_info->user_data);
1355         } else if (strcasecmp(signal_name, BT_A2DP_SOURCE_DISCONNECTED) == 0) {
1356                 char *address = NULL;
1357
1358                 g_variant_get(parameters, "(i&s)", &result, &address);
1359
1360                 _bt_a2dp_source_event_cb(BLUETOOTH_EVENT_AV_SOURCE_DISCONNECTED,
1361                                                 result, address,
1362                                                 event_info->cb, event_info->user_data);
1363         } else if (strcasecmp(signal_name, BT_SPEAKER_GAIN) == 0) {
1364                 unsigned int gain;
1365                 guint16 spkr_gain;
1366                 char *address = NULL;
1367
1368                 g_variant_get(parameters, "(i&sq)", &result, &address,
1369                                                                 &spkr_gain);
1370                 gain = (unsigned int)spkr_gain;
1371
1372                 _bt_headset_event_cb(BLUETOOTH_EVENT_AG_SPEAKER_GAIN,
1373                                 result, &gain,
1374                                 event_info->cb, event_info->user_data);
1375         } else if (strcasecmp(signal_name, BT_MICROPHONE_GAIN) == 0) {
1376                 unsigned int gain;
1377                 guint16 mic_gain;
1378                 char *address = NULL;
1379
1380                 g_variant_get(parameters, "(i&sq)", &result,
1381                                                 &address, &mic_gain);
1382                 gain = (unsigned int)mic_gain;
1383
1384                 _bt_headset_event_cb(BLUETOOTH_EVENT_AG_MIC_GAIN,
1385                                 result, &gain,
1386                                 event_info->cb, event_info->user_data);
1387         }
1388 }
1389
1390 void __bt_hid_device_event_filter(GDBusConnection *connection,
1391                                                  const gchar *sender_name,
1392                                                  const gchar *object_path,
1393                                                  const gchar *interface_name,
1394                                                  const gchar *signal_name,
1395                                                  GVariant *parameters,
1396                                                  gpointer user_data)
1397 {
1398         bt_event_info_t *event_info;
1399         int result = BLUETOOTH_ERROR_NONE;
1400
1401         event_info = (bt_event_info_t *)user_data;
1402         ret_if(event_info == NULL);
1403         if (strcasecmp(object_path, BT_HID_DEVICE_PATH) != 0)
1404                 return;
1405         if (strcasecmp(interface_name, BT_EVENT_SERVICE) != 0)
1406                 return;
1407
1408         ret_if(signal_name == NULL);
1409
1410         if (strcasecmp(signal_name, BT_HID_DEVICE_CONNECTED) == 0) {
1411                 const char *address = NULL;
1412                 bluetooth_device_address_t dev_address = { {0} };
1413
1414                 g_variant_get(parameters, "(i&s)", &result, &address);
1415
1416                 _bt_convert_addr_string_to_type(dev_address.addr,
1417                                                 address);
1418
1419                 _bt_input_event_cb(BLUETOOTH_HID_DEVICE_CONNECTED,
1420                                 result, &dev_address,
1421                                 event_info->cb, event_info->user_data);
1422         } else if (strcasecmp(signal_name, BT_HID_DEVICE_DISCONNECTED) == 0) {
1423                 const char *address = NULL;
1424                 bluetooth_device_address_t dev_address = { {0} };
1425
1426                 g_variant_get(parameters, "(i&s)", &result, &address);
1427
1428                 BT_DBG("address: %s", address);
1429
1430                 _bt_convert_addr_string_to_type(dev_address.addr,
1431                                                 address);
1432
1433                 _bt_input_event_cb(BLUETOOTH_HID_DEVICE_DISCONNECTED,
1434                                 result, &dev_address,
1435                                 event_info->cb, event_info->user_data);
1436         } else if (strcasecmp(signal_name, BT_INPUT_HID_DEVICE_CONNECTED) == 0) {
1437                 BT_INFO_C("Type %s", g_variant_get_type_string(parameters));
1438                 const char *address = NULL;
1439                 bluetooth_device_address_t dev_address = { {0} };
1440
1441                 g_variant_get(parameters, "(i&s)", &result, &address);
1442
1443                 BT_DBG("address: %s", address);
1444                 _bt_convert_addr_string_to_type(dev_address.addr,
1445                                                 address);
1446                 int ctrl = -1, intr = -1;
1447                 _bt_hid_device_get_fd(address, &ctrl, &intr);
1448                 if (ctrl != -1 && intr != -1)
1449                         _bt_hid_new_connection(&dev_address, ctrl, intr);
1450                 else
1451                         BT_ERR("fd is invalid.(ctrl=%d, intr=%d)", ctrl, intr);
1452         } else if (strcasecmp(signal_name, BT_INPUT_HID_DEVICE_DISCONNECTED) == 0) {
1453                 const char *address = NULL;
1454                 g_variant_get(parameters, "(i&s)", &result, &address);
1455
1456                 BT_DBG("address: %s", address);
1457         }
1458 }
1459 void __bt_a2dp_source_event_filter(GDBusConnection *connection,
1460                                                  const gchar *sender_name,
1461                                                  const gchar *object_path,
1462                                                  const gchar *interface_name,
1463                                                  const gchar *signal_name,
1464                                                  GVariant *parameters,
1465                                                  gpointer user_data)
1466 {
1467         bt_event_info_t *event_info;
1468         int result = BLUETOOTH_ERROR_NONE;
1469         event_info = (bt_event_info_t *)user_data;
1470         ret_if(event_info == NULL);
1471
1472         if (strcasecmp(object_path, BT_A2DP_SOURCE_PATH) != 0)
1473                 return;
1474         if (strcasecmp(interface_name, BT_EVENT_SERVICE) != 0)
1475                 return;
1476
1477         ret_if(signal_name == NULL);
1478
1479         if (strcasecmp(signal_name, BT_A2DP_SOURCE_CONNECTED) == 0) {
1480                 char *address = NULL;
1481
1482                 g_variant_get(parameters, "(i&s)", &result, &address);
1483                 _bt_a2dp_source_event_cb(BLUETOOTH_EVENT_AV_SOURCE_CONNECTED,
1484                                                 result, address,
1485                                                 event_info->cb, event_info->user_data);
1486         } else if (strcasecmp(signal_name, BT_A2DP_SOURCE_DISCONNECTED) == 0) {
1487                 char *address = NULL;
1488
1489                 g_variant_get(parameters, "(i&s)", &result, &address);
1490
1491                 _bt_a2dp_source_event_cb(BLUETOOTH_EVENT_AV_SOURCE_DISCONNECTED,
1492                                                 result, address,
1493                                                 event_info->cb, event_info->user_data);
1494         }
1495 }
1496
1497 void __bt_network_event_filter(GDBusConnection *connection,
1498                                                  const gchar *sender_name,
1499                                                  const gchar *object_path,
1500                                                  const gchar *interface_name,
1501                                                  const gchar *signal_name,
1502                                                  GVariant *parameters,
1503                                                  gpointer user_data)
1504 {
1505         bt_event_info_t *event_info;
1506         int result = BLUETOOTH_ERROR_NONE;
1507         event_info = (bt_event_info_t *)user_data;
1508         ret_if(event_info == NULL);
1509
1510         if (strcasecmp(object_path, BT_NETWORK_PATH) != 0)
1511                 return;
1512         if (strcasecmp(interface_name, BT_EVENT_SERVICE) != 0)
1513                 return;
1514
1515         ret_if(signal_name == NULL);
1516
1517         if (strcasecmp(signal_name, BT_NETWORK_CONNECTED) == 0) {
1518                 const char *address = NULL;
1519                 bluetooth_device_address_t dev_address = { {0} };
1520
1521                 g_variant_get(parameters, "(i&s)", &result, &address);
1522
1523                 _bt_convert_addr_string_to_type(dev_address.addr,
1524                                                 address);
1525
1526                 _bt_common_event_cb(BLUETOOTH_EVENT_NETWORK_CONNECTED,
1527                                 result, &dev_address,
1528                                 event_info->cb, event_info->user_data);
1529         } else if (strcasecmp(signal_name, BT_NETWORK_DISCONNECTED) == 0) {
1530                 const char *address = NULL;
1531                 bluetooth_device_address_t dev_address = { {0} };
1532
1533                 g_variant_get(parameters, "(i&s)", &result, &address);
1534
1535                 _bt_convert_addr_string_to_type(dev_address.addr,
1536                                                 address);
1537
1538                 _bt_common_event_cb(BLUETOOTH_EVENT_NETWORK_DISCONNECTED,
1539                                 result, &dev_address,
1540                                 event_info->cb, event_info->user_data);
1541         } else if (strcasecmp(signal_name, BT_NETWORK_SERVER_CONNECTED) == 0) {
1542                 const char *device = NULL;
1543                 const char *address = NULL;
1544                 bluetooth_network_device_info_t network_info;
1545
1546                 g_variant_get(parameters, "(i&s&s)", &result,
1547                                                         &device, &address);
1548
1549                 memset(&network_info, 0x00, sizeof(bluetooth_network_device_info_t));
1550
1551                 _bt_convert_addr_string_to_type(network_info.device_address.addr,
1552                                                 address);
1553
1554                 _bt_print_device_address_t(&network_info.device_address);
1555                 g_strlcpy(network_info.interface_name, device,
1556                                         sizeof(network_info.interface_name));
1557
1558                 DBG_SECURE("Interface: %s", network_info.interface_name);
1559
1560                 _bt_common_event_cb(BLUETOOTH_EVENT_NETWORK_SERVER_CONNECTED,
1561                                 result, &network_info,
1562                                 event_info->cb, event_info->user_data);
1563         } else if (strcasecmp(signal_name, BT_NETWORK_SERVER_DISCONNECTED) == 0) {
1564                 const char *device = NULL;
1565                 const char *address = NULL;
1566                 bluetooth_network_device_info_t network_info;
1567
1568                 g_variant_get(parameters, "(i&s&s)", &result, &device, &address);
1569
1570                 memset(&network_info, 0x00, sizeof(bluetooth_network_device_info_t));
1571
1572                 _bt_convert_addr_string_to_type(network_info.device_address.addr,
1573                                                 address);
1574
1575                 _bt_print_device_address_t(&network_info.device_address);
1576
1577                 _bt_common_event_cb(BLUETOOTH_EVENT_NETWORK_SERVER_DISCONNECTED,
1578                                 result, &network_info,
1579                                 event_info->cb, event_info->user_data);
1580         }
1581 }
1582
1583 void __bt_avrcp_event_filter(GDBusConnection *connection,
1584                                                  const gchar *sender_name,
1585                                                  const gchar *object_path,
1586                                                  const gchar *interface_name,
1587                                                  const gchar *signal_name,
1588                                                  GVariant *parameters,
1589                                                  gpointer user_data)
1590 {
1591         bt_event_info_t *event_info;
1592         int result = BLUETOOTH_ERROR_NONE;
1593         event_info = (bt_event_info_t *)user_data;
1594         ret_if(event_info == NULL);
1595
1596         if (strcasecmp(object_path, BT_AVRCP_PATH) != 0)
1597                 return;
1598         if (strcasecmp(interface_name, BT_EVENT_SERVICE) != 0)
1599                 return;
1600
1601         ret_if(signal_name == NULL);
1602
1603         if (strcasecmp(signal_name, BT_AVRCP_CONNECTED) == 0) {
1604                 char *address = NULL;
1605
1606                 g_variant_get(parameters, "(i&s)", &result, &address);
1607
1608                 _bt_avrcp_event_cb(BLUETOOTH_EVENT_AVRCP_CONNECTED,
1609                                 result, address,
1610                                 event_info->cb, event_info->user_data);
1611         } else if (strcasecmp(signal_name, BT_AVRCP_DISCONNECTED) == 0) {
1612                 char *address = NULL;
1613
1614                 g_variant_get(parameters, "(i&s)", &result, &address);
1615
1616                 _bt_avrcp_event_cb(BLUETOOTH_EVENT_AVRCP_DISCONNECTED,
1617                                 result, address,
1618                                 event_info->cb, event_info->user_data);
1619         } else if (strcasecmp(signal_name, BT_MEDIA_SHUFFLE_STATUS) == 0) {
1620                 unsigned int status;
1621
1622                 g_variant_get(parameters, "(u)", &status);
1623                 _bt_avrcp_event_cb(BLUETOOTH_EVENT_AVRCP_SETTING_SHUFFLE_STATUS,
1624                                 result, &status,
1625                                 event_info->cb, event_info->user_data);
1626         } else if (strcasecmp(signal_name, BT_MEDIA_EQUALIZER_STATUS) == 0) {
1627                 unsigned int status;
1628
1629                 g_variant_get(parameters, "(u)", &status);
1630                 _bt_avrcp_event_cb(BLUETOOTH_EVENT_AVRCP_SETTING_EQUALIZER_STATUS,
1631                                 result, &status,
1632                                 event_info->cb, event_info->user_data);
1633         } else if (strcasecmp(signal_name, BT_MEDIA_REPEAT_STATUS) == 0) {
1634                 unsigned int status;
1635
1636                 g_variant_get(parameters, "(u)", &status);
1637                 _bt_avrcp_event_cb(BLUETOOTH_EVENT_AVRCP_SETTING_REPEAT_STATUS,
1638                                 result, &status,
1639                                 event_info->cb, event_info->user_data);
1640         }  else if (strcasecmp(signal_name, BT_MEDIA_SCAN_STATUS) == 0) {
1641                 unsigned int status;
1642
1643                 g_variant_get(parameters, "(u)", &status);
1644                 _bt_avrcp_event_cb(BLUETOOTH_EVENT_AVRCP_SETTING_SCAN_STATUS,
1645                                 result, &status,
1646                                 event_info->cb, event_info->user_data);
1647         }  else if (strcasecmp(signal_name, BT_MEDIA_DELAY_CHANGE) == 0) {
1648                 unsigned int delay;
1649
1650                 g_variant_get(parameters, "(u)", &delay);
1651                 _bt_avrcp_event_cb(BLUETOOTH_EVENT_AVRCP_DELAY_CHANGED,
1652                                 result, &delay,
1653                                 event_info->cb, event_info->user_data);
1654         }
1655 }
1656
1657 void __bt_avrcp_control_event_filter(GDBusConnection *connection,
1658                                                 const gchar *sender_name,
1659                                                 const gchar *object_path,
1660                                                 const gchar *interface_name,
1661                                                 const gchar *signal_name,
1662                                                 GVariant *parameters,
1663                                                 gpointer user_data)
1664 {
1665         bt_event_info_t *event_info;
1666         int result = BLUETOOTH_ERROR_NONE;
1667         event_info = (bt_event_info_t *)user_data;
1668         ret_if(event_info == NULL);
1669
1670         if (strcasecmp(object_path, BT_AVRCP_CONTROL_PATH) != 0)
1671                 return;
1672         if (strcasecmp(interface_name, BT_EVENT_SERVICE) != 0)
1673                 return;
1674
1675         ret_if(signal_name == NULL);
1676
1677         if (strcasecmp(signal_name, BT_AVRCP_CONNECTED) == 0) {
1678                 char *address = NULL;
1679
1680                 g_variant_get(parameters, "(i&s)", &result, &address);
1681
1682                 _bt_avrcp_event_cb(BLUETOOTH_EVENT_AVRCP_CONTROL_CONNECTED,
1683                                 result, address,
1684                                 event_info->cb, event_info->user_data);
1685         } else if (strcasecmp(signal_name, BT_AVRCP_DISCONNECTED) == 0) {
1686                 char *address = NULL;
1687
1688                 g_variant_get(parameters, "(i&s)", &result, &address);
1689
1690                 _bt_avrcp_event_cb(BLUETOOTH_EVENT_AVRCP_CONTROL_DISCONNECTED,
1691                                 result, address,
1692                                 event_info->cb, event_info->user_data);
1693         } else if (strcasecmp(signal_name, BT_MEDIA_SHUFFLE_STATUS) == 0) {
1694                 unsigned int status;
1695
1696                 g_variant_get(parameters, "(u)", &status);
1697                 _bt_avrcp_event_cb(BLUETOOTH_EVENT_AVRCP_CONTROL_SHUFFLE_STATUS,
1698                                 result, &status,
1699                                 event_info->cb, event_info->user_data);
1700         } else if (strcasecmp(signal_name, BT_MEDIA_EQUALIZER_STATUS) == 0) {
1701                 unsigned int status;
1702
1703                 g_variant_get(parameters, "(u)", &status);
1704                 _bt_avrcp_event_cb(BLUETOOTH_EVENT_AVRCP_CONTROL_EQUALIZER_STATUS,
1705                                 result, &status,
1706                                 event_info->cb, event_info->user_data);
1707         } else if (strcasecmp(signal_name, BT_MEDIA_REPEAT_STATUS) == 0) {
1708                 unsigned int status;
1709
1710                 g_variant_get(parameters, "(u)", &status);
1711                 _bt_avrcp_event_cb(BLUETOOTH_EVENT_AVRCP_CONTROL_REPEAT_STATUS,
1712                                 result, &status,
1713                                 event_info->cb, event_info->user_data);
1714         }  else if (strcasecmp(signal_name, BT_MEDIA_SCAN_STATUS) == 0) {
1715                 unsigned int status;
1716
1717                 g_variant_get(parameters, "(u)", &status);
1718                 _bt_avrcp_event_cb(BLUETOOTH_EVENT_AVRCP_CONTROL_SCAN_STATUS,
1719                                 result, &status,
1720                                 event_info->cb, event_info->user_data);
1721         } else if (strcasecmp(signal_name, BT_MEDIA_PLAY_STATUS) == 0) {
1722                 unsigned int status;
1723
1724                 g_variant_get(parameters, "(u)", &status);
1725                 _bt_avrcp_event_cb(BLUETOOTH_EVENT_AVRCP_PLAY_STATUS_CHANGED,
1726                                 result, &status,
1727                                 event_info->cb, event_info->user_data);
1728         } else if (strcasecmp(signal_name, BT_MEDIA_POSITION_STATUS) == 0) {
1729                 unsigned int status;
1730
1731                 g_variant_get(parameters, "(u)", &status);
1732                 _bt_avrcp_event_cb(BLUETOOTH_EVENT_AVRCP_SONG_POSITION_STATUS,
1733                                 result, &status,
1734                                 event_info->cb, event_info->user_data);
1735         } else if (strcasecmp(signal_name, BT_MEDIA_TRACK_CHANGE) == 0) {
1736                 media_metadata_attributes_t metadata;
1737                 GVariant *title = NULL;
1738                 GVariant *artist = NULL;
1739                 GVariant *album = NULL;
1740                 GVariant *genre = NULL;
1741
1742                 unsigned int total_tracks;
1743                 unsigned int number;
1744                 unsigned int duration;
1745
1746                 g_variant_get(parameters, "(@ay@ay@ay@ayuuu)",
1747                                 &title, &artist, &album, &genre,
1748                                 &total_tracks, &number, &duration);
1749
1750                 metadata.title = g_variant_get_bytestring(title);
1751                 metadata.artist = g_variant_get_bytestring(artist);
1752                 metadata.album = g_variant_get_bytestring(album);
1753                 metadata.genre = g_variant_get_bytestring(genre);
1754                 metadata.total_tracks = total_tracks;
1755                 metadata.number = number;
1756                 metadata.duration = duration;
1757
1758                 _bt_avrcp_event_cb(BLUETOOTH_EVENT_AVRCP_TRACK_CHANGED,
1759                                 result, &metadata,
1760                                 event_info->cb, event_info->user_data);
1761
1762                 g_variant_unref(title);
1763                 g_variant_unref(artist);
1764                 g_variant_unref(album);
1765                 g_variant_unref(genre);
1766         }
1767 }
1768
1769 void __bt_opp_client_event_filter(GDBusConnection *connection,
1770                                                  const gchar *sender_name,
1771                                                  const gchar *object_path,
1772                                                  const gchar *interface_name,
1773                                                  const gchar *signal_name,
1774                                                  GVariant *parameters,
1775                                                  gpointer user_data)
1776 {
1777         bt_event_info_t *event_info;
1778         int result = BLUETOOTH_ERROR_NONE;
1779         event_info = (bt_event_info_t *)user_data;
1780         ret_if(event_info == NULL);
1781
1782         if (strcasecmp(object_path, BT_OPP_CLIENT_PATH) != 0)
1783                 return;
1784         if (strcasecmp(interface_name, BT_EVENT_SERVICE) != 0)
1785                 return;
1786
1787         ret_if(signal_name == NULL);
1788
1789         if (strcasecmp(signal_name, BT_OPP_CONNECTED) == 0) {
1790                 const char *address = NULL;
1791                 int request_id = 0;
1792                 bluetooth_device_address_t dev_address = { {0} };
1793
1794                 g_variant_get(parameters, "(i&si)", &result,
1795                                                 &address, &request_id);
1796
1797                 if (__bt_is_request_id_exist(request_id) == FALSE) {
1798                         BT_ERR("Different request id!");
1799                         return;
1800                 }
1801
1802                 _bt_convert_addr_string_to_type(dev_address.addr,
1803                                                 address);
1804
1805                 _bt_common_event_cb(BLUETOOTH_EVENT_OPC_CONNECTED,
1806                                 result, &dev_address,
1807                                 event_info->cb, event_info->user_data);
1808
1809                 if (result != BLUETOOTH_ERROR_NONE)
1810                         __bt_remove_push_request_id(request_id);
1811
1812         } else if (strcasecmp(signal_name, BT_OPP_DISCONNECTED) == 0) {
1813                 const char *address = NULL;
1814                 int request_id = 0;
1815                 bluetooth_device_address_t dev_address = { {0} };
1816
1817                 g_variant_get(parameters, "(i&si)", &result, &address,
1818                                                         &request_id);
1819
1820                 if (__bt_is_request_id_exist(request_id) == FALSE) {
1821                         BT_ERR("Different request id!");
1822                         return;
1823                 }
1824
1825                 _bt_convert_addr_string_to_type(dev_address.addr,
1826                                                 address);
1827
1828                 _bt_common_event_cb(BLUETOOTH_EVENT_OPC_DISCONNECTED,
1829                                 result, &dev_address,
1830                                 event_info->cb, event_info->user_data);
1831
1832                 __bt_remove_push_request_id(request_id);
1833         } else if (strcasecmp(signal_name, BT_TRANSFER_STARTED) == 0) {
1834                 const char *file_name = NULL;
1835                 const char *device_addr = NULL;
1836                 int request_id = 0;
1837                 guint64 size = 0;
1838                 bt_opc_transfer_info_t transfer_info;
1839
1840                 g_variant_get(parameters, "(i&s&sti)", &result, &device_addr, &file_name,
1841                                                 &size, &request_id);
1842
1843                 if (__bt_is_request_id_exist(request_id) == FALSE) {
1844                         BT_ERR("Different request id!");
1845                         return;
1846                 }
1847
1848                 memset(&transfer_info, 0x00, sizeof(bt_opc_transfer_info_t));
1849
1850                 transfer_info.filename = g_strdup(file_name);
1851                 transfer_info.device_addr = g_strdup(device_addr);
1852                 transfer_info.size = size;
1853
1854                 _bt_common_event_cb(BLUETOOTH_EVENT_OPC_TRANSFER_STARTED,
1855                                 result, &transfer_info,
1856                                 event_info->cb, event_info->user_data);
1857
1858                 g_free(transfer_info.device_addr);
1859                 g_free(transfer_info.filename);
1860         } else if (strcasecmp(signal_name, BT_TRANSFER_PROGRESS) == 0) {
1861                 const char *file_name = NULL;
1862                 int request_id = 0;
1863                 guint64 size = 0;
1864                 int progress = 0;
1865                 bt_opc_transfer_info_t transfer_info;
1866
1867                 g_variant_get(parameters, "(i&stii)", &result,
1868                         &file_name, &size, &progress, &request_id);
1869
1870                 if (__bt_is_request_id_exist(request_id) == FALSE) {
1871                         BT_ERR("Different request id!");
1872                         return;
1873                 }
1874
1875                 memset(&transfer_info, 0x00, sizeof(bt_opc_transfer_info_t));
1876
1877                 transfer_info.filename = g_strdup(file_name);
1878                 transfer_info.size = size;
1879                 transfer_info.percentage = progress;
1880
1881                 _bt_common_event_cb(BLUETOOTH_EVENT_OPC_TRANSFER_PROGRESS,
1882                                 result, &transfer_info,
1883                                 event_info->cb, event_info->user_data);
1884
1885                 g_free(transfer_info.filename);
1886         } else if (strcasecmp(signal_name, BT_TRANSFER_COMPLETED) == 0) {
1887                 const char *file_name = NULL;
1888                 const char *device_addr = NULL;
1889                 int request_id = 0;
1890                 guint64 size = 0;
1891                 bt_opc_transfer_info_t transfer_info;
1892
1893                 g_variant_get(parameters, "(i&s&sti)", &result, &device_addr,
1894                                         &file_name, &size, &request_id);
1895
1896                 if (__bt_is_request_id_exist(request_id) == FALSE) {
1897                         BT_ERR("Different request id!");
1898                         return;
1899                 }
1900
1901                 memset(&transfer_info, 0x00, sizeof(bt_opc_transfer_info_t));
1902
1903                 transfer_info.device_addr = g_strdup(device_addr);
1904                 transfer_info.filename = g_strdup(file_name);
1905                 transfer_info.size = size;
1906
1907                 _bt_common_event_cb(BLUETOOTH_EVENT_OPC_TRANSFER_COMPLETE,
1908                                 result, &transfer_info,
1909                                 event_info->cb, event_info->user_data);
1910
1911                 g_free(transfer_info.device_addr);
1912                 g_free(transfer_info.filename);
1913         }
1914 }
1915
1916 void __bt_opp_server_event_filter(GDBusConnection *connection,
1917                                                  const gchar *sender_name,
1918                                                  const gchar *object_path,
1919                                                  const gchar *interface_name,
1920                                                  const gchar *signal_name,
1921                                                  GVariant *parameters,
1922                                                  gpointer user_data)
1923 {
1924         bt_event_info_t *event_info;
1925         int result = BLUETOOTH_ERROR_NONE;
1926         event_info = (bt_event_info_t *)user_data;
1927         ret_if(event_info == NULL);
1928
1929         if (strcasecmp(object_path, BT_OPP_SERVER_PATH) != 0)
1930                 return;
1931         if (strcasecmp(interface_name, BT_EVENT_SERVICE) != 0)
1932                 return;
1933
1934         ret_if(signal_name == NULL);
1935
1936         if (strcasecmp(signal_name, BT_TRANSFER_AUTHORIZED) == 0) {
1937                 /* Native only event */
1938                 const char *file_name = NULL;
1939                 const char *address = NULL;
1940                 const char *device_name = NULL;
1941                 guint64 size = 0;
1942                 bt_obex_server_authorize_into_t auth_info;
1943
1944                 g_variant_get(parameters, "(i&st&s&s)", &result, &file_name, &size,
1945                                 &address, &device_name);
1946
1947                 /* OSP server: Don't get this event */
1948                 ret_if(obex_server_id == BT_CUSTOM_SERVER);
1949
1950                 memset(&auth_info, 0x00, sizeof(bt_obex_server_authorize_into_t));
1951
1952                 auth_info.filename = g_strdup(file_name);
1953                 auth_info.length = size;
1954                 auth_info.address = g_strdup(address);
1955                 auth_info.name = g_strdup(device_name);
1956                 _bt_common_event_cb(BLUETOOTH_EVENT_OBEX_SERVER_TRANSFER_AUTHORIZE,
1957                                 result, &auth_info,
1958                                 event_info->cb, event_info->user_data);
1959
1960                 g_free(auth_info.filename);
1961                 g_free(auth_info.address);
1962                 g_free(auth_info.name);
1963         } else if (strcasecmp(signal_name, BT_CONNECTION_AUTHORIZED) == 0) {
1964                 /* OSP only event */
1965                 const char *address = NULL;
1966                 const char *name = NULL;
1967                 bluetooth_device_address_t dev_address = { {0} };
1968
1969                 g_variant_get(parameters, "(i&s&s)", &result, &address, &name);
1970
1971                 /* Native server: Don't get this event */
1972                 ret_if(obex_server_id == BT_NATIVE_SERVER);
1973
1974                 _bt_convert_addr_string_to_type(dev_address.addr,
1975                                                 address);
1976
1977                 _bt_common_event_cb(BLUETOOTH_EVENT_OBEX_SERVER_CONNECTION_AUTHORIZE,
1978                                 result, &dev_address,
1979                                 event_info->cb, event_info->user_data);
1980         } else if (strcasecmp(signal_name, BT_TRANSFER_CONNECTED) == 0) {
1981                 bt_obex_server_connection_info_t conn_info = {0, };
1982                 char *address = NULL;
1983                 char *name = NULL;
1984                 int transfer_id = -1;
1985                 g_variant_get(parameters, "(i&s&si)", &result,
1986                                 &address, &name, &transfer_id);
1987
1988                 conn_info.address = g_strdup(address);
1989                 conn_info.device_name = g_strdup(name);
1990                 conn_info.transfer_id = transfer_id;
1991
1992                 _bt_common_event_cb(BLUETOOTH_EVENT_OBEX_SERVER_TRANSFER_CONNECTED,
1993                                         result, &conn_info, event_info->cb,
1994                                         event_info->user_data);
1995
1996                 g_free(conn_info.address);
1997                 g_free(conn_info.device_name);
1998         } else if (strcasecmp(signal_name, BT_TRANSFER_DISCONNECTED) == 0) {
1999                 bt_obex_server_transfer_info_t transfer_info = {0, };
2000                 char *address = NULL;
2001                 int transfer_id = -1;
2002                 g_variant_get(parameters, "(i&si)", &result, &address, &transfer_id);
2003                 DBG_SECURE("address: %s, transfer_id: %d", address, transfer_id);
2004
2005                 transfer_info.address = g_strdup(address);
2006                 transfer_info.transfer_id = transfer_id;
2007
2008                 _bt_common_event_cb(BLUETOOTH_EVENT_OBEX_SERVER_TRANSFER_DISCONNECTED,
2009                                         result, &transfer_info, event_info->cb,
2010                                         event_info->user_data);
2011                 g_free(transfer_info.address);
2012         } else if (strcasecmp(signal_name, BT_TRANSFER_STARTED) == 0) {
2013                 const char *device_name = NULL;
2014                 const char *file_name = NULL;
2015                 const char *type = NULL;
2016                 const char *address = NULL;
2017                 GVariantIter *iter = NULL;
2018                 int i = 0;
2019                 guchar byte;
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&stii(ay))", &result, &device_name,
2026                         &file_name, &type, &address, &size, &transfer_id, &server_type, &iter);
2027
2028                 /* Other server's event */
2029                 ret_if(obex_server_id != server_type &&
2030                         server_type != BT_FTP_SERVER);
2031
2032                 memset(&transfer_info, 0x00, sizeof(bt_obex_server_transfer_info_t));
2033
2034                 transfer_info.contact_auth_info = g_malloc0(sizeof(unsigned char) * 5);
2035
2036                 for (i = 0; i < 5 && g_variant_iter_loop(iter, "y", &byte); ++i)
2037                         transfer_info.contact_auth_info[i] = byte;
2038
2039                 transfer_info.device_name = g_strdup(device_name);
2040                 transfer_info.filename = g_strdup(file_name);
2041                 transfer_info.type = g_strdup(type);
2042                 transfer_info.address = g_strdup(address);
2043                 transfer_info.file_size = size;
2044                 transfer_info.transfer_id = transfer_id;
2045                 transfer_info.server_type = (server_type == BT_FTP_SERVER) ?
2046                                                 FTP_SERVER : OPP_SERVER;
2047
2048                 _bt_common_event_cb(BLUETOOTH_EVENT_OBEX_SERVER_TRANSFER_STARTED,
2049                                 result, &transfer_info,
2050                                 event_info->cb, event_info->user_data);
2051
2052                 g_free(transfer_info.filename);
2053                 g_free(transfer_info.type);
2054                 g_free(transfer_info.device_name);
2055                 g_free(transfer_info.address);
2056                 g_free(transfer_info.contact_auth_info);
2057                 g_variant_iter_free(iter);
2058         } else if (strcasecmp(signal_name, BT_TRANSFER_PROGRESS) == 0) {
2059                 const char *file_name = NULL;
2060                 const char *type = NULL;
2061                 const char *device_name = NULL;
2062                 const char *address = NULL;
2063                 int transfer_id = 0;
2064                 int progress = 0;
2065                 int server_type = 0; /* bt_server_type_t */
2066                 guint64 size = 0;
2067                 bt_obex_server_transfer_info_t transfer_info;
2068
2069                 g_variant_get(parameters, "(i&s&s&s&stiii)", &result, &file_name,
2070                                                 &type, &device_name, &address, &size, &transfer_id,
2071                                                 &progress, &server_type);
2072
2073                 /* Other server's event */
2074                 ret_if(obex_server_id != server_type &&
2075                         server_type != BT_FTP_SERVER);
2076
2077                 memset(&transfer_info, 0x00, sizeof(bt_obex_server_transfer_info_t));
2078
2079                 transfer_info.filename = g_strdup(file_name);
2080                 transfer_info.type = g_strdup(type);
2081                 transfer_info.device_name = g_strdup(device_name);
2082                 transfer_info.address = g_strdup(address);
2083                 transfer_info.file_size = size;
2084                 transfer_info.transfer_id = transfer_id;
2085                 transfer_info.percentage = progress;
2086                 transfer_info.server_type = (server_type == BT_FTP_SERVER) ?
2087                                                 FTP_SERVER : OPP_SERVER;
2088
2089                 _bt_common_event_cb(BLUETOOTH_EVENT_OBEX_SERVER_TRANSFER_PROGRESS,
2090                                 result, &transfer_info,
2091                                 event_info->cb, event_info->user_data);
2092
2093                 g_free(transfer_info.filename);
2094                 g_free(transfer_info.device_name);
2095                 g_free(transfer_info.address);
2096                 g_free(transfer_info.type);
2097         } else if (strcasecmp(signal_name, BT_TRANSFER_COMPLETED) == 0) {
2098                 const char *file_name = NULL;
2099                 const char *device_name = NULL;
2100                 const char *address = NULL;
2101                 const char *type = NULL;
2102                 const char *file_path;
2103                 int transfer_id = 0;
2104                 int server_type = 0; /* bt_server_type_t */
2105                 guint64 size = 0;
2106                 bt_obex_server_transfer_info_t transfer_info;
2107
2108                 g_variant_get(parameters, "(i&s&s&s&s&stii)", &result, &file_name,
2109                                         &type, &device_name, &file_path, &address, &size,
2110                                         &transfer_id, &server_type);
2111
2112                 /* Other server's event */
2113                 ret_if(obex_server_id != server_type &&
2114                         server_type != BT_FTP_SERVER);
2115
2116                 memset(&transfer_info, 0x00, sizeof(bt_obex_server_transfer_info_t));
2117
2118                 transfer_info.filename = g_strdup(file_name);
2119                 transfer_info.type = g_strdup(type);
2120                 transfer_info.device_name = g_strdup(device_name);
2121                 transfer_info.file_path = g_strdup(file_path);
2122                 transfer_info.address = g_strdup(address);
2123                 transfer_info.file_size = size;
2124                 transfer_info.transfer_id = transfer_id;
2125                 transfer_info.server_type = (server_type == BT_FTP_SERVER) ?
2126                                                 FTP_SERVER : OPP_SERVER;
2127
2128                 _bt_common_event_cb(BLUETOOTH_EVENT_OBEX_SERVER_TRANSFER_COMPLETED,
2129                                 result, &transfer_info,
2130                                 event_info->cb, event_info->user_data);
2131
2132                 g_free(transfer_info.filename);
2133                 g_free(transfer_info.type);
2134                 g_free(transfer_info.device_name);
2135                 g_free(transfer_info.address);
2136                 g_free(transfer_info.file_path);
2137         }
2138 }
2139
2140 void __bt_map_client_event_filter(GDBusConnection *connection,
2141                                                  const gchar *sender_name,
2142                                                  const gchar *object_path,
2143                                                  const gchar *interface_name,
2144                                                  const gchar *signal_name,
2145                                                  GVariant *parameters,
2146                                                  gpointer user_data)
2147 {
2148         BT_DBG("Entered __bt_map_client_event_filter");
2149         bt_event_info_t *event_info;
2150         int result = BLUETOOTH_ERROR_NONE;
2151         event_info = (bt_event_info_t *)user_data;
2152         ret_if(event_info == NULL);
2153
2154         if (strcasecmp(object_path, BT_MAP_CLIENT_PATH) != 0)
2155                 return;
2156         if (strcasecmp(interface_name, BT_EVENT_SERVICE) != 0)
2157                 return;
2158
2159         ret_if(signal_name == NULL);
2160
2161         if (strcasecmp(signal_name, BT_MAP_CONNECTED) == 0) {
2162                 const char *address = NULL;
2163                 int request_id = 0;
2164                 bluetooth_device_address_t dev_address = { {0} };
2165
2166                 g_variant_get(parameters, "(i&si)", &result,
2167                                                 &address, &request_id);
2168
2169                 if (__bt_is_request_id_exist(request_id) == FALSE) {
2170                         BT_ERR("Different request id!");
2171                         return;
2172                 }
2173
2174                 _bt_convert_addr_string_to_type(dev_address.addr,
2175                                                 address);
2176
2177                 _bt_common_event_cb(BLUETOOTH_EVENT_MAP_CONNECTED,
2178                                 result, &dev_address,
2179                                 event_info->cb, event_info->user_data);
2180
2181                 if (result != BLUETOOTH_ERROR_NONE)
2182                         __bt_remove_push_request_id(request_id);
2183         } else if (strcasecmp(signal_name, BT_MAP_DISCONNECTED) == 0) {
2184                 const char *address = NULL;
2185                 int request_id = 0;
2186                 bluetooth_device_address_t dev_address = { {0} };
2187
2188                 g_variant_get(parameters, "(i&si)", &result, &address,
2189                                 &request_id);
2190
2191                 if (__bt_is_request_id_exist(request_id) == FALSE) {
2192                         BT_ERR("Different request id!");
2193                         return;
2194                 }
2195
2196                 _bt_convert_addr_string_to_type(dev_address.addr,
2197                                 address);
2198
2199                 _bt_common_event_cb(BLUETOOTH_EVENT_MAP_DISCONNECTED,
2200                                 result, &dev_address,
2201                                 event_info->cb, event_info->user_data);
2202
2203                 __bt_remove_push_request_id(request_id);
2204         } else if (strcasecmp(signal_name, BT_MAP_LIST_FOLDERS_COMPLETE) == 0) {
2205                 int request_id = 0;
2206                 GVariant* folder_list_var = NULL;
2207
2208                 g_variant_get(parameters, "(iiv)", &result, &request_id, &folder_list_var);
2209                 if (__bt_is_request_id_exist(request_id) == FALSE) {
2210                         BT_ERR("Different request id!");
2211                         return;
2212                 }
2213
2214                 GVariantIter* iter;
2215
2216                 bt_map_client_folders_s folders_struct = {0,};
2217                 g_variant_get(folder_list_var, "(aa{sv})", &iter);
2218
2219                 folders_struct.size = g_variant_iter_n_children(iter);
2220                 folders_struct.names = (char**) g_malloc0(folders_struct.size * sizeof(*(folders_struct.names)));
2221                 BT_DBG("g_variant_iter_n_children: %lli", (long long int)folders_struct.size);
2222                 GVariantIter* res = NULL;
2223                 int i = 0;
2224                 while (g_variant_iter_loop(iter, "a{sv}", &res)) {
2225                         char* key = NULL;
2226                         GVariant* value = NULL;
2227                         while (g_variant_iter_loop(res, "{sv}", &key, &value)) {
2228                                 char* string_value = NULL;
2229                                 g_variant_get(value, "s", &string_value);
2230                                 BT_DBG("got folder name: %s", string_value);
2231                                 folders_struct.names[i] = strdup(string_value);
2232                         }
2233                         ++i;
2234                 }
2235                 _bt_common_event_cb(BLUETOOTH_EVENT_MAP_LIST_FOLDERS_COMPLETE,
2236                                 result, &folders_struct,
2237                                 event_info->cb, event_info->user_data);
2238
2239                 __bt_remove_push_request_id(request_id);
2240
2241                 // freeing resources
2242                 while (--i >= 0) {
2243                         free(folders_struct.names[i]);
2244                         folders_struct.names[i] = NULL;
2245                 }
2246                 g_free(folders_struct.names);
2247
2248                 g_variant_unref(folder_list_var);
2249
2250         } else if (strcasecmp(signal_name, BT_MAP_FILTER_FIELDS_COMPLETE) == 0) {
2251                 BT_DBG("BT_MAP_LIST_FOLDERS_COMPLETE");
2252
2253                 GVariant *value;
2254                 int request_id = 0;
2255                 int i = 0;
2256                 bt_map_list_filter_fields_info_t fields_info = {0,};
2257
2258                 g_variant_get(parameters, "(ivi)", &result, &value, &request_id);
2259
2260                 if (__bt_is_request_id_exist(request_id) == FALSE) {
2261                         BT_ERR("Different request id!");
2262                         return;
2263                 }
2264
2265                 if (value) {
2266                         GVariantIter *iter = NULL;
2267                         g_variant_get(value, "(as)", &iter);
2268                         fields_info.size  = g_variant_iter_n_children(iter);
2269                         char* field = NULL;
2270
2271                         fields_info.fields = g_malloc0(fields_info.size * sizeof(char*));
2272                         while (g_variant_iter_loop(iter, "s", &field)) {
2273                                 fields_info.fields[i] = strdup(field);
2274                                 i++;
2275                         }
2276                 }
2277
2278                 _bt_common_event_cb(BLUETOOTH_EVENT_MAP_LIST_FILTER_FIELD_COMPLETE,
2279                                 request_id, &fields_info,
2280                                 event_info->cb, event_info->user_data);
2281
2282                 while (--i >= 0) {
2283                         free(fields_info.fields[i]);
2284                         fields_info.fields[i] = NULL;
2285                 }
2286                 g_free(fields_info.fields);
2287
2288                 __bt_remove_push_request_id(request_id);
2289                 g_variant_unref(value);
2290         } else if (strcasecmp(signal_name, BT_MAP_LIST_MESSAGES_COMPLETE) == 0) {
2291                 int request_id = 0;
2292                 GVariant* messages_list_var = NULL;
2293                 g_variant_get(parameters, "(iiv)", &result, &request_id, &messages_list_var);
2294                 if (__bt_is_request_id_exist(request_id) == FALSE) {
2295                         BT_ERR("Different request id!");
2296                         return;
2297                 }
2298
2299                 bt_map_client_message_items_s messages_struct = {0,};
2300
2301                 GVariantIter* iter;
2302                 g_variant_get(messages_list_var, "(a{oa{sv}})", &iter);
2303                 messages_struct.size = g_variant_iter_n_children(iter);
2304                 messages_struct.message_items = (bt_map_client_message_item_t*)
2305                         g_malloc(messages_struct.size * sizeof(*(messages_struct.message_items)));
2306                 BT_DBG("g_variant_iter_n_children: %lli", (long long int)messages_struct.size);
2307
2308                 char *object = NULL;
2309                 GVariantIter *properites = NULL;
2310                 int i = 0;
2311                 while (g_variant_iter_loop(iter, "{oa{sv}}", &object, &properites)) {
2312                         messages_struct.message_items[i].message_object = strdup(object);
2313                         BT_DBG("Message found: %s", messages_struct.message_items[i].message_object);
2314                         messages_struct.message_items[i].folder = NULL;
2315                         messages_struct.message_items[i].subject = NULL;
2316                         messages_struct.message_items[i].timestamp = NULL;
2317                         messages_struct.message_items[i].sender = NULL;
2318                         messages_struct.message_items[i].sender_address = NULL;
2319                         messages_struct.message_items[i].reply_to = NULL;
2320                         messages_struct.message_items[i].recipient = NULL;
2321                         messages_struct.message_items[i].recipient_address = NULL;
2322                         messages_struct.message_items[i].type = NULL;
2323                         messages_struct.message_items[i].size = -1;
2324                         messages_struct.message_items[i].is_text = -1;
2325                         messages_struct.message_items[i].status = NULL;
2326                         messages_struct.message_items[i].attachment_size = -1;
2327                         messages_struct.message_items[i].is_priority = -1;
2328                         messages_struct.message_items[i].is_read = -1;
2329                         messages_struct.message_items[i].is_sent = -1;
2330                         messages_struct.message_items[i].is_protected = -1;
2331                         char *key = NULL;
2332                         GVariant *value = NULL;
2333                         while (g_variant_iter_loop(properites, "{sv}", &key, &value)) {
2334                                 char *value_string = NULL;
2335                                 uint64_t value_int = -1;
2336                                 bool value_bool = false;
2337                                 if (strcmp(key, "Folder") == 0) {
2338                                         g_variant_get(value, "s", &value_string);
2339                                         messages_struct.message_items[i].folder = strdup(value_string);
2340                                         BT_DBG("  Folder: %s", value_string);
2341                                 } else if (strcmp(key, "Subject") == 0) {
2342                                         g_variant_get(value, "s", &value_string);
2343                                         messages_struct.message_items[i].subject = strdup(value_string);
2344                                         BT_DBG("  Subject: %s", value_string);
2345                                 } else if (strcmp(key, "Timestamp") == 0) {
2346                                         g_variant_get(value, "s", &value_string);
2347                                         messages_struct.message_items[i].timestamp = strdup(value_string);
2348                                         BT_DBG("  Timestamp: %s", value_string);
2349                                 } else if (strcmp(key, "Sender") == 0) {
2350                                         g_variant_get(value, "s", &value_string);
2351                                         messages_struct.message_items[i].sender = strdup(value_string);
2352                                         BT_DBG("  Sender: %s", value_string);
2353                                 } else if (strcmp(key, "SenderAddress") == 0) {
2354                                         g_variant_get(value, "s", &value_string);
2355                                         messages_struct.message_items[i].sender_address = strdup(value_string);
2356                                         BT_DBG("  SenderAddress: %s", value_string);
2357                                 } else if (strcmp(key, "ReplyTo") == 0) {
2358                                         g_variant_get(value, "s", &value_string);
2359                                         messages_struct.message_items[i].reply_to = strdup(value_string);
2360                                         BT_DBG("  ReplyTo: %s", value_string);
2361                                 } else if (strcmp(key, "Recipient") == 0) {
2362                                         g_variant_get(value, "s", &value_string);
2363                                         messages_struct.message_items[i].recipient = strdup(value_string);
2364                                         BT_DBG("  Recipient: %s", value_string);
2365                                 } else if (strcmp(key, "RecipientAddress") == 0) {
2366                                         g_variant_get(value, "s", &value_string);
2367                                         messages_struct.message_items[i].recipient_address = strdup(value_string);
2368                                         BT_DBG("  RecipientAddress: %s", value_string);
2369                                 } else if (strcmp(key, "Type") == 0) {
2370                                         g_variant_get(value, "s", &value_string);
2371                                         messages_struct.message_items[i].type = strdup(value_string);
2372                                         BT_DBG("  Type: %s", value_string);
2373                                 } else if (strcmp(key, "Size") == 0) {
2374                                         g_variant_get(value, "t", &value_int);
2375                                         messages_struct.message_items[i].size = value_int;
2376                                         BT_DBG("  Size: %llu", (unsigned long long int)value_int);
2377                                 } else if (strcmp(key, "Text") == 0) {
2378                                         g_variant_get(value, "b", &value_bool);
2379                                         messages_struct.message_items[i].is_text = value_bool ? 1 : 0;
2380                                         BT_DBG("  Text: %s", value_bool ? "true" : "false");
2381                                 } else if (strcmp(key, "Status") == 0) {
2382                                         g_variant_get(value, "s", &value_string);
2383                                         messages_struct.message_items[i].status = strdup(value_string);
2384                                         BT_DBG("  Status: %s", value_string);
2385                                 } else if (strcmp(key, "AttachmentSize") == 0) {
2386                                         g_variant_get(value, "t", &value_int);
2387                                         messages_struct.message_items[i].attachment_size = value_int;
2388                                         BT_DBG("  AttachmentSize: %llu", (unsigned long long int)value_int);
2389                                 } else if (strcmp(key, "Priority") == 0) {
2390                                         g_variant_get(value, "b", &value_bool);
2391                                         messages_struct.message_items[i].is_priority = value_bool ? 1 : 0;
2392                                         BT_DBG("  Priority: %s", value_bool ? "true" : "false");
2393                                 } else if (strcmp(key, "Read") == 0) {
2394                                         g_variant_get(value, "b", &value_bool);
2395                                         messages_struct.message_items[i].is_read = value_bool ? 1 : 0;
2396                                         BT_DBG("  Read: %s", value_bool ? "true" : "false");
2397                                 } else if (strcmp(key, "Sent") == 0) {
2398                                         g_variant_get(value, "b", &value_bool);
2399                                         messages_struct.message_items[i].is_sent = value_bool ? 1 : 0;
2400                                         BT_DBG("  Sent: %s", value_bool ? "true" : "false");
2401                                 } else if (strcmp(key, "Protected") == 0) {
2402                                         g_variant_get(value, "b", &value_bool);
2403                                         messages_struct.message_items[i].is_protected = value_bool ? 1 : 0;
2404                                         BT_DBG("  Protected: %s", value_bool ? "true" : "false");
2405                                 }
2406                         }
2407                         ++i;
2408                 }
2409
2410                 _bt_common_event_cb(BLUETOOTH_EVENT_MAP_LIST_MESSAGES_COMPLETE,
2411                                 result, &messages_struct,
2412                                 event_info->cb, event_info->user_data);
2413
2414                 __bt_remove_push_request_id(request_id);
2415
2416                 while (--i >= 0) {
2417                         free(messages_struct.message_items[i].folder);
2418                         free(messages_struct.message_items[i].subject);
2419                         free(messages_struct.message_items[i].timestamp);
2420                         free(messages_struct.message_items[i].sender);
2421                         free(messages_struct.message_items[i].sender_address);
2422                         free(messages_struct.message_items[i].reply_to);
2423                         free(messages_struct.message_items[i].recipient);
2424                         free(messages_struct.message_items[i].recipient_address);
2425                         free(messages_struct.message_items[i].type);
2426                         free(messages_struct.message_items[i].status);
2427                 }
2428                 g_free(messages_struct.message_items);
2429
2430                 g_variant_unref(messages_list_var);
2431         } else if (strcasecmp(signal_name, BT_MAP_GET_MESSAGE_COMPLETE) == 0) {
2432                 BT_DBG("BT_MAP_GET_MESSAGE_COMPLETE");
2433                 int request_id = 0;
2434
2435                 g_variant_get(parameters, "(ii)", &result, &request_id);
2436                 if (__bt_is_request_id_exist(request_id) == FALSE) {
2437                         BT_ERR("Different request id!");
2438                         return;
2439                 }
2440
2441                 // currently there is no result value passed from here, just passing NULL
2442                 void* some_result_value = NULL;
2443                 _bt_common_event_cb(BLUETOOTH_EVENT_MAP_GET_MESSAGE_COMPLETE,
2444                                 result, some_result_value, event_info->cb, event_info->user_data);
2445
2446                 __bt_remove_push_request_id(request_id);
2447         } else if (strcasecmp(signal_name, BT_MAP_PUSH_MESSAGE_COMPLETE) == 0) {
2448                 BT_DBG("BT_MAP_PUSH_MESSAGE_COMPLETE");
2449                 int request_id = 0;
2450
2451                 g_variant_get(parameters, "(ii)", &result, &request_id);
2452                 if (__bt_is_request_id_exist(request_id) == FALSE) {
2453                         BT_ERR("Different request id!");
2454                         return;
2455                 }
2456
2457                 // currently there is no result value passed from here, just passing NULL
2458                 void* some_result_value = NULL;
2459                 _bt_common_event_cb(BLUETOOTH_EVENT_MAP_PUSH_MESSAGE_COMPLETE,
2460                                 result, some_result_value, event_info->cb, event_info->user_data);
2461
2462                 __bt_remove_push_request_id(request_id);
2463         }
2464
2465 }
2466
2467 void __bt_pbap_client_event_filter(GDBusConnection *connection,
2468                                                  const gchar *sender_name,
2469                                                  const gchar *object_path,
2470                                                  const gchar *interface_name,
2471                                                  const gchar *signal_name,
2472                                                  GVariant *parameters,
2473                                                  gpointer user_data)
2474 {
2475         bt_event_info_t *event_info;
2476         int result = BLUETOOTH_ERROR_NONE;
2477         event_info = (bt_event_info_t *)user_data;
2478
2479         ret_if(event_info == NULL);
2480
2481         if (strcasecmp(object_path, BT_PBAP_CLIENT_PATH) != 0)
2482                 return;
2483
2484         if (strcasecmp(interface_name, BT_EVENT_SERVICE) != 0)
2485                 return;
2486
2487         ret_if(signal_name == NULL);
2488
2489         BT_DBG("Type: %s", g_variant_get_type_string(parameters));
2490
2491         if (strcasecmp(signal_name, BT_PBAP_CONNECTED) == 0) {
2492                 bt_pbap_connected_t connected = { { { 0 }, }, };
2493                 char *address = NULL;
2494
2495                 g_variant_get(parameters, "(i&s)", &result, &address);
2496                 BT_DBG("address: %s", address);
2497
2498                 _bt_convert_addr_string_to_type(connected.btaddr.addr,
2499                                                 address);
2500                 if (result == 0)
2501                         connected.connected = 1;
2502                 else
2503                         connected.connected = 0;
2504
2505                 _bt_common_event_cb(BLUETOOTH_PBAP_CONNECTED,
2506                                 result, &connected,
2507                                 event_info->cb, event_info->user_data);
2508         } else if (strcasecmp(signal_name, BT_PBAP_DISCONNECTED) == 0) {
2509                 bt_pbap_connected_t disconnected = { { { 0 }, }, };
2510                 char *address = NULL;
2511
2512                 g_variant_get(parameters, "(i&s)", &result, &address);
2513                 BT_DBG("address: %s", address);
2514
2515                 _bt_convert_addr_string_to_type(disconnected.btaddr.addr,
2516                                                 address);
2517                 disconnected.connected = 0;
2518
2519                 _bt_common_event_cb(BLUETOOTH_PBAP_DISCONNECTED,
2520                                 result, &disconnected,
2521                                 event_info->cb, event_info->user_data);
2522         } else if (strcasecmp(signal_name, BT_PBAP_PHONEBOOK_SIZE) == 0) {
2523                 bt_pbap_phonebook_size_t pb_size = { { { 0 }, }, };
2524                 char *address = NULL;
2525                 int size = 0;
2526
2527                 g_variant_get(parameters, "(i&si)", &result, &address, &size);
2528
2529                 BT_DBG("address: %s, size: %d", address, size);
2530
2531                 _bt_convert_addr_string_to_type(pb_size.btaddr.addr,
2532                                                 address);
2533                 pb_size.size = size;
2534
2535                 _bt_common_event_cb(BLUETOOTH_PBAP_PHONEBOOK_SIZE,
2536                                 result, &pb_size,
2537                                 event_info->cb, event_info->user_data);
2538         } else if (strcasecmp(signal_name, BT_PBAP_PHONEBOOK_PULL) == 0) {
2539                 bt_pbap_phonebook_pull_t pb_pull = { { { 0 } }, };
2540                 char *address = NULL;
2541                 char *vcf_file = NULL;
2542                 int success = -1;
2543
2544                 g_variant_get(parameters, "(i&s&si)", &result, &address, &vcf_file, &success);
2545
2546                 BT_DBG("address: %s, vcf_file: %s, success: %d",
2547                                                 address, vcf_file, success);
2548
2549                 _bt_convert_addr_string_to_type(pb_pull.btaddr.addr,
2550                                                 address);
2551                 pb_pull.vcf_file = vcf_file;
2552                 pb_pull.success = success;
2553                 _bt_common_event_cb(BLUETOOTH_PBAP_PHONEBOOK_PULL,
2554                                 result, &pb_pull,
2555                                 event_info->cb, event_info->user_data);
2556         } else if (strcasecmp(signal_name, BT_PBAP_VCARD_LIST) == 0) {
2557                 bt_pbap_vcard_list_t vc_list = { { { 0 } }, };
2558                 char *address = NULL;
2559                 gsize count = 0;
2560                 gchar **list = NULL;
2561                 GVariant *string_var;
2562                 int success = -1;
2563                 int i = 0;
2564
2565                 g_variant_get(parameters, "(i&sv)", &result, &address, &string_var);
2566
2567                 list = (gchar **)g_variant_get_strv(string_var, &count);
2568
2569                 success = !result;
2570
2571                 for (i = 0; i < count; i++)
2572                         BT_DBG("%s", list[i]);
2573
2574                 BT_DBG("address: %s, result: %d, count: %zd, success: %d",
2575                                         address, result, count, success);
2576
2577                 _bt_convert_addr_string_to_type(vc_list.btaddr.addr,
2578                                                 address);
2579                 vc_list.vcards = list;
2580                 vc_list.length = count;
2581                 vc_list.success = success;
2582                 _bt_common_event_cb(BLUETOOTH_PBAP_VCARD_LIST,
2583                                 result, &vc_list,
2584                                 event_info->cb, event_info->user_data);
2585
2586                 g_variant_unref(string_var);
2587                 //free lists
2588         } else if (strcasecmp(signal_name, BT_PBAP_VCARD_PULL) == 0) {
2589                 bt_pbap_vcard_pull_t vc_pull = { { { 0 } }, };
2590                 char *address = NULL;
2591                 char *vcf_file = NULL;
2592                 int success = -1;
2593
2594                 g_variant_get(parameters, "(i&s&si)",
2595                                         &result, &address, &vcf_file, &success);
2596
2597                 BT_DBG("address: %s, vcf_file: %s, success: %d",
2598                                                 address, vcf_file, success);
2599
2600                 _bt_convert_addr_string_to_type(vc_pull.btaddr.addr, address);
2601                 vc_pull.vcf_file = vcf_file;
2602                 vc_pull.success = success;
2603                 _bt_common_event_cb(BLUETOOTH_PBAP_VCARD_PULL,
2604                                 result, &vc_pull,
2605                                 event_info->cb, event_info->user_data);
2606         } else if (strcasecmp(signal_name, BT_PBAP_SEARCH_PHONEBOOK) == 0) {
2607                 bt_pbap_phonebook_search_list_t vc_list = { { { 0 } }, };
2608                 char *address = NULL;
2609                 gsize count = 0;
2610                 gchar **list = NULL;
2611                 GVariant *string_var;
2612                 int success = -1;
2613                 int i = 0;
2614
2615                 g_variant_get(parameters, "(i&s@as)", &result, &address, &string_var);
2616
2617                 list = (gchar **)g_variant_get_strv(string_var, &count);
2618                 success = !result;
2619                 for (i = 0; i < count; i++)
2620                         BT_DBG("%s", list[i]);
2621
2622                 BT_DBG("address: %s success: %d", address, success);
2623
2624                 _bt_convert_addr_string_to_type(vc_list.btaddr.addr, address);
2625                 vc_list.vcards = list;
2626                 vc_list.length = count;
2627                 vc_list.success = success;
2628                 _bt_common_event_cb(BLUETOOTH_PBAP_PHONEBOOK_SEARCH,
2629                                 result, &vc_list,
2630                                 event_info->cb, event_info->user_data);
2631
2632                 g_variant_unref(string_var);
2633                 //free lists
2634         }
2635 }
2636
2637 void __bt_rfcomm_client_event_filter(GDBusConnection *connection,
2638                                                  const gchar *sender_name,
2639                                                  const gchar *object_path,
2640                                                  const gchar *interface_name,
2641                                                  const gchar *signal_name,
2642                                                  GVariant *parameters,
2643                                                  gpointer user_data)
2644 {
2645         bt_event_info_t *event_info;
2646         int result = BLUETOOTH_ERROR_NONE;
2647         event_info = (bt_event_info_t *)user_data;
2648         ret_if(event_info == NULL);
2649
2650         if (strcasecmp(object_path, BT_RFCOMM_CLIENT_PATH) != 0)
2651                 return;
2652         if (strcasecmp(interface_name, BT_EVENT_SERVICE) != 0)
2653                 return;
2654
2655         ret_if(signal_name == NULL);
2656
2657         if (strcasecmp(signal_name, BT_RFCOMM_CONNECTED) == 0) {
2658                 const char *address = NULL;
2659                 const char *uuid = NULL;
2660                 int socket_fd = 0;
2661                 bluetooth_rfcomm_connection_t conn_info;
2662
2663                 g_variant_get(parameters, "(i&s&sn)", &result, &address,
2664                                                         &uuid, &socket_fd);
2665
2666                 memset(&conn_info, 0x00, sizeof(bluetooth_rfcomm_connection_t));
2667                 conn_info.device_role = RFCOMM_ROLE_CLIENT;
2668                 g_strlcpy(conn_info.uuid, uuid, BLUETOOTH_UUID_STRING_MAX);
2669                 conn_info.socket_fd = socket_fd;
2670                 _bt_convert_addr_string_to_type(conn_info.device_addr.addr,
2671                                                 address);
2672
2673                 _bt_common_event_cb(BLUETOOTH_EVENT_RFCOMM_CONNECTED,
2674                                 result, &conn_info,
2675                                 event_info->cb, event_info->user_data);
2676         } else if (strcasecmp(signal_name, BT_RFCOMM_DISCONNECTED) == 0) {
2677                 const char *address = NULL;
2678                 const char *uuid = NULL;
2679                 int socket_fd = 0;
2680                 bluetooth_rfcomm_disconnection_t disconn_info;
2681
2682                 g_variant_get(parameters, "(i&s&sn)", &result, &address,
2683                                                                 &uuid, &socket_fd);
2684
2685                 memset(&disconn_info, 0x00, sizeof(bluetooth_rfcomm_disconnection_t));
2686                 disconn_info.device_role = RFCOMM_ROLE_CLIENT;
2687                 g_strlcpy(disconn_info.uuid, uuid, BLUETOOTH_UUID_STRING_MAX);
2688                 disconn_info.socket_fd = socket_fd;
2689                 _bt_convert_addr_string_to_type(disconn_info.device_addr.addr,
2690                                                 address);
2691
2692                 _bt_common_event_cb(BLUETOOTH_EVENT_RFCOMM_DISCONNECTED,
2693                                 result, &disconn_info,
2694                                 event_info->cb, event_info->user_data);
2695         } else if (strcasecmp(signal_name, BT_RFCOMM_DATA_RECEIVED) == 0) {
2696                 char *buffer;
2697                 int buffer_len = 0;
2698                 int socket_fd = 0;
2699                 bluetooth_rfcomm_received_data_t data_r;
2700                 GVariant *byte_var;
2701
2702                 g_variant_get(parameters, "(in@ay)", &result, &socket_fd,
2703                                                                 &byte_var);
2704
2705                 buffer_len = g_variant_get_size(byte_var);
2706                 buffer = (char *) g_variant_get_data(byte_var);
2707
2708                 data_r.socket_fd = socket_fd;
2709                 data_r.buffer_size = buffer_len;
2710                 data_r.buffer = buffer;
2711
2712                 _bt_common_event_cb(BLUETOOTH_EVENT_RFCOMM_DATA_RECEIVED,
2713                                 result, &data_r,
2714                                 event_info->cb, event_info->user_data);
2715                 g_variant_unref(byte_var);
2716         }
2717 }
2718
2719 void __bt_rfcomm_server_event_filter(GDBusConnection *connection,
2720                                                  const gchar *sender_name,
2721                                                  const gchar *object_path,
2722                                                  const gchar *interface_name,
2723                                                  const gchar *signal_name,
2724                                                  GVariant *parameters,
2725                                                  gpointer user_data)
2726 {
2727         bt_event_info_t *event_info;
2728         int result = BLUETOOTH_ERROR_NONE;
2729         event_info = (bt_event_info_t *)user_data;
2730         ret_if(event_info == NULL);
2731
2732         if (strcasecmp(object_path, BT_RFCOMM_SERVER_PATH) != 0)
2733                 return;
2734         if (strcasecmp(interface_name, BT_EVENT_SERVICE) != 0)
2735                 return;
2736
2737         ret_if(signal_name == NULL);
2738
2739         if (strcasecmp(signal_name, BT_RFCOMM_CONNECTED) == 0) {
2740                 const char *address = NULL;
2741                 const char *uuid = NULL;
2742                 int socket_fd = 0;
2743                 bluetooth_rfcomm_connection_t conn_info;
2744
2745                 g_variant_get(parameters, "(i&s&sn)", &result, &address,
2746                                                         &uuid, &socket_fd);
2747
2748                 memset(&conn_info, 0x00, sizeof(bluetooth_rfcomm_connection_t));
2749                 conn_info.device_role = RFCOMM_ROLE_SERVER;
2750                 g_strlcpy(conn_info.uuid, uuid, BLUETOOTH_UUID_STRING_MAX);
2751                 conn_info.socket_fd = socket_fd;
2752                 _bt_convert_addr_string_to_type(conn_info.device_addr.addr,
2753                                                 address);
2754
2755                 _bt_common_event_cb(BLUETOOTH_EVENT_RFCOMM_CONNECTED,
2756                                 result, &conn_info,
2757                                 event_info->cb, event_info->user_data);
2758         } else if (strcasecmp(signal_name, BT_RFCOMM_DISCONNECTED) == 0) {
2759                 const char *address = NULL;
2760                 const char *uuid = NULL;
2761                 int socket_fd = 0;
2762                 bluetooth_rfcomm_disconnection_t disconn_info;
2763
2764                 g_variant_get(parameters, "(i&s&sn)", &result, &address,
2765                                                                 &uuid, &socket_fd);
2766
2767                 memset(&disconn_info, 0x00, sizeof(bluetooth_rfcomm_disconnection_t));
2768                 disconn_info.device_role = RFCOMM_ROLE_SERVER;
2769                 g_strlcpy(disconn_info.uuid, uuid, BLUETOOTH_UUID_STRING_MAX);
2770                 disconn_info.socket_fd = socket_fd;
2771                 _bt_convert_addr_string_to_type(disconn_info.device_addr.addr,
2772                                                 address);
2773
2774                 _bt_common_event_cb(BLUETOOTH_EVENT_RFCOMM_DISCONNECTED,
2775                                 result, &disconn_info,
2776                                 event_info->cb, event_info->user_data);
2777         } else if (strcasecmp(signal_name, BT_CONNECTION_AUTHORIZED) == 0) {
2778                 /* OSP only event */
2779                 bluetooth_rfcomm_connection_request_t req_ind;
2780                 char *address = NULL;
2781                 char *uuid = NULL;
2782                 int socket_fd = 0;
2783 #ifdef TIZEN_FEATURE_BT_RFCOMM_DIRECT
2784                 char *name = NULL;
2785                 char *path = NULL;
2786
2787                 g_variant_get(parameters, "(i&s&s&s&sn)", &result, &address,
2788                                                 &uuid, &name, &path, &socket_fd);
2789
2790                 if (_check_uuid_path(path, uuid) == FALSE)
2791                         return;
2792 #else
2793                 gboolean auto_accept = FALSE;
2794
2795                 g_variant_get(parameters, "(i&s&s)", &result, &address, &uuid);
2796                 socket_fd = _get_rfcomm_server_id(uuid, &auto_accept);
2797                 if (0 > socket_fd)
2798                         return;
2799
2800                 _bt_rfcomm_server_set_pending_conn(socket_fd, address);
2801                 if (auto_accept) {
2802                         bluetooth_rfcomm_accept_connection(socket_fd);
2803                         return;
2804                 }
2805 #endif
2806                 memset(&req_ind, 0x00, sizeof(bluetooth_rfcomm_connection_request_t));
2807                 _bt_convert_addr_string_to_type(req_ind.device_addr.addr,
2808                                                 address);
2809
2810                 req_ind.socket_fd = socket_fd;
2811
2812                 _bt_common_event_cb(BLUETOOTH_EVENT_RFCOMM_AUTHORIZE,
2813                                 result, &req_ind,
2814                                 event_info->cb, event_info->user_data);
2815         } else if (strcasecmp(signal_name, BT_RFCOMM_SERVER_REMOVED) == 0) {
2816                 /* OSP only event */
2817                 int socket_fd = 0;
2818
2819                 g_variant_get(parameters, "(in)", &result, &socket_fd);
2820
2821                 ret_if(__bt_is_server_exist(socket_fd) == FALSE);
2822
2823                 _bt_remove_server(socket_fd);
2824         } else if (strcasecmp(signal_name, BT_RFCOMM_DATA_RECEIVED) == 0) {
2825                 char *buffer = NULL;
2826                 int buffer_len = 0;
2827                 int socket_fd = 0;
2828                 bluetooth_rfcomm_received_data_t data_r;
2829                 GVariant *byte_var;
2830
2831                 g_variant_get(parameters, "(in@ay)", &result,
2832                                                 &socket_fd, &byte_var);
2833
2834                 buffer_len = g_variant_get_size(byte_var);
2835                 buffer = (char *) g_variant_get_data(byte_var);
2836
2837                 data_r.socket_fd = socket_fd;
2838                 data_r.buffer_size = buffer_len;
2839                 data_r.buffer = buffer;
2840
2841                 _bt_common_event_cb(BLUETOOTH_EVENT_RFCOMM_DATA_RECEIVED,
2842                                 result, &data_r,
2843                                 event_info->cb, event_info->user_data);
2844                 g_variant_unref(byte_var);
2845         }
2846 }
2847
2848 void __bt_hf_agent_event_filter(GDBusConnection *connection,
2849                                                  const gchar *sender_name,
2850                                                  const gchar *object_path,
2851                                                  const gchar *interface_name,
2852                                                  const gchar *signal_name,
2853                                                  GVariant *parameters,
2854                                                  gpointer user_data)
2855 {
2856         BT_DBG("+");
2857
2858         bt_event_info_t *event_info;
2859         int result = BLUETOOTH_ERROR_NONE;
2860         event_info = (bt_event_info_t *)user_data;
2861         ret_if(event_info == NULL);
2862
2863         if (strcasecmp(object_path, BT_HF_AGENT_PATH) != 0)
2864                 return;
2865         if (strcasecmp(interface_name, BT_HF_SERVICE_INTERFACE) != 0)
2866                 return;
2867
2868         ret_if(signal_name == NULL);
2869
2870         BT_DBG("%s", signal_name);
2871         if (strcasecmp(signal_name, "Connected") == 0) {
2872                 char *address = NULL;
2873
2874                 g_variant_get(parameters, "(&s)", &address);
2875                 _bt_hf_event_cb(BLUETOOTH_EVENT_HF_CONNECTED,
2876                                 result, address,
2877                                 event_info->cb, event_info->user_data);
2878         } else if (strcasecmp(signal_name, "Disconnected") == 0) {
2879                 char *address = NULL;
2880
2881                 g_variant_get(parameters, "(&s)", &address);
2882                 _bt_hf_event_cb(BLUETOOTH_EVENT_HF_DISCONNECTED,
2883                                 result, address,
2884                                 event_info->cb, event_info->user_data);
2885         } else if (strcasecmp(signal_name, "AudioConnected") == 0) {
2886                 _bt_hf_event_cb(BLUETOOTH_EVENT_HF_AUDIO_CONNECTED,
2887                                 result, NULL,
2888                                 event_info->cb, event_info->user_data);
2889         } else if (strcasecmp(signal_name, "AudioDisconnected") == 0) {
2890                 _bt_hf_event_cb(BLUETOOTH_EVENT_HF_AUDIO_DISCONNECTED,
2891                                 result, NULL,
2892                                 event_info->cb, event_info->user_data);
2893         } else if (strcasecmp(signal_name, "Ring") == 0) {
2894                 char *phoneno = NULL;
2895
2896                 g_variant_get(parameters, "(&s)", &phoneno);
2897
2898                 _bt_hf_event_cb(BLUETOOTH_EVENT_HF_RING_INDICATOR,
2899                                 result, phoneno,
2900                                 event_info->cb, event_info->user_data);
2901         } else if (strcasecmp(signal_name, "CallWaiting") == 0) {
2902                 char *phoneno = NULL;
2903
2904                 g_variant_get(parameters, "(&s)", &phoneno);
2905
2906                 _bt_hf_event_cb(BLUETOOTH_EVENT_HF_CALL_WAITING,
2907                                 result, phoneno,
2908                                 event_info->cb, event_info->user_data);
2909         }  else if (strcasecmp(signal_name, "CallTerminated") == 0) {
2910                 _bt_hf_event_cb(BLUETOOTH_EVENT_HF_CALL_TERMINATED,
2911                                 result, NULL,
2912                                 event_info->cb, event_info->user_data);
2913         }  else if (strcasecmp(signal_name, "FailedToDial") == 0) {
2914                 _bt_hf_event_cb(BLUETOOTH_EVENT_HF_CALL_FAILED_TO_DIAL,
2915                                 result, NULL,
2916                                 event_info->cb, event_info->user_data);
2917         } else if (strcasecmp(signal_name, "CallIdle") == 0) {
2918                 _bt_hf_event_cb(BLUETOOTH_EVENT_HF_CALL_IDLE,
2919                                 result, NULL,
2920                                 event_info->cb, event_info->user_data);
2921         } else if (strcasecmp(signal_name, "CallSetupIncoming") == 0) {
2922                 _bt_hf_event_cb(BLUETOOTH_EVENT_HF_CALLSETUP_INCOMING,
2923                                 result, NULL,
2924                                 event_info->cb, event_info->user_data);
2925         } else if (strcasecmp(signal_name, "CallSetupDialing") == 0) {
2926                 _bt_hf_event_cb(BLUETOOTH_EVENT_HF_CALLSETUP_DIALING,
2927                                 result, NULL,
2928                                 event_info->cb, event_info->user_data);
2929         } else if (strcasecmp(signal_name, "CallSetupAlerting") == 0) {
2930                 _bt_hf_event_cb(BLUETOOTH_EVENT_HF_CALLSETUP_ALERTING,
2931                                 result, NULL,
2932                                 event_info->cb, event_info->user_data);
2933         } else if (strcasecmp(signal_name, "CallStarted") == 0) {
2934                 _bt_hf_event_cb(BLUETOOTH_EVENT_HF_CALL_STARTED,
2935                                 result, NULL,
2936                                 event_info->cb, event_info->user_data);
2937         } else if (strcasecmp(signal_name, "CallEnded") == 0) {
2938                 _bt_hf_event_cb(BLUETOOTH_EVENT_HF_CALL_ENDED,
2939                                 result, NULL,
2940                                 event_info->cb, event_info->user_data);
2941         }  else if (strcasecmp(signal_name, "NoCallsHeld") == 0) {
2942                 _bt_hf_event_cb(BLUETOOTH_EVENT_HF_CALL_UNHOLD,
2943                                 result, NULL,
2944                                 event_info->cb, event_info->user_data);
2945         } else if (strcasecmp(signal_name, "CallsSwapped") == 0) {
2946                 _bt_hf_event_cb(BLUETOOTH_EVENT_HF_CALL_SWAPPED,
2947                                 result, NULL,
2948                                 event_info->cb, event_info->user_data);
2949         } else if (strcasecmp(signal_name, "CallOnHold") == 0) {
2950                 _bt_hf_event_cb(BLUETOOTH_EVENT_HF_CALL_ON_HOLD,
2951                                 result, NULL,
2952                                 event_info->cb, event_info->user_data);
2953         } else if (strcasecmp(signal_name, "CallStatusUpdate") == 0) {
2954                 int call_count;
2955                 GVariant *var_data = NULL;
2956                 char *number = NULL;
2957                 int idx, dir, status, mpart;
2958                 bt_hf_call_list_s *handle = NULL;
2959
2960                 g_variant_get(parameters, "(i@a(siiii))", &call_count,
2961                                                                 &var_data);
2962                 BT_DBG("call count : %d", call_count);
2963
2964                 if (var_data) {
2965                         GVariantIter *iter = NULL;
2966                         __bt_call_list_create(&handle);
2967
2968                         g_variant_get(var_data, "a(siiii)", &iter);
2969                         while (g_variant_iter_loop(iter, "(siiii)", &number,
2970                                                 &dir, &status, &mpart, &idx)) {
2971                                 BT_DBG("call number:%s, dir:%d, status : %d",
2972                                                         number, dir, status);
2973                                 BT_DBG("call mpart : %d, idx : %d", mpart, idx);
2974                                 __bt_call_list_add(handle, number, dir,
2975                                                         status, mpart, idx);
2976                         }
2977                         g_variant_iter_free(iter);
2978                         g_variant_unref(var_data);
2979                 }
2980
2981                 if (handle && (call_count == g_list_length(handle->list))) {
2982                         handle->count = call_count;
2983                         _bt_hf_event_cb(BLUETOOTH_EVENT_HF_CALL_STATUS,
2984                                         result, handle,
2985                                         event_info->cb, event_info->user_data);
2986                 } else {
2987                         BT_ERR(" Mismatch in call count : %d", call_count);
2988                 }
2989
2990                 __bt_call_list_destroy(handle);
2991         } else if (strcasecmp(signal_name, "VoiceRecognition") == 0) {
2992                 int status;
2993                 g_variant_get(parameters, "(i)", &status);
2994                 BT_DBG("status = [%d]\n", status);
2995                 if (status)
2996                         _bt_hf_event_cb(BLUETOOTH_EVENT_HF_VOICE_RECOGNITION_ENABLED,
2997                                         result, NULL,
2998                                         event_info->cb, event_info->user_data);
2999                 else
3000                         _bt_hf_event_cb(BLUETOOTH_EVENT_HF_VOICE_RECOGNITION_DISABLED,
3001                                         result, NULL,
3002                                         event_info->cb, event_info->user_data);
3003         } else if (strcasecmp(signal_name, "VolumeSpeaker") == 0) {
3004                 int value;
3005                 g_variant_get(parameters, "(i)", &value);
3006                 BT_DBG("Value = [%d]\n", value);
3007                         _bt_hf_event_cb(BLUETOOTH_EVENT_HF_VOLUME_SPEAKER,
3008                                         result, &value,
3009                                         event_info->cb, event_info->user_data);
3010         } else if (strcasecmp(signal_name, "SamsungXSAT") == 0) {
3011                 int value = 0;
3012                 char *msg = NULL;
3013                 bluetooth_vendor_dep_at_cmd_t cmd;
3014                 g_variant_get(parameters, "(i&s)", &value, &msg);
3015                 BT_DBG("Value = [%d], message = %s\n", value, msg);
3016                 cmd.app_id =  value;
3017                 cmd.message = msg;
3018                 _bt_hf_event_cb(BLUETOOTH_EVENT_HF_VENDOR_DEP_CMD,
3019                                 result, &cmd,
3020                                 event_info->cb, event_info->user_data);
3021         } else if (strcasecmp(signal_name, "PropertyChanged") == 0) {
3022                 GVariant *value;
3023                 gchar *property;
3024                 bluetooth_hf_ciev_device_event_t dev_event;
3025
3026                 g_variant_get(parameters, "(&sv)", &property, &value);
3027                 dev_event.value  = g_variant_get_uint16(value);
3028
3029                 BT_DBG("Property: %s , value: %d", property, dev_event.value);
3030                 g_variant_unref(value);
3031
3032                 if (strcasecmp(property, "BatteryCharge") == 0) {
3033                         dev_event.event = BLUETOOTH_HF_CIEV_BATTCHG;
3034                         _bt_hf_event_cb(BLUETOOTH_EVENT_HF_CIEV_DEVICE_STATUS_CHANGED,
3035                                         result, &dev_event,
3036                                         event_info->cb, event_info->user_data);
3037                 } else if (strcasecmp(property, "SignalStrength") == 0) {
3038                         dev_event.event = BLUETOOTH_HF_CIEV_SIGNAL;
3039                         _bt_hf_event_cb(BLUETOOTH_EVENT_HF_CIEV_DEVICE_STATUS_CHANGED,
3040                                         result, &dev_event,
3041                                         event_info->cb, event_info->user_data);
3042                 } else if (strcasecmp(property, "RegistrationStatus") == 0) {
3043                         dev_event.event = BLUETOOTH_HF_CIEV_SERVICE;
3044                         _bt_hf_event_cb(BLUETOOTH_EVENT_HF_CIEV_DEVICE_STATUS_CHANGED,
3045                                         result, &dev_event,
3046                                         event_info->cb, event_info->user_data);
3047                 }
3048         }
3049         BT_DBG("-");
3050 }
3051
3052 static void __bt_tds_event_filter(GDBusConnection *connection,
3053                 const gchar *sender_name,
3054                 const gchar *object_path,
3055                 const gchar *interface_name,
3056                 const gchar *signal_name,
3057                 GVariant *parameters,
3058                 gpointer user_data)
3059 {
3060         bt_event_info_t *event_info;
3061         event_info = (bt_event_info_t *)user_data;
3062         int result = BLUETOOTH_ERROR_NONE;
3063
3064         ret_if(event_info == NULL);
3065
3066         if (strcasecmp(object_path, BT_TDS_PATH) != 0)
3067                 return;
3068         if (strcasecmp(interface_name, BT_EVENT_SERVICE) != 0)
3069                 return;
3070
3071         ret_if(signal_name == NULL);
3072
3073         BT_DBG("+");
3074
3075         if (strcasecmp(signal_name, BT_TDS_ACTIVATION_REQUESTED) == 0) {
3076                 bluetooth_tds_activation_req_t act_req;
3077                 const char *address = NULL;
3078                 char *buffer = NULL;
3079                 int transport = 0;
3080                 GVariant *byte_var;
3081
3082                 g_variant_get(parameters, "(&si@ay)", &address,
3083                                 &transport, &byte_var);
3084
3085                 memset(&act_req, 0x00, sizeof(bluetooth_tds_activation_req_t));
3086
3087                 act_req.transport = transport;
3088
3089                 act_req.tds_data.length = g_variant_get_size(byte_var);
3090                 if (act_req.tds_data.length > BLUETOOTH_TDS_DATA_LENGTH_MAX) {
3091                         BT_INFO("tds data length > BLUETOOTH_TDS_DATA_LENGTH_MAX");
3092                         act_req.tds_data.length = BLUETOOTH_TDS_DATA_LENGTH_MAX;
3093                 }
3094                 buffer = (char *) g_variant_get_data(byte_var);
3095                 memcpy(act_req.tds_data.data, buffer, act_req.tds_data.length);
3096                 g_variant_unref(byte_var);
3097
3098                 _bt_convert_addr_string_to_type(act_req.rem_addr.addr, address);
3099
3100                 _bt_common_event_cb(BLUETOOTH_EVENT_TDS_ACTIVATION_REQUESTED,
3101                                 BLUETOOTH_ERROR_NONE, &act_req,
3102                                 event_info->cb, event_info->user_data);
3103         } else if (strcasecmp(signal_name, BT_TDS_TRANSPORT_DATA_RECEIVED) == 0) {
3104                 BT_DBG("TDS Complete Block Data received");
3105                 const char *address = NULL;
3106                 char *data;
3107                 int data_len = 0;
3108                 int k;
3109                 GVariant *var = NULL;
3110                 bluetooth_tds_transport_data_info_t *info = NULL;
3111
3112                 /* Extract data from DBUS params */
3113                 g_variant_get(parameters, "(i&sn@ay)", &result, &address, &data_len, &var);
3114                 data = (char *)g_variant_get_data(var);
3115
3116                 if (data) {
3117                         BT_DBG("Address [%s]", address);
3118                         BT_DBG("Data len [%d]", data_len);
3119
3120                         /* DEBUG */
3121                         for (k = 0; k < data_len ; k++)
3122                                 BT_DBG("Data[%d] [0x%x]", k, data[k]);
3123
3124                         if (data_len == 0) {
3125                                 BT_ERR("No data");
3126                                 g_variant_unref(var);
3127                                 return;
3128                         }
3129
3130                         info = g_malloc0(sizeof(bluetooth_tds_transport_data_info_t));
3131                         info->data_length = data_len;
3132                         info->data = g_memdup(data, data_len);
3133
3134                         _bt_convert_addr_string_to_type(info->device_address.addr,
3135                                         address);
3136
3137                         _bt_common_event_cb(BLUETOOTH_EVENT_TDS_TRANSPORT_DATA_RECEIVED,
3138                                         result, info,
3139                                         event_info->cb, event_info->user_data);
3140
3141                         if (info->data) {
3142                                 g_free(info->data);
3143                                 g_free(info);
3144                         }
3145                 }
3146                 g_variant_unref(var);
3147         } else if (strcasecmp(signal_name, BT_TDS_ACTIVATION_RESULT) == 0) {
3148                 BT_DBG("TDS Control point Activation result");
3149                 const char *address = NULL;
3150                 bluetooth_device_address_t dev_address = { {0} };
3151
3152                 /* Extract data from DBUS params */
3153                 g_variant_get(parameters, "(i&s)", &result, &address);
3154                 BT_DBG("Address [%s]", address);
3155                 BT_DBG("Result  [%d]", result);
3156
3157                 _bt_convert_addr_string_to_type(dev_address.addr,
3158                                 address);
3159
3160                 _bt_common_event_cb(BLUETOOTH_EVENT_TDS_ACTIVATION_RESULT,
3161                                 result, &dev_address,
3162                                 event_info->cb, event_info->user_data);
3163         } else if (strcasecmp(signal_name, BT_TDS_ACTIVATION_INDICATION) == 0) {
3164                 BT_DBG("TDS Control point Indication Response");
3165                 bluetooth_tds_indication_res_t ind_res;
3166                 const char *address = NULL;
3167                 char *buffer = NULL;
3168                 GVariant *byte_var = NULL;
3169
3170                 g_variant_get(parameters, "(&s@ay)", &address, &byte_var);
3171
3172                 memset(&ind_res, 0x00, sizeof(bluetooth_tds_indication_res_t));
3173
3174                 ind_res.tds_data.length = g_variant_get_size(byte_var);
3175
3176                 buffer = (char *) g_variant_get_data(byte_var);
3177                 BT_DBG("[len = %d]", ind_res.tds_data.length);
3178                 memcpy(ind_res.tds_data.data, buffer, ind_res.tds_data.length);
3179
3180                 _bt_convert_addr_string_to_type(ind_res.rem_addr.addr, address);
3181
3182                 _bt_common_event_cb(BLUETOOTH_EVENT_TDS_ACTIVATION_INDICATION,
3183                                 BLUETOOTH_ERROR_NONE,  &ind_res,
3184                                 event_info->cb, event_info->user_data);
3185
3186                 g_variant_unref(byte_var);
3187         } else if (strcasecmp(signal_name, BT_TDS_CONTROL_POINT_ENABLED) == 0) {
3188                 BT_DBG("TDS Control point Enabled event");
3189                 const char *address = NULL;
3190                 bluetooth_device_address_t dev_address = { {0} };
3191
3192                 /* Extract data from DBUS params */
3193                 g_variant_get(parameters, "(i&s)", &result, &address);
3194                 BT_DBG("Address [%s]", address);
3195                 BT_DBG("Result  [%d]", result);
3196
3197                 _bt_convert_addr_string_to_type(dev_address.addr,
3198                                 address);
3199
3200                 _bt_common_event_cb(BLUETOOTH_EVENT_TDS_CONTROL_POINT_ENABLED,
3201                                 result, &dev_address,
3202                                 event_info->cb, event_info->user_data);
3203         }
3204
3205         BT_DBG("-");
3206 }
3207
3208 static void __bt_otp_event_filter(GDBusConnection *connection,
3209                 const gchar *sender_name,
3210                 const gchar *object_path,
3211                 const gchar *interface_name,
3212                 const gchar *signal_name,
3213                 GVariant *parameters,
3214                 gpointer user_data)
3215 {
3216         bt_event_info_t *event_info;
3217         event_info = (bt_event_info_t *)user_data;
3218         int result = BLUETOOTH_ERROR_NONE;
3219
3220         ret_if(event_info == NULL);
3221
3222         if (strcasecmp(object_path, BT_OTP_PATH) != 0)
3223                 return;
3224         if (strcasecmp(interface_name, BT_EVENT_SERVICE) != 0)
3225                 return;
3226
3227         ret_if(signal_name == NULL);
3228
3229         BT_DBG("+");
3230
3231         if (strcasecmp(signal_name, BT_OTP_SERVER_STATE_CHANGED) == 0) {
3232                 BT_DBG("OTP Server State Changed Event");
3233                 bool status = FALSE;
3234
3235                 /* Extract data from DBUS params */
3236                 g_variant_get(parameters, "(ib)", &result, &status);
3237                 BT_DBG("Result [%d]", result);
3238                 BT_DBG("Status  [%s]", status ? "enabled" : "disabled");
3239
3240                 _bt_common_event_cb(BLUETOOTH_EVENT_OTP_SERVER_STATE_CHANGED,
3241                                 result, &status, event_info->cb, event_info->user_data);
3242         } else if (strcasecmp(signal_name, BT_OTP_READ_CHAR_VAL) == 0) {
3243                 BT_DBG("OTP Read Data received");
3244                 const char *handle = NULL;
3245                 char *data;
3246                 int data_len = 0;
3247                 GVariant *var = NULL;
3248                 bluetooth_otp_resp_info_t *info = NULL;
3249
3250                 /* Extract data from DBUS params */
3251                 g_variant_get(parameters, "(i&sn@ay)", &result, &handle, &data_len, &var);
3252                 if (!var) {
3253                         BT_ERR("No data");
3254                         return;
3255                 }
3256                 data = (char *)g_variant_get_data(var);
3257
3258                 BT_DBG("Handle [%s]", handle);
3259                 BT_DBG("Data len [%d]", data_len);
3260
3261                 if (data_len == 0) {
3262                         BT_ERR("No data");
3263                         if (var)
3264                                 g_variant_unref(var);
3265                         return;
3266                 }
3267
3268                 info = g_malloc0(sizeof(bluetooth_otp_resp_info_t));
3269                 info->data_length = data_len;
3270                 info->data = g_memdup(data, data_len);
3271                 info->handle = g_strdup(handle);
3272
3273                 _bt_common_event_cb(BLUETOOTH_EVENT_OTP_READ_CHAR_VAL,
3274                                 result, info,
3275                                 event_info->cb, event_info->user_data);
3276
3277                 if (info->handle)
3278                         g_free(info->handle);
3279
3280                 if (info->data) {
3281                         g_free(info->data);
3282                         g_free(info);
3283                 }
3284                 g_variant_unref(var);
3285         } else if (strcasecmp(signal_name, BT_OTP_NOTIFICATION_ENABLED) == 0) {
3286                 BT_DBG("OTP Notification Enabled event");
3287                 char *handle = NULL;
3288
3289                 /* Extract data from DBUS params */
3290                 g_variant_get(parameters, "(i&s)", &result, &handle);
3291                 BT_DBG("Handle [%s]", handle);
3292                 BT_DBG("Result  [%d]", result);
3293
3294                 _bt_common_event_cb(BLUETOOTH_EVENT_OTP_NOTIFICATION_ENABLED,
3295                                 result, handle,
3296                                 event_info->cb, event_info->user_data);
3297         } else if (strcasecmp(signal_name, BT_OTP_WRITE_CHAR_VAL) == 0) {
3298                 BT_DBG("OTP Control point Activation result");
3299                 char *handle = NULL;
3300
3301                 /* Extract data from DBUS params */
3302                 g_variant_get(parameters, "(i&s)", &result, &handle);
3303                 BT_DBG("Handle [%s]", handle);
3304                 BT_DBG("Result  [%d]", result);
3305
3306                 _bt_common_event_cb(BLUETOOTH_EVENT_OTP_WRITE_CHAR_VAL,
3307                                 result, handle,
3308                                 event_info->cb, event_info->user_data);
3309         } else if (strcasecmp(signal_name, BT_OTP_INDICATION) == 0) {
3310                 BT_DBG("OTP Control point Indication Response");
3311                 bluetooth_otp_resp_info_t *ind_res = NULL;
3312                 char *buffer = NULL;
3313                 GVariant *byte_var = NULL;
3314                 char *handle = NULL;
3315
3316                 g_variant_get(parameters, "(i&s@ay)", &result, &handle, &byte_var);
3317                 if (!byte_var) {
3318                         BT_ERR("No Indication data from Server");
3319                         return;
3320                 }
3321
3322                 ind_res = g_malloc0(sizeof(bluetooth_otp_resp_info_t));
3323                 ind_res->data_length = g_variant_get_size(byte_var);
3324                 buffer = (char *)g_variant_get_data(byte_var);
3325                 ind_res->data = g_memdup(buffer, ind_res->data_length);
3326                 ind_res->handle = g_strdup(handle);
3327
3328                 _bt_common_event_cb(BLUETOOTH_EVENT_OTP_INDICATION,
3329                                 result,  ind_res,
3330                                 event_info->cb, event_info->user_data);
3331
3332                 if (ind_res->handle)
3333                         g_free(ind_res->handle);
3334
3335                 if (ind_res->data) {
3336                         g_free(ind_res->data);
3337                         g_free(ind_res);
3338                 }
3339                 g_variant_unref(byte_var);
3340         }  else if (strcasecmp(signal_name, BT_OTC_STATE_CHANGED) == 0) {
3341                 BT_DBG("OTC State Changed");
3342                 char *address = NULL;
3343                 int fd = -1;
3344                 gboolean connected = FALSE;
3345                 bluetooth_otc_info_t *otc_info = NULL;
3346
3347                 /* Extract data from DBUS params */
3348                 g_variant_get(parameters, "(ib&sn)", &result, &connected, &address, &fd);
3349                 BT_DBG("Result  [%d]", result);
3350                 BT_DBG("Address [%s]", address);
3351                 BT_DBG("Connected [%d]", connected);
3352                 BT_DBG("Fd  [%d]", fd);
3353
3354                 otc_info = g_malloc0(sizeof(bluetooth_otc_info_t));
3355                 otc_info->fd = fd;
3356                 otc_info->connected = connected;
3357                 otc_info->address = g_strdup(address);
3358
3359                 _bt_common_event_cb(BLUETOOTH_EVENT_OTC_STATE_CHANGED,
3360                                 result, otc_info,
3361                                 event_info->cb, event_info->user_data);
3362         }
3363
3364         BT_DBG("-");
3365 }
3366
3367 void __bt_hdp_event_filter(GDBusConnection *connection,
3368                                                  const gchar *sender_name,
3369                                                  const gchar *object_path,
3370                                                  const gchar *interface_name,
3371                                                  const gchar *signal_name,
3372                                                  GVariant *parameters,
3373                                                  gpointer user_data)
3374 {
3375         bt_event_info_t *event_info;
3376         int result = BLUETOOTH_ERROR_NONE;
3377
3378         BT_DBG("+");
3379         event_info = (bt_event_info_t *)user_data;
3380         ret_if(event_info == NULL);
3381
3382         if (strcasecmp(object_path, BT_HDP_DEVICE_PATH) != 0)
3383                 return;
3384         if (strcasecmp(interface_name, BT_EVENT_SERVICE) != 0)
3385                 return;
3386
3387         ret_if(signal_name == NULL);
3388
3389         if (strcasecmp(signal_name, BT_HDP_CONNECTED) == 0) {
3390                 const char *address = NULL;
3391                 char *app_handle = NULL;
3392                 bt_hdp_connected_t conn_info;
3393
3394                 g_variant_get(parameters, "(i&s&sui)", &result,
3395                                 &address, &app_handle,
3396                                 &(conn_info.channel_id), &(conn_info.type));
3397
3398                 conn_info.app_handle = app_handle;
3399
3400                 BT_DBG("address: %s, app_handle: %s, ch_id: %d, ch_type: %d",
3401                         address, conn_info.app_handle, conn_info.channel_id, conn_info.type);
3402                 _bt_convert_addr_string_to_type(conn_info.device_address.addr, address);
3403
3404                 if (BLUETOOTH_ERROR_NONE == result)
3405                         result = _bt_hdp_app_acquire_fd(&conn_info);
3406
3407                 _bt_common_event_cb(BLUETOOTH_EVENT_HDP_CONNECTED,
3408                                 result, &conn_info,
3409                                 event_info->cb, event_info->user_data);
3410         } else if (strcasecmp(signal_name, BT_HDP_DISCONNECTED) == 0) {
3411                 const char *address = NULL;
3412                 bt_hdp_disconnected_t disconn_info;
3413
3414                 g_variant_get(parameters, "(i&su)", &result,
3415                                 &address, &(disconn_info.channel_id));
3416
3417                 BT_DBG("address: %s", address);
3418                 _bt_convert_addr_string_to_type(disconn_info.device_address.addr, address);
3419
3420                 _bt_hdp_app_remove_obj_info(disconn_info.channel_id);
3421                 _bt_common_event_cb(BLUETOOTH_EVENT_HDP_DISCONNECTED,
3422                                 result, &disconn_info,
3423                                 event_info->cb, event_info->user_data);
3424         }
3425
3426         BT_DBG("-");
3427 }
3428
3429 static void __bt_remove_all_events(void)
3430 {
3431         bt_event_info_t *info;
3432
3433         while ((info = g_slist_nth_data(event_list, 0)) != NULL)
3434                 _bt_unregister_event(info->event_type);
3435
3436         if (event_list) {
3437                 g_slist_free(event_list);
3438                 event_list = NULL;
3439         }
3440 }
3441
3442 static gboolean __bt_event_is_registered(int event_type)
3443 {
3444         GSList *l;
3445         bt_event_info_t *info;
3446
3447         for (l = event_list; l != NULL; l = g_slist_next(l)) {
3448                 info = l->data;
3449                 if (info == NULL)
3450                         continue;
3451
3452                 if (info->event_type == event_type)
3453                         return TRUE;
3454         }
3455
3456         return FALSE;
3457 }
3458
3459 bt_event_info_t *_bt_event_get_cb_data(int event_type)
3460 {
3461         GSList *l;
3462         bt_event_info_t *info;
3463
3464         for (l = event_list; l != NULL; l = g_slist_next(l)) {
3465                 info = l->data;
3466                 if (info == NULL)
3467                         continue;
3468
3469                 if (info->event_type == event_type)
3470                         return info;
3471         }
3472
3473         return NULL;
3474 }
3475
3476 void _bt_add_server(int server_fd)
3477 {
3478         bt_server_info_t *info;
3479
3480         info = g_new0(bt_server_info_t, 1);
3481         info->server_fd = server_fd;
3482
3483         server_list = g_slist_append(server_list, info);
3484 }
3485
3486 void _bt_remove_server(int server_fd)
3487 {
3488         GSList *l;
3489         bt_server_info_t *info;
3490
3491         for (l = server_list; l != NULL; l = g_slist_next(l)) {
3492                 info = l->data;
3493                 if (info == NULL)
3494                         continue;
3495
3496                 if (info->server_fd == server_fd)
3497                         server_list = g_slist_remove(server_list, (void *)info);
3498
3499                 g_free(info);
3500         }
3501 }
3502
3503 void _bt_set_obex_server_id(int server_type)
3504 {
3505         obex_server_id = server_type;
3506 }
3507
3508 int _bt_get_obex_server_id(void)
3509 {
3510         return obex_server_id;
3511 }
3512
3513 int _bt_init_event_handler(void)
3514 {
3515         if (is_initialized == TRUE) {
3516                 BT_ERR("Connection already exist");
3517                 return BLUETOOTH_ERROR_ALREADY_INITIALIZED;
3518         }
3519
3520         __bt_remove_all_events();
3521
3522         is_initialized = TRUE;
3523
3524         return BLUETOOTH_ERROR_NONE;
3525 }
3526
3527 int _bt_deinit_event_handler(void)
3528 {
3529         if (is_initialized == FALSE) {
3530                 BT_ERR("Connection dose not exist");
3531                 return BLUETOOTH_ERROR_INTERNAL;
3532         }
3533
3534         __bt_remove_all_events();
3535
3536         if (disable_timer_id > 0) {
3537                 g_source_remove(disable_timer_id);
3538                 disable_timer_id = 0;
3539         }
3540
3541         is_initialized = FALSE;
3542
3543         return BLUETOOTH_ERROR_NONE;
3544 }
3545
3546 static void __bt_event_data_free(void *data)
3547 {
3548         bt_event_info_t *cb_data = data;
3549
3550         ret_if(cb_data == NULL);
3551
3552         g_free(cb_data);
3553 }
3554
3555 #ifdef TIZEN_GATT_CLIENT
3556 static void __bt_gatt_client_event_filter(GDBusConnection *connection,
3557                 const gchar *sender_name,
3558                 const gchar *object_path,
3559                 const gchar *interface_name,
3560                 const gchar *signal_name,
3561                 GVariant *parameters,
3562                 gpointer user_data)
3563 {
3564         BT_DBG("GATT Client event handler Entry >>");
3565
3566         bt_event_info_t *event_info;
3567         int result = BLUETOOTH_ERROR_NONE;
3568
3569         event_info = (bt_event_info_t *)user_data;
3570         ret_if(event_info == NULL);
3571
3572         if (strcasecmp(signal_name, BT_GATT_CHAR_VAL_CHANGED) == 0) { /* Done */
3573                 /* Event: BLUETOOTH_EVENT_GATT_CHAR_VAL_CHANGED */
3574                 BT_INFO("GATT Client event[BT_GATT_CHAR_VAL_CHANGED]");
3575                 bt_gatt_char_property_t char_prop;
3576                 const char *address = NULL;
3577                 GVariant *data_var = NULL;
3578                 GVariant *svc_uuid_var = NULL;
3579                 int svc_inst;
3580                 GVariant *char_uuid_var = NULL;
3581                 int svc_uuid_len = 0;
3582                 int char_uuid_len = 0;
3583                 unsigned int i;
3584
3585                 memset(&char_prop, 0x00, sizeof(bt_gatt_char_property_t));
3586
3587                 /* Extract data from DBUS params */
3588                 g_variant_get(parameters, "(i&sn@ayin@ayin@ay)",
3589                                 &result,
3590                                 &address,
3591                                 &svc_uuid_len,
3592                                 &svc_uuid_var,
3593                                 &svc_inst,
3594                                 &char_uuid_len,
3595                                 &char_uuid_var,
3596                                 &char_prop.prop.instance_id,
3597                                 &char_prop.val_len,
3598                                 &data_var);
3599                 g_strlcpy(char_prop.address, address, BT_ADDRESS_STRING_SIZE);
3600
3601                 BT_INFO("GATT Client Char value changed in remote Server [%s]", address);
3602                 BT_INFO("GATT Client Char Val len: [%d]", char_prop.val_len);
3603
3604                 if (char_prop.val_len > 0) {
3605                         /* Copy Data */
3606                         memcpy(&char_prop.value, g_variant_get_data(data_var), char_prop.val_len);
3607                 }
3608
3609                 memcpy(&char_prop.prop.uuid, g_variant_get_data(char_uuid_var), 16);
3610
3611                 /* Copy SVC data */
3612                 memcpy(&char_prop.svc_prop.uuid, g_variant_get_data(svc_uuid_var), 16);
3613                 char_prop.svc_prop.instance_id = svc_inst;
3614
3615                 /* DEBUG */
3616                 for (i = 0; i < char_prop.val_len; i++)
3617                         BT_INFO("Data[%d] = [0x%x]", i, char_prop.value[i]);
3618
3619                 _bt_gatt_client_event_cb(BLUETOOTH_EVENT_GATT_CHAR_VAL_CHANGED,
3620                                 result, &char_prop,
3621                                 event_info->cb, event_info->user_data);
3622         } else if (strcasecmp(signal_name, BT_GATT_CLIENT_READ_CHAR) == 0) { /* Done */
3623                 /* Event: BLUETOOTH_EVENT_GATT_READ_CHAR */
3624                 BT_INFO("GATT Client event[BT_GATT_CLIENT_READ_CHAR]");
3625                 bt_gatt_char_property_t char_prop;
3626                 const char *address = NULL;
3627                 GVariant *data_var = NULL;
3628                 GVariant *svc_uuid_var = NULL;
3629                 int svc_inst = 0;
3630                 GVariant *char_uuid_var = NULL;
3631                 int svc_uuid_len = 0;
3632                 int char_uuid_len = 0;
3633                 unsigned int i;
3634
3635                 memset(&char_prop, 0x00, sizeof(bt_gatt_char_property_t));
3636
3637                 /* Extract data from DBUS params */
3638                 g_variant_get(parameters, "(i&sn@ayin@ayin@ay)",
3639                                 &result,
3640                                 &address,
3641                                 &svc_uuid_len,
3642                                 &svc_uuid_var,
3643                                 &svc_inst,
3644                                 &char_uuid_len,
3645                                 &char_uuid_var,
3646                                 &char_prop.prop.instance_id,
3647                                 &char_prop.val_len,
3648                                 &data_var);
3649                 g_strlcpy(char_prop.address, address, BT_ADDRESS_STRING_SIZE);
3650
3651                 BT_INFO("GATT Client Read Callback from [%s] svc inst [%d] char val len [%d] char inst [%d]",
3652                                 address, svc_inst, char_prop.val_len, char_prop.prop.instance_id);
3653
3654                 if (char_prop.val_len > 0) {
3655                         BT_INFO("Get the read data");
3656                         /* Copy Data */
3657                         memcpy(&char_prop.value, g_variant_get_data(data_var), char_prop.val_len);
3658                 }
3659
3660                 memcpy(&char_prop.prop.uuid, g_variant_get_data(char_uuid_var), 16);
3661
3662                 /* Copy Svc Data */
3663                 memcpy(&char_prop.svc_prop.uuid, g_variant_get_data(svc_uuid_var), 16);
3664                 char_prop.svc_prop.instance_id = svc_inst;
3665
3666                 /* DEBUG */
3667                 for (i = 0; i < char_prop.val_len; i++)
3668                         BT_INFO("Data[%d] = [0x%x]", i, char_prop.value[i]);
3669
3670                 _bt_gatt_client_event_cb(BLUETOOTH_EVENT_GATT_READ_CHAR,
3671                                 result, &char_prop,
3672                                 event_info->cb, event_info->user_data);
3673         } else if (strcasecmp(signal_name, BT_GATT_CLIENT_WRITE_CHAR) == 0) { /* Done */
3674                 /* Event: BLUETOOTH_EVENT_GATT_WRITE_CHAR */
3675                 BT_INFO("GATT Client event[BT_GATT_CLIENT_WRITE_CHAR]");
3676                 bt_gatt_char_property_t char_prop;
3677                 const char *address = NULL;
3678                 GVariant *svc_uuid_var = NULL;
3679                 int svc_inst = 0;
3680                 GVariant *char_uuid_var = NULL;
3681                 int svc_uuid_len = 0;
3682                 int char_uuid_len = 0;
3683
3684                 memset(&char_prop, 0x00, sizeof(bt_gatt_char_property_t));
3685
3686                 /* Extract data from DBUS params */
3687                 g_variant_get(parameters, "(i&sn@ayin@ayi)",
3688                                 &result,
3689                                 &address,
3690                                 &svc_uuid_len,
3691                                 &svc_uuid_var,
3692                                 &svc_inst,
3693                                 &char_uuid_len,
3694                                 &char_uuid_var,
3695                                 &char_prop.prop.instance_id);
3696
3697                 g_strlcpy(char_prop.address, address, BT_ADDRESS_STRING_SIZE);
3698
3699                 BT_DBG("GATT Client Char Write Done in remote Server [%s]", address);
3700
3701                 /* Copy Data */
3702                 memcpy(&char_prop.prop.uuid, g_variant_get_data(char_uuid_var), 16);
3703
3704                 /* Copy Svc Data */
3705                 memcpy(&char_prop.svc_prop.uuid, g_variant_get_data(svc_uuid_var), 16);
3706                 char_prop.svc_prop.instance_id = svc_inst;
3707
3708                 _bt_gatt_client_event_cb(BLUETOOTH_EVENT_GATT_WRITE_CHAR,
3709                                 result, &char_prop,
3710                                 event_info->cb, event_info->user_data);
3711         } else if (strcasecmp(signal_name, BT_GATT_CLIENT_READ_DESC) == 0) { /* Done */
3712                 /* Event: BLUETOOTH_EVENT_GATT_READ_DESC */
3713                 BT_INFO("GATT Client event[BT_GATT_CLIENT_READ_DESC]");
3714                 bt_gatt_char_descriptor_property_t desc_prop;
3715                 const char *address = NULL;
3716                 GVariant *data_var = NULL;
3717                 GVariant *svc_uuid_var = NULL;
3718                 int svc_inst = 0;
3719                 GVariant *char_uuid_var = NULL;
3720                 int char_inst = 0;
3721                 GVariant *desc_uuid_var = NULL;
3722                 int svc_uuid_len = 0;
3723                 int char_uuid_len = 0;
3724                 int desc_uuid_len = 0;
3725                 unsigned int i;
3726
3727                 memset(&desc_prop, 0x00, sizeof(bt_gatt_char_descriptor_property_t));
3728
3729                 /* Extract data from DBUS params */
3730                 g_variant_get(parameters, "(i&sn@ayin@ayin@ayin@ay)",
3731                                 &result,
3732                                 &address,
3733                                 &svc_uuid_len,
3734                                 &svc_uuid_var,
3735                                 &svc_inst,
3736                                 &char_uuid_len,
3737                                 &char_uuid_var,
3738                                 &char_inst,
3739                                 &desc_uuid_len,
3740                                 &desc_uuid_var,
3741                                 &desc_prop.prop.instance_id,
3742                                 &desc_prop.val_len,
3743                                 &data_var);
3744                 g_strlcpy(desc_prop.address, address, BT_ADDRESS_STRING_SIZE);
3745
3746                 BT_DBG("GATT Client Read Descriptor Callback from [%s]", address);
3747                 BT_DBG("GATT Client Descriptor Val len: [%d]", desc_prop.val_len);
3748
3749                 /* Copy Data */
3750                 if (desc_prop.val_len > 0) {
3751                         BT_INFO("Get the desc read data");
3752                         memcpy(&desc_prop.value, g_variant_get_data(data_var), desc_prop.val_len);
3753                 }
3754
3755                 memcpy(&desc_prop.prop.uuid, g_variant_get_data(desc_uuid_var), 16);
3756
3757                 /* Copy Char Data */
3758                 memcpy(&desc_prop.char_prop.uuid, g_variant_get_data(char_uuid_var), 16);
3759                 desc_prop.char_prop.instance_id = char_inst;
3760
3761                 /* Copy Svc Data */
3762                 memcpy(&desc_prop.svc_prop.uuid, g_variant_get_data(svc_uuid_var), 16);
3763                 desc_prop.svc_prop.instance_id = svc_inst;
3764
3765                 /* DEBUG */
3766                 for (i = 0; i < desc_prop.val_len; i++)
3767                         BT_INFO("Data[%d] = [0x%x]", i, desc_prop.value[i]);
3768
3769                 _bt_gatt_client_event_cb(BLUETOOTH_EVENT_GATT_READ_DESC,
3770                                 result, &desc_prop,
3771                                 event_info->cb, event_info->user_data);
3772         } else if (strcasecmp(signal_name, BT_GATT_CLIENT_WRITE_DESC) == 0) { /* Done */
3773                 /* Event: BLUETOOTH_EVENT_GATT_WRITE_DESC */
3774                 BT_INFO("GATT Client event[BT_GATT_CLIENT_WRITE_DESC]");
3775                 bt_gatt_char_descriptor_property_t desc_prop;
3776                 const char *address = NULL;
3777                 GVariant *svc_uuid_var = NULL;
3778                 int svc_inst = 0;
3779                 GVariant *char_uuid_var = NULL;
3780                 int char_inst;
3781                 GVariant *desc_uuid_var = NULL;
3782                 int svc_uuid_len = 0;
3783                 int char_uuid_len = 0;
3784                 int desc_uuid_len = 0;
3785
3786                 memset(&desc_prop, 0x00, sizeof(bt_gatt_char_descriptor_property_t));
3787
3788                 /* Extract data from DBUS params */
3789                 g_variant_get(parameters, "(i&sn@ayin@ayin@ayi)",
3790                                 &result,
3791                                 &address,
3792                                 &svc_uuid_len,
3793                                 &svc_uuid_var,
3794                                 &svc_inst,
3795                                 &char_uuid_len,
3796                                 &char_uuid_var,
3797                                 &char_inst,
3798                                 &desc_uuid_len,
3799                                 &desc_uuid_var,
3800                                 &desc_prop.prop.instance_id);
3801
3802                 g_strlcpy(desc_prop.address, address, BT_ADDRESS_STRING_SIZE);
3803
3804                 BT_INFO("GATT Client Write Descriptor Callback from [%s]", address);
3805                 BT_INFO("GATT Client Descriptor Val len: [%d]", desc_prop.val_len);
3806
3807                 /* Copy Data */
3808                 memcpy(&desc_prop.prop.uuid, g_variant_get_data(desc_uuid_var), 16);
3809
3810                 /* Copy Char Data */
3811                 memcpy(&desc_prop.char_prop.uuid, g_variant_get_data(char_uuid_var), 16);
3812                 desc_prop.char_prop.instance_id = char_inst;
3813
3814                 /* Copy Svc Data */
3815                 memcpy(&desc_prop.svc_prop.uuid, g_variant_get_data(svc_uuid_var), 16);
3816                 desc_prop.svc_prop.instance_id = svc_inst;
3817
3818                 _bt_gatt_client_event_cb(BLUETOOTH_EVENT_GATT_WRITE_DESC,
3819                                 result, &desc_prop,
3820                                 event_info->cb, event_info->user_data);
3821         }
3822
3823         BT_DBG("GATT Client event handler Exit <<");
3824 }
3825
3826 #endif
3827
3828
3829 #ifndef GATT_DIRECT
3830 static void __bt_gatt_server_event_filter(GDBusConnection *connection,
3831                 const gchar *sender_name,
3832                 const gchar *object_path,
3833                 const gchar *interface_name,
3834                 const gchar *signal_name,
3835                 GVariant *parameters,
3836                 gpointer user_data)
3837 {
3838         BT_INFO("GATT Server event handler Entry >>");
3839
3840         bt_event_info_t *event_info;
3841         int result = BLUETOOTH_ERROR_NONE;
3842
3843         event_info = (bt_event_info_t *)user_data;
3844         ret_if(event_info == NULL);
3845 #ifdef TIZEN_GATT_CLIENT
3846         if (strcasecmp(signal_name, BT_GATT_VALUE_CHANGED) == 0) {
3847 #else
3848         if (strcasecmp(signal_name, BT_GATT_CONNECTED) == 0) {
3849                 const char *address = NULL;
3850                 bluetooth_device_address_t dev_address = { {0} };
3851                 BT_DBG("BT_GATT_CONNECTED");
3852                 g_variant_get(parameters, "(i&s)", &result, &address);
3853
3854                 _bt_convert_addr_string_to_type(dev_address.addr, address);
3855                 _bt_gatt_server_event_cb(BLUETOOTH_EVENT_GATT_CONNECTED,
3856                                 result, &dev_address,
3857                                 event_info->cb, event_info->user_data);
3858         } else if (strcasecmp(signal_name, BT_GATT_DISCONNECTED) == 0) {
3859                 const char *address = NULL;
3860                 bluetooth_device_address_t dev_address = { {0} };
3861                 BT_DBG("BT_GATT_DISCONNECTED");
3862                 g_variant_get(parameters, "(i&s)", &result, &address);
3863
3864                 _bt_convert_addr_string_to_type(dev_address.addr, address);
3865                 _bt_gatt_server_event_cb(BLUETOOTH_EVENT_GATT_DISCONNECTED,
3866                                 result, &dev_address,
3867                                 event_info->cb, event_info->user_data);
3868         } else if (strcasecmp(signal_name, BT_GATT_VALUE_CHANGED) == 0) {
3869 #endif
3870                 BT_INFO("GATT Server event[BT_GATT_SERVER_WRITE_REQUESTED]");
3871                 const char *address = NULL;
3872                 GVariant *data_var = NULL;
3873                 int i;
3874                 bluetooth_device_address_t dev_address = { {0} };
3875
3876                 bluetooth_gatt_server_write_requested_info_t write_info;
3877                 memset(&write_info, 0x00, sizeof(bluetooth_gatt_server_write_requested_info_t));
3878
3879                 /* Extract data from DBUS params */
3880                 g_variant_get(parameters, "(iiiiiibb&sn@ay)",
3881                                 &result,
3882                                 &write_info.connection_id,
3883                                 &write_info.request_id,
3884                                 &write_info.attribute_handle,
3885                                 &write_info.offset,
3886                                 &write_info.length,
3887                                 &write_info.need_resp,
3888                                 &write_info.is_prep_write,
3889                                 &address,
3890                                 &write_info.length,
3891                                 &data_var);
3892
3893                 _bt_convert_addr_string_to_type(dev_address.addr,
3894                                 address);
3895
3896                 BT_DBG("GATT Server Write From Remote Client [%s]", address);
3897                 BT_DBG("GATT Server Write len: [%d]", write_info.length);
3898                 BT_DBG("GATT Server Conn ID:   [%d]", write_info.connection_id);
3899                 BT_DBG("GATT Server Req ID:    [%d]", write_info.request_id);
3900                 BT_DBG("GATT Server att handle:[%d]", write_info.attribute_handle);
3901                 BT_DBG("GATT Server Offset:    [%d]", write_info.offset);
3902                 BT_DBG("GATT Server Need Resp: [%d]", write_info.need_resp);
3903                 BT_DBG("GATT Server Is Prep:   [%d]", write_info.is_prep_write);
3904
3905                 /* Copy Data */
3906                 memcpy(&write_info.data.data, g_variant_get_data(data_var), write_info.length);
3907
3908                 memcpy(write_info.device_address.addr,
3909                                 dev_address.addr,
3910                                 BLUETOOTH_ADDRESS_LENGTH);
3911
3912                 /* DEBUG */
3913                 for (i = 0; i < write_info.length; i++)
3914                         BT_DBG("Data[%d] = [0x%x]", i, write_info.data.data[i]);
3915
3916                 _bt_gatt_server_event_cb(BLUETOOTH_EVENT_GATT_SERVER_VALUE_CHANGED,
3917                                 BLUETOOTH_ERROR_NONE, &write_info,
3918                                 event_info->cb, event_info->user_data);
3919         } else if (strcasecmp(signal_name, BT_GATT_SERVER_READ_REQ) == 0) {
3920                 const char *address = NULL;
3921                 bluetooth_device_address_t dev_address = { {0} };
3922                 bluetooth_gatt_server_read_requested_info_t read_info;
3923
3924                 memset(&read_info, 0x00, sizeof(bluetooth_gatt_server_read_requested_info_t));
3925
3926                 /* Extract data from DBUS params */
3927                 g_variant_get(parameters, "(iiiiib&s)", &result,
3928                                 &read_info.connection_id, &read_info.request_id,
3929                                 &read_info.attribute_handle, &read_info.offset,
3930                                 &read_info.is_long, &address);
3931
3932                 _bt_convert_addr_string_to_type(dev_address.addr,
3933                                 address);
3934                 /* Copy Data */
3935                 memcpy(read_info.device_address.addr,
3936                                 dev_address.addr,
3937                                 BLUETOOTH_ADDRESS_LENGTH);
3938
3939                 _bt_gatt_server_event_cb(BLUETOOTH_EVENT_GATT_SERVER_READ_REQUESTED,
3940                                 result, &read_info,
3941                                 event_info->cb, event_info->user_data);
3942         } else if (strcasecmp(signal_name, BT_GATT_SERVER_ACQUIRE_WRITE) == 0) {
3943
3944                 bluetooth_gatt_server_send_acquire_write_response(parameters);
3945
3946         } else if (strcasecmp(signal_name, BT_GATT_SERVER_ACQUIRE_NOTIFICATION) == 0) {
3947
3948                 bluetooth_gatt_server_send_acquire_notify_response(parameters, event_info);
3949
3950         }  else if (strcasecmp(signal_name, BT_GATT_SERVER_NOTIFICATION_COMPLETED) == 0) {
3951                 const char *address = NULL;
3952                 bluetooth_device_address_t dev_address = { {0} };
3953                 bluetooth_gatt_server_indicate_confirmed_info_t info;
3954                 memset(&info, 0x00, sizeof(bluetooth_gatt_server_indicate_confirmed_info_t));
3955
3956                 BT_INFO("GATT Server event[BT_GATT_SERVER_NOTIFICATION_COMPLETED]");
3957                 /* Extract data from DBUS params */
3958                 g_variant_get(parameters, "(i&sib)", &result, &address, &info.handle, &info.completed);
3959
3960                 _bt_convert_addr_string_to_type(dev_address.addr,
3961                                 address);
3962                 /* Copy Data */
3963                 memcpy(info.device_address.addr,
3964                                 dev_address.addr,
3965                                 BLUETOOTH_ADDRESS_LENGTH);
3966
3967                 BT_INFO("GATT Server: Indicate confirmed Handle: [%d] address [%s] completed [%d] result [%d]",
3968                                 info.handle, address, info.completed, result);
3969
3970
3971                 _bt_gatt_server_event_cb(BLUETOOTH_EVENT_GATT_SERVER_NOTIFICATION_COMPLETED,
3972                                 result, &info,
3973                                 event_info->cb, event_info->user_data);
3974         } else if (strcasecmp(signal_name, BT_GATT_SERVER_NOTIFICATION_CHANGED) == 0) {
3975                 const char *address = NULL;
3976                 bluetooth_device_address_t dev_address = { {0} };
3977                 bluetooth_gatt_server_notification_changed_t info;
3978                 memset(&info, 0x00, sizeof(bluetooth_gatt_server_notification_changed_t));
3979
3980                 BT_INFO("GATT Server event[BT_GATT_SERVER_NOTIFICATION_CHANGED]");
3981                 /* Extract data from DBUS params */
3982                 g_variant_get(parameters, "(i&sib)", &result, &address, &info.handle, &info.notification);
3983
3984                 _bt_convert_addr_string_to_type(dev_address.addr,
3985                                 address);
3986                 /* Copy Data */
3987                 memcpy(info.device_address.addr,
3988                                 dev_address.addr,
3989                                 BLUETOOTH_ADDRESS_LENGTH);
3990
3991                 BT_INFO("GATT Server: Notification Enabled?? Handle: [%d] address [%s] Is Enabled [%d] result [%d]",
3992                                 info.handle, address, info.notification, result);
3993
3994                 if (info.notification == FALSE)
3995                         cleanup_gatt_acquire_fd(info.handle);
3996
3997                 _bt_gatt_server_event_cb(BLUETOOTH_EVENT_GATT_SERVER_NOTIFICATION_STATE_CHANGED,
3998                                 result, &info,
3999                                 event_info->cb, event_info->user_data);
4000         } else if (strcasecmp(signal_name, BT_GATT_SERVER_ATT_MTU_CHANGED) == 0) {
4001                 const char *address = NULL;
4002                 bluetooth_device_address_t dev_address = { {0} };
4003                 bluetooth_le_att_mtu_info_t att_mtu_info;
4004                 guint16 mtu;
4005                 guint8 status;
4006                 BT_DBG("BT_GATT_SERVER_ATT_MTU_CHANGED");
4007                 g_variant_get(parameters, "(i&sqy)", &result, &address, &mtu, &status);
4008
4009                 _bt_convert_addr_string_to_type(dev_address.addr, address);
4010
4011                 memset(&att_mtu_info, 0x00, sizeof(bluetooth_le_att_mtu_info_t));
4012                 memcpy(att_mtu_info.device_address.addr,
4013                                         dev_address.addr,
4014                                         BLUETOOTH_ADDRESS_LENGTH);
4015
4016                 att_mtu_info.mtu = mtu;
4017                 att_mtu_info.status = status;
4018
4019                 _bt_common_event_cb(BLUETOOTH_EVENT_GATT_SERVER_ATT_MTU_CHANGED,
4020                                 result, &att_mtu_info,
4021                                 event_info->cb, event_info->user_data);
4022         }
4023
4024
4025         BT_INFO("GATT Server event handler Exit <<");
4026 }
4027 #endif
4028
4029 int _bt_register_event(int event_type, void *event_cb, void *user_data)
4030 {
4031         GDBusConnection *connection_type;
4032         GDBusSignalCallback event_func;
4033         bt_event_info_t *cb_data;
4034         const char *path;
4035         const char *interface = BT_EVENT_SERVICE;
4036
4037         if (is_initialized == FALSE)
4038                 _bt_init_event_handler();
4039
4040         if (__bt_event_is_registered(event_type) == TRUE) {
4041                 BT_ERR("The event is already registed");
4042                 return BLUETOOTH_ERROR_ALREADY_INITIALIZED;
4043         }
4044
4045         switch (event_type) {
4046         case BT_ADAPTER_EVENT:
4047                 event_func = __bt_adapter_event_filter;
4048                 path = BT_ADAPTER_PATH;
4049                 break;
4050         case BT_LE_ADAPTER_EVENT:
4051                 event_func = __bt_adapter_le_event_filter;
4052                 path = BT_LE_ADAPTER_PATH;
4053                 break;
4054         case BT_DEVICE_EVENT:
4055                 event_func = __bt_device_event_filter;
4056                 path = BT_DEVICE_PATH;
4057                 break;
4058         case BT_HID_EVENT:
4059                 event_func = __bt_hid_event_filter;
4060                 path = BT_HID_PATH;
4061                 break;
4062         case BT_HEADSET_EVENT:
4063                 event_func = __bt_headset_event_filter;
4064                 path = BT_HEADSET_PATH;
4065                 break;
4066         case BT_NETWORK_EVENT:
4067                 event_func = __bt_network_event_filter;
4068                 path = BT_NETWORK_PATH;
4069                 break;
4070         case BT_AVRCP_EVENT:
4071                 event_func = __bt_avrcp_event_filter;
4072                 path = BT_AVRCP_PATH;
4073                 break;
4074         case BT_AVRCP_CONTROL_EVENT:
4075                 event_func = __bt_avrcp_control_event_filter;
4076                 path = BT_AVRCP_CONTROL_PATH;
4077                 break;
4078         case BT_OPP_CLIENT_EVENT:
4079                 event_func = __bt_opp_client_event_filter;
4080                 path = BT_OPP_CLIENT_PATH;
4081                 break;
4082         case BT_OPP_SERVER_EVENT:
4083                 event_func = __bt_opp_server_event_filter;
4084                 path = BT_OPP_SERVER_PATH;
4085                 break;
4086         case BT_MAP_CLIENT_EVENT:
4087                 event_func = __bt_map_client_event_filter;
4088                 path = BT_MAP_CLIENT_PATH;
4089                 break;
4090         case BT_PBAP_CLIENT_EVENT:
4091                 event_func = __bt_pbap_client_event_filter;
4092                 path = BT_PBAP_CLIENT_PATH;
4093                 break;
4094         case BT_RFCOMM_CLIENT_EVENT:
4095                 event_func = __bt_rfcomm_client_event_filter;
4096                 path = BT_RFCOMM_CLIENT_PATH;
4097                 break;
4098         case BT_RFCOMM_SERVER_EVENT:
4099                 event_func = __bt_rfcomm_server_event_filter;
4100                 path = BT_RFCOMM_SERVER_PATH;
4101                 break;
4102         case BT_HF_AGENT_EVENT:
4103                 BT_DBG("BT_HF_AGENT_EVENT\n");
4104                 event_func = __bt_hf_agent_event_filter;
4105                 path = BT_HF_AGENT_PATH;
4106                 interface = BT_HF_SERVICE_INTERFACE;
4107                 break;
4108         case BT_A2DP_SOURCE_EVENT:
4109                 BT_DBG("BT_A2DP_SOURCE_EVENT");
4110                 event_func = __bt_a2dp_source_event_filter;
4111                 path = BT_A2DP_SOURCE_PATH;
4112                 break;
4113         case BT_HID_DEVICE_EVENT:
4114                 BT_DBG("BT_HID_DEVICE_EVENT");
4115                 event_func = __bt_hid_device_event_filter;
4116                 path = BT_HID_DEVICE_PATH;
4117                 break;
4118 #ifdef GATT_NO_RELAY
4119         case BT_GATT_BLUEZ_EVENT:
4120                 BT_DBG("BT_GATT_BLUEZ_EVENT");
4121                 event_func = __bt_device_event_filter;
4122                 interface = BT_GATT_CHARACTERISTIC_INTERFACE;
4123                 path = NULL;
4124                 break;
4125 #endif
4126         case BT_TDS_EVENT:
4127                 BT_DBG("BT_TDS_EVENT");
4128                 event_func = __bt_tds_event_filter;
4129                 path = BT_TDS_PATH;
4130                 break;
4131         case BT_OTP_EVENT:
4132                 BT_DBG("BT_OTP_EVENT");
4133                 event_func = __bt_otp_event_filter;
4134                 path = BT_OTP_PATH;
4135                 break;
4136         case BT_HDP_EVENT:
4137                 BT_DBG("BT_HDP_EVENT");
4138                 event_func = __bt_hdp_event_filter;
4139                 path = BT_HDP_DEVICE_PATH;
4140                 break;
4141 #ifndef GATT_DIRECT
4142         case BT_GATT_SERVER_EVENT:
4143                 event_func = __bt_gatt_server_event_filter;
4144                 path = BT_GATT_SERVER_PATH;
4145                 break;
4146 #endif
4147
4148 #ifdef TIZEN_GATT_CLIENT
4149         case BT_GATT_CLIENT_EVENT:
4150                 event_func = __bt_gatt_client_event_filter;
4151                 path = BT_GATT_CLIENT_PATH;
4152                 break;
4153 #endif
4154         default:
4155                 BT_ERR("Unknown event");
4156                 return BLUETOOTH_ERROR_INTERNAL;
4157         }
4158
4159         connection_type = _bt_get_system_private_conn();
4160         if (connection_type == NULL)
4161                 return BLUETOOTH_ERROR_INTERNAL;
4162
4163         cb_data = g_new0(bt_event_info_t, 1);
4164
4165         cb_data->event_type = event_type;
4166         cb_data->cb = event_cb;
4167         cb_data->user_data = user_data;
4168
4169         cb_data->id = g_dbus_connection_signal_subscribe(connection_type,
4170                                 NULL, interface, NULL, path, NULL, 0,
4171                                 event_func, cb_data, NULL);
4172
4173         event_list = g_slist_append(event_list, cb_data);
4174
4175         return BLUETOOTH_ERROR_NONE;
4176 }
4177
4178 int _bt_unregister_event(int event_type)
4179 {
4180         GDBusConnection *connection_type;
4181         bt_event_info_t *cb_data;
4182
4183         if (is_initialized == FALSE) {
4184                 BT_ERR("Event is not registered");
4185                 return BLUETOOTH_ERROR_NOT_INITIALIZED;
4186         }
4187
4188         if (__bt_event_is_registered(event_type) == FALSE) {
4189                 BT_ERR("Not registered event");
4190                 return BLUETOOTH_ERROR_INTERNAL;
4191         }
4192
4193         cb_data = _bt_event_get_cb_data(event_type);
4194
4195         if (cb_data == NULL) {
4196                 BT_ERR("No matched event data");
4197                 return BLUETOOTH_ERROR_INTERNAL;
4198         }
4199
4200         connection_type = _bt_get_system_private_conn();
4201
4202         event_list = g_slist_remove(event_list, (void *)cb_data);
4203
4204         retv_if(connection_type == NULL, BLUETOOTH_ERROR_INTERNAL);
4205
4206         g_dbus_connection_signal_unsubscribe(connection_type, cb_data->id);
4207
4208         __bt_event_data_free((void *)cb_data);
4209
4210         return BLUETOOTH_ERROR_NONE;
4211 }
4212
4213 static void __bt_name_owner_changed(GDBusConnection *connection,
4214                                                  const gchar *sender_name,
4215                                                  const gchar *object_path,
4216                                                  const gchar *interface_name,
4217                                                  const gchar *signal_name,
4218                                                  GVariant *parameters,
4219                                                  gpointer user_data)
4220 {
4221         const char *name = NULL;
4222         const char *old_owner = NULL;
4223         const char *new_owner = NULL;
4224         bt_event_info_t *event_info;
4225
4226         g_variant_get(parameters, "(&s&s&s)", &name, &old_owner, &new_owner);
4227
4228         if (g_strcmp0(name, BT_DBUS_NAME) == 0 &&
4229                         (new_owner != NULL && *new_owner == '\0')) {
4230                 BT_DBG("bt-service is terminated");
4231                 event_info = _bt_event_get_cb_data(BT_ADAPTER_EVENT);
4232                 if (event_info == NULL)
4233                         return;
4234
4235                 if (disable_timer_id > 0)
4236                         g_source_remove(disable_timer_id);
4237
4238                 disable_timer_id = g_timeout_add(BT_RELIABLE_DISABLE_TIME,
4239                                 (GSourceFunc)__bt_reliable_disable_cb,
4240                                 event_info);
4241         }
4242 }
4243
4244 void _bt_register_name_owner_changed(void)
4245 {
4246         GDBusConnection *connection_type;
4247
4248         connection_type = _bt_get_system_private_conn();
4249         if (connection_type == NULL) {
4250                 BT_ERR("Unable to get the bus");
4251                 return;
4252         }
4253         owner_sig_id = g_dbus_connection_signal_subscribe(connection_type,
4254                                 NULL, BT_EVENT_FREEDESKTOP,
4255                                 BT_NAME_OWNER_CHANGED, NULL, NULL, 0,
4256                                 __bt_name_owner_changed, NULL, NULL);
4257 }
4258
4259 void _bt_unregister_name_owner_changed(void)
4260 {
4261         GDBusConnection *connection_type;
4262
4263         connection_type = _bt_get_system_private_conn();
4264         if (connection_type != NULL && owner_sig_id > 0) {
4265                 g_dbus_connection_signal_unsubscribe(connection_type,
4266                                                         owner_sig_id);
4267                 owner_sig_id = 0;
4268         }
4269 }
4270
4271 static void __bt_gatt_get_uuid_from_path(char *path, char **service_uuid)
4272 {
4273         GDBusProxy *proxy = NULL;
4274         GError *err = NULL;
4275         GDBusConnection *g_conn;
4276         GVariant *ret = NULL;
4277         GVariant *value = NULL;
4278
4279         g_conn = _bt_get_system_private_conn();
4280         ret_if(g_conn == NULL);
4281
4282         proxy = g_dbus_proxy_new_sync(g_conn,
4283                                 G_DBUS_PROXY_FLAGS_DO_NOT_LOAD_PROPERTIES, NULL,
4284                                 BT_BLUEZ_NAME,
4285                                 path,
4286                                 BT_PROPERTIES_INTERFACE,
4287                                 NULL, &err);
4288
4289         ret_if(proxy == NULL);
4290
4291         ret = g_dbus_proxy_call_sync(proxy, "Get",
4292                         g_variant_new("(ss)", GATT_SERV_INTERFACE, "UUID"),
4293                         G_DBUS_CALL_FLAGS_NONE, -1, NULL, &err);
4294         if (err) {
4295                 BT_ERR("DBus Error : %s", err->message);
4296                 g_clear_error(&err);
4297         } else {
4298                 g_variant_get(ret, "(v)", &value);
4299                 *service_uuid = g_variant_dup_string(value, NULL);
4300                 g_variant_unref(value);
4301                 g_variant_unref(ret);
4302         }
4303
4304         if (proxy)
4305                 g_object_unref(proxy);
4306
4307         return;
4308 }
4309
4310
4311 static void __bt_manager_event_filter(GDBusConnection *connection,
4312                                         const gchar *sender_name,
4313                                         const gchar *object_path,
4314                                         const gchar *interface_name,
4315                                         const gchar *signal_name,
4316                                         GVariant *parameters,
4317                                         gpointer user_data)
4318 {
4319         char *path = NULL;
4320         GVariantIter *interface_iter = NULL;
4321         char *interface_str = NULL;
4322         bt_gatt_service_change_t change;
4323         char secure_address[BT_ADDRESS_STRING_SIZE] = { 0 };
4324         bt_user_info_t *user_info = NULL;
4325
4326         user_info = _bt_get_user_data(BT_COMMON);
4327         if (user_info == NULL) {
4328                 BT_ERR("There is no registered common event callback");
4329                 return;
4330         }
4331
4332         if (strcasecmp(signal_name, "GattServiceAdded") == 0) {
4333                 g_variant_get(parameters, "(&s)", &path);
4334
4335                 _bt_convert_device_path_to_addr_type(path, change.device_addr.addr);
4336                 _bt_convert_addr_type_to_secure_string(secure_address,
4337                                                        change.device_addr.addr);
4338
4339                 if (_bluetooth_gatt_check_service_change_watcher_address(&change.device_addr)
4340                         == FALSE) {
4341                         BT_INFO("GATT Service [%s] added, but no watcher for %s",
4342                                                         path, secure_address);
4343                         return;
4344                 } else {
4345                         char *uuid = NULL;
4346                         char *name = NULL;
4347                         __bt_gatt_get_uuid_from_path(path, &uuid);
4348                         bluetooth_get_uuid_name(uuid, &name);
4349
4350                         BT_INFO(" ### GATT Service added [%s] [%s]",
4351                                                         path, name);
4352                         g_free(name);
4353                         g_free(uuid);
4354                 }
4355
4356                 change.svc_path = g_strdup(path);
4357                 change.change_type = BLUETOOTH_GATT_SERVICE_CHANGE_TYPE_ADD;
4358                 _bt_common_event_cb(BLUETOOTH_EVENT_GATT_CLIENT_SERVICE_CHANGED,
4359                                     BLUETOOTH_ERROR_NONE, &change,
4360                                     user_info->cb, user_info->user_data);
4361                 g_free(change.svc_path);
4362         } else if (strcasecmp(signal_name, "InterfacesRemoved") == 0) {
4363                 g_variant_get(parameters, "(&oas)", &path, &interface_iter);
4364                 if (!path) {
4365                         BT_ERR("Invalid adapter path");
4366                         g_variant_iter_free(interface_iter);
4367                         return;
4368                 }
4369
4370                 _bt_convert_device_path_to_addr_type(path, change.device_addr.addr);
4371                 if (!_bluetooth_gatt_check_service_change_watcher_address(&change.device_addr)) {
4372                         g_variant_iter_free(interface_iter);
4373                         return;
4374                 }
4375
4376                 while (g_variant_iter_loop(interface_iter, "&s", &interface_str)) {
4377                         if (g_strcmp0(interface_str, GATT_SERV_INTERFACE) != 0)
4378                                 continue;
4379
4380                         BT_INFO(" ### GATT Service removed [%s]", path);
4381
4382                         change.svc_path = g_strdup(path);
4383                         change.change_type = BLUETOOTH_GATT_SERVICE_CHANGE_TYPE_REMOVE;
4384                         _bt_common_event_cb(
4385                                         BLUETOOTH_EVENT_GATT_CLIENT_SERVICE_CHANGED,
4386                                         BLUETOOTH_ERROR_NONE, &change,
4387                                         user_info->cb, user_info->user_data);
4388                         g_free(change.svc_path);
4389                         break;
4390                 }
4391                 g_variant_iter_free(interface_iter);
4392         }
4393 }
4394
4395 int _bt_register_manager_subscribe_signal(gboolean subscribe)
4396 {
4397         GDBusConnection *g_conn;
4398         static guint service_added_id = 0;
4399         static guint interface_removed_id = 0;
4400
4401         g_conn = _bt_get_system_private_conn();
4402         if (g_conn == NULL)
4403                 return BLUETOOTH_ERROR_INTERNAL;
4404
4405         if (subscribe == TRUE) {
4406                 if (service_added_id == 0) {
4407                         service_added_id = g_dbus_connection_signal_subscribe(g_conn,
4408                                         NULL, GATT_SERV_INTERFACE,
4409                                         "GattServiceAdded", NULL, NULL, 0,
4410                                         __bt_manager_event_filter,
4411                                         NULL, NULL);
4412                 }
4413                 if (interface_removed_id == 0) {
4414                         interface_removed_id = g_dbus_connection_signal_subscribe(g_conn,
4415                                         NULL, BT_MANAGER_INTERFACE,
4416                                         "InterfacesRemoved", NULL, NULL, 0,
4417                                         __bt_manager_event_filter,
4418                                         NULL, NULL);
4419                 }
4420         } else {
4421                 if (service_added_id > 0) {
4422                         g_dbus_connection_signal_unsubscribe(g_conn,
4423                                         service_added_id);
4424                         service_added_id = 0;
4425                 }
4426                 if (interface_removed_id > 0) {
4427                         g_dbus_connection_signal_unsubscribe(g_conn,
4428                                         interface_removed_id);
4429                         interface_removed_id = 0;
4430                 }
4431         }
4432
4433         return BLUETOOTH_ERROR_NONE;
4434 }
4435