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