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                 const char *title;
1644                 const char *artist;
1645                 const char *album;
1646                 const char *genre;
1647                 unsigned int total_tracks;
1648                 unsigned int number;
1649                 unsigned int duration;
1650
1651                 g_variant_get(parameters, "(&s&s&s&suuu)", &title,
1652                                                 &artist, &album, &genre,
1653                                                 &total_tracks, &number,
1654                                                 &duration);
1655                 memset(&metadata, 0x00, sizeof(media_metadata_attributes_t));
1656
1657                 metadata.title = title;
1658                 metadata.artist = artist;
1659                 metadata.album = album;
1660                 metadata.genre = genre;
1661                 metadata.total_tracks = total_tracks;
1662                 metadata.number = number;
1663                 metadata.duration = duration;
1664
1665                 _bt_avrcp_event_cb(BLUETOOTH_EVENT_AVRCP_TRACK_CHANGED,
1666                                 result, &metadata,
1667                                 event_info->cb, event_info->user_data);
1668         }
1669 }
1670
1671 void __bt_opp_client_event_filter(GDBusConnection *connection,
1672                                                  const gchar *sender_name,
1673                                                  const gchar *object_path,
1674                                                  const gchar *interface_name,
1675                                                  const gchar *signal_name,
1676                                                  GVariant *parameters,
1677                                                  gpointer user_data)
1678 {
1679         bt_event_info_t *event_info;
1680         int result = BLUETOOTH_ERROR_NONE;
1681         event_info = (bt_event_info_t *)user_data;
1682         ret_if(event_info == NULL);
1683
1684         if (strcasecmp(object_path, BT_OPP_CLIENT_PATH) != 0)
1685                 return;
1686         if (strcasecmp(interface_name, BT_EVENT_SERVICE) != 0)
1687                 return;
1688
1689         ret_if(signal_name == NULL);
1690
1691         if (strcasecmp(signal_name, BT_OPP_CONNECTED) == 0) {
1692                 const char *address = NULL;
1693                 int request_id = 0;
1694                 bluetooth_device_address_t dev_address = { {0} };
1695
1696                 g_variant_get(parameters, "(i&si)", &result,
1697                                                 &address, &request_id);
1698
1699                 if (__bt_is_request_id_exist(request_id) == FALSE) {
1700                         BT_ERR("Different request id!");
1701                         return;
1702                 }
1703
1704                 _bt_convert_addr_string_to_type(dev_address.addr,
1705                                                 address);
1706
1707                 _bt_common_event_cb(BLUETOOTH_EVENT_OPC_CONNECTED,
1708                                 result, &dev_address,
1709                                 event_info->cb, event_info->user_data);
1710
1711                 if (result != BLUETOOTH_ERROR_NONE)
1712                         __bt_remove_push_request_id(request_id);
1713
1714         } else if (strcasecmp(signal_name, BT_OPP_DISCONNECTED) == 0) {
1715                 const char *address = NULL;
1716                 int request_id = 0;
1717                 bluetooth_device_address_t dev_address = { {0} };
1718
1719                 g_variant_get(parameters, "(i&si)", &result, &address,
1720                                                         &request_id);
1721
1722                 if (__bt_is_request_id_exist(request_id) == FALSE) {
1723                         BT_ERR("Different request id!");
1724                         return;
1725                 }
1726
1727                 _bt_convert_addr_string_to_type(dev_address.addr,
1728                                                 address);
1729
1730                 _bt_common_event_cb(BLUETOOTH_EVENT_OPC_DISCONNECTED,
1731                                 result, &dev_address,
1732                                 event_info->cb, event_info->user_data);
1733
1734                 __bt_remove_push_request_id(request_id);
1735         } else if (strcasecmp(signal_name, BT_TRANSFER_STARTED) == 0) {
1736                 const char *file_name = NULL;
1737                 const char *device_addr = NULL;
1738                 int request_id = 0;
1739                 guint64 size = 0;
1740                 bt_opc_transfer_info_t transfer_info;
1741
1742                 g_variant_get(parameters, "(i&s&sti)", &result, &device_addr, &file_name,
1743                                                 &size, &request_id);
1744
1745                 if (__bt_is_request_id_exist(request_id) == FALSE) {
1746                         BT_ERR("Different request id!");
1747                         return;
1748                 }
1749
1750                 memset(&transfer_info, 0x00, sizeof(bt_opc_transfer_info_t));
1751
1752                 transfer_info.filename = g_strdup(file_name);
1753                 transfer_info.device_addr = g_strdup(device_addr);
1754                 transfer_info.size = size;
1755
1756                 _bt_common_event_cb(BLUETOOTH_EVENT_OPC_TRANSFER_STARTED,
1757                                 result, &transfer_info,
1758                                 event_info->cb, event_info->user_data);
1759
1760                 g_free(transfer_info.device_addr);
1761                 g_free(transfer_info.filename);
1762         } else if (strcasecmp(signal_name, BT_TRANSFER_PROGRESS) == 0) {
1763                 const char *file_name = NULL;
1764                 int request_id = 0;
1765                 guint64 size = 0;
1766                 int progress = 0;
1767                 bt_opc_transfer_info_t transfer_info;
1768
1769                 g_variant_get(parameters, "(i&stii)", &result,
1770                         &file_name, &size, &progress, &request_id);
1771
1772                 if (__bt_is_request_id_exist(request_id) == FALSE) {
1773                         BT_ERR("Different request id!");
1774                         return;
1775                 }
1776
1777                 memset(&transfer_info, 0x00, sizeof(bt_opc_transfer_info_t));
1778
1779                 transfer_info.filename = g_strdup(file_name);
1780                 transfer_info.size = size;
1781                 transfer_info.percentage = progress;
1782
1783                 _bt_common_event_cb(BLUETOOTH_EVENT_OPC_TRANSFER_PROGRESS,
1784                                 result, &transfer_info,
1785                                 event_info->cb, event_info->user_data);
1786
1787                 g_free(transfer_info.filename);
1788         } else if (strcasecmp(signal_name, BT_TRANSFER_COMPLETED) == 0) {
1789                 const char *file_name = NULL;
1790                 const char *device_addr = NULL;
1791                 int request_id = 0;
1792                 guint64 size = 0;
1793                 bt_opc_transfer_info_t transfer_info;
1794
1795                 g_variant_get(parameters, "(i&s&sti)", &result, &device_addr,
1796                                         &file_name, &size, &request_id);
1797
1798                 if (__bt_is_request_id_exist(request_id) == FALSE) {
1799                         BT_ERR("Different request id!");
1800                         return;
1801                 }
1802
1803                 memset(&transfer_info, 0x00, sizeof(bt_opc_transfer_info_t));
1804
1805                 transfer_info.device_addr = g_strdup(device_addr);
1806                 transfer_info.filename = g_strdup(file_name);
1807                 transfer_info.size = size;
1808
1809                 _bt_common_event_cb(BLUETOOTH_EVENT_OPC_TRANSFER_COMPLETE,
1810                                 result, &transfer_info,
1811                                 event_info->cb, event_info->user_data);
1812
1813                 g_free(transfer_info.device_addr);
1814                 g_free(transfer_info.filename);
1815         }
1816 }
1817
1818 void __bt_opp_server_event_filter(GDBusConnection *connection,
1819                                                  const gchar *sender_name,
1820                                                  const gchar *object_path,
1821                                                  const gchar *interface_name,
1822                                                  const gchar *signal_name,
1823                                                  GVariant *parameters,
1824                                                  gpointer user_data)
1825 {
1826         bt_event_info_t *event_info;
1827         int result = BLUETOOTH_ERROR_NONE;
1828         event_info = (bt_event_info_t *)user_data;
1829         ret_if(event_info == NULL);
1830
1831         if (strcasecmp(object_path, BT_OPP_SERVER_PATH) != 0)
1832                 return;
1833         if (strcasecmp(interface_name, BT_EVENT_SERVICE) != 0)
1834                 return;
1835
1836         ret_if(signal_name == NULL);
1837
1838         if (strcasecmp(signal_name, BT_TRANSFER_AUTHORIZED) == 0) {
1839                 /* Native only event */
1840                 const char *file_name = NULL;
1841                 const char *address = NULL;
1842                 const char *device_name = NULL;
1843                 guint64 size = 0;
1844                 bt_obex_server_authorize_into_t auth_info;
1845
1846                 g_variant_get(parameters, "(i&st&s&s)", &result, &file_name, &size,
1847                                 &address, &device_name);
1848
1849                 /* OSP server: Don't get this event */
1850                 ret_if(obex_server_id == BT_CUSTOM_SERVER);
1851
1852                 memset(&auth_info, 0x00, sizeof(bt_obex_server_authorize_into_t));
1853
1854                 auth_info.filename = g_strdup(file_name);
1855                 auth_info.length = size;
1856                 auth_info.address = g_strdup(address);
1857                 auth_info.name = g_strdup(device_name);
1858                 _bt_common_event_cb(BLUETOOTH_EVENT_OBEX_SERVER_TRANSFER_AUTHORIZE,
1859                                 result, &auth_info,
1860                                 event_info->cb, event_info->user_data);
1861
1862                 g_free(auth_info.filename);
1863                 g_free(auth_info.address);
1864                 g_free(auth_info.name);
1865         } else if (strcasecmp(signal_name, BT_CONNECTION_AUTHORIZED) == 0) {
1866                 /* OSP only event */
1867                 const char *address = NULL;
1868                 const char *name = NULL;
1869                 bluetooth_device_address_t dev_address = { {0} };
1870
1871                 g_variant_get(parameters, "(i&s&s)", &result, &address, &name);
1872
1873                 /* Native server: Don't get this event */
1874                 ret_if(obex_server_id == BT_NATIVE_SERVER);
1875
1876                 _bt_convert_addr_string_to_type(dev_address.addr,
1877                                                 address);
1878
1879                 _bt_common_event_cb(BLUETOOTH_EVENT_OBEX_SERVER_CONNECTION_AUTHORIZE,
1880                                 result, &dev_address,
1881                                 event_info->cb, event_info->user_data);
1882         } else if (strcasecmp(signal_name, BT_TRANSFER_CONNECTED) == 0) {
1883                 bt_obex_server_connection_info_t conn_info = {0, };
1884                 char *address = NULL;
1885                 char *name = NULL;
1886                 int transfer_id = -1;
1887                 g_variant_get(parameters, "(i&s&si)", &result,
1888                                 &address, &name, &transfer_id);
1889
1890                 conn_info.address = g_strdup(address);
1891                 conn_info.device_name = g_strdup(name);
1892                 conn_info.transfer_id = transfer_id;
1893
1894                 _bt_common_event_cb(BLUETOOTH_EVENT_OBEX_SERVER_TRANSFER_CONNECTED,
1895                                         result, &conn_info, event_info->cb,
1896                                         event_info->user_data);
1897
1898                 g_free(conn_info.address);
1899                 g_free(conn_info.device_name);
1900         } else if (strcasecmp(signal_name, BT_TRANSFER_DISCONNECTED) == 0) {
1901                 bt_obex_server_transfer_info_t transfer_info = {0, };
1902                 char *address = NULL;
1903                 int transfer_id = -1;
1904                 g_variant_get(parameters, "(i&si)", &result, &address, &transfer_id);
1905                 DBG_SECURE("address: %s, transfer_id: %d", address, transfer_id);
1906
1907                 transfer_info.address = g_strdup(address);
1908                 transfer_info.transfer_id = transfer_id;
1909
1910                 _bt_common_event_cb(BLUETOOTH_EVENT_OBEX_SERVER_TRANSFER_DISCONNECTED,
1911                                         result, &transfer_info, event_info->cb,
1912                                         event_info->user_data);
1913                 g_free(transfer_info.address);
1914         } else if (strcasecmp(signal_name, BT_TRANSFER_STARTED) == 0) {
1915                 const char *device_name = NULL;
1916                 const char *file_name = NULL;
1917                 const char *type = NULL;
1918                 const char *address = NULL;
1919                 GVariantIter *iter = NULL;
1920                 int i = 0;
1921                 guchar byte;
1922                 int transfer_id = 0;
1923                 int server_type = 0; /* bt_server_type_t */
1924                 guint64 size = 0;
1925                 bt_obex_server_transfer_info_t transfer_info;
1926
1927                 g_variant_get(parameters, "(i&s&s&s&stii(ay))", &result, &device_name,
1928                         &file_name, &type, &address, &size, &transfer_id, &server_type, &iter);
1929
1930                 /* Other server's event */
1931                 ret_if(obex_server_id != server_type &&
1932                         server_type != BT_FTP_SERVER);
1933
1934                 memset(&transfer_info, 0x00, sizeof(bt_obex_server_transfer_info_t));
1935
1936                 transfer_info.contact_auth_info = g_malloc0(sizeof(unsigned char) * 5);
1937
1938                 for (i = 0; i < 5 && g_variant_iter_loop(iter, "y", &byte); ++i)
1939                         transfer_info.contact_auth_info[i] = byte;
1940
1941                 transfer_info.device_name = g_strdup(device_name);
1942                 transfer_info.filename = g_strdup(file_name);
1943                 transfer_info.type = g_strdup(type);
1944                 transfer_info.address = g_strdup(address);
1945                 transfer_info.file_size = size;
1946                 transfer_info.transfer_id = transfer_id;
1947                 transfer_info.server_type = (server_type == BT_FTP_SERVER) ?
1948                                                 FTP_SERVER : OPP_SERVER;
1949
1950                 _bt_common_event_cb(BLUETOOTH_EVENT_OBEX_SERVER_TRANSFER_STARTED,
1951                                 result, &transfer_info,
1952                                 event_info->cb, event_info->user_data);
1953
1954                 g_free(transfer_info.filename);
1955                 g_free(transfer_info.type);
1956                 g_free(transfer_info.device_name);
1957                 g_free(transfer_info.address);
1958                 g_free(transfer_info.contact_auth_info);
1959                 g_variant_iter_free(iter);
1960         } else if (strcasecmp(signal_name, BT_TRANSFER_PROGRESS) == 0) {
1961                 const char *file_name = NULL;
1962                 const char *type = NULL;
1963                 const char *device_name = NULL;
1964                 const char *address = NULL;
1965                 int transfer_id = 0;
1966                 int progress = 0;
1967                 int server_type = 0; /* bt_server_type_t */
1968                 guint64 size = 0;
1969                 bt_obex_server_transfer_info_t transfer_info;
1970
1971                 g_variant_get(parameters, "(i&s&s&s&stiii)", &result, &file_name,
1972                                                 &type, &device_name, &address, &size, &transfer_id,
1973                                                 &progress, &server_type);
1974
1975                 /* Other server's event */
1976                 ret_if(obex_server_id != server_type &&
1977                         server_type != BT_FTP_SERVER);
1978
1979                 memset(&transfer_info, 0x00, sizeof(bt_obex_server_transfer_info_t));
1980
1981                 transfer_info.filename = g_strdup(file_name);
1982                 transfer_info.type = g_strdup(type);
1983                 transfer_info.device_name = g_strdup(device_name);
1984                 transfer_info.address = g_strdup(address);
1985                 transfer_info.file_size = size;
1986                 transfer_info.transfer_id = transfer_id;
1987                 transfer_info.percentage = progress;
1988                 transfer_info.server_type = (server_type == BT_FTP_SERVER) ?
1989                                                 FTP_SERVER : OPP_SERVER;
1990
1991                 _bt_common_event_cb(BLUETOOTH_EVENT_OBEX_SERVER_TRANSFER_PROGRESS,
1992                                 result, &transfer_info,
1993                                 event_info->cb, event_info->user_data);
1994
1995                 g_free(transfer_info.filename);
1996                 g_free(transfer_info.device_name);
1997                 g_free(transfer_info.address);
1998                 g_free(transfer_info.type);
1999         } else if (strcasecmp(signal_name, BT_TRANSFER_COMPLETED) == 0) {
2000                 const char *file_name = NULL;
2001                 const char *device_name = NULL;
2002                 const char *address = NULL;
2003                 const char *type = NULL;
2004                 const char *file_path;
2005                 int transfer_id = 0;
2006                 int server_type = 0; /* bt_server_type_t */
2007                 guint64 size = 0;
2008                 bt_obex_server_transfer_info_t transfer_info;
2009
2010                 g_variant_get(parameters, "(i&s&s&s&s&stii)", &result, &file_name,
2011                                         &type, &device_name, &file_path, &address, &size,
2012                                         &transfer_id, &server_type);
2013
2014                 /* Other server's event */
2015                 ret_if(obex_server_id != server_type &&
2016                         server_type != BT_FTP_SERVER);
2017
2018                 memset(&transfer_info, 0x00, sizeof(bt_obex_server_transfer_info_t));
2019
2020                 transfer_info.filename = g_strdup(file_name);
2021                 transfer_info.type = g_strdup(type);
2022                 transfer_info.device_name = g_strdup(device_name);
2023                 transfer_info.file_path = g_strdup(file_path);
2024                 transfer_info.address = g_strdup(address);
2025                 transfer_info.file_size = size;
2026                 transfer_info.transfer_id = transfer_id;
2027                 transfer_info.server_type = (server_type == BT_FTP_SERVER) ?
2028                                                 FTP_SERVER : OPP_SERVER;
2029
2030                 _bt_common_event_cb(BLUETOOTH_EVENT_OBEX_SERVER_TRANSFER_COMPLETED,
2031                                 result, &transfer_info,
2032                                 event_info->cb, event_info->user_data);
2033
2034                 g_free(transfer_info.filename);
2035                 g_free(transfer_info.type);
2036                 g_free(transfer_info.device_name);
2037                 g_free(transfer_info.address);
2038                 g_free(transfer_info.file_path);
2039         }
2040 }
2041
2042 void __bt_map_client_event_filter(GDBusConnection *connection,
2043                                                  const gchar *sender_name,
2044                                                  const gchar *object_path,
2045                                                  const gchar *interface_name,
2046                                                  const gchar *signal_name,
2047                                                  GVariant *parameters,
2048                                                  gpointer user_data)
2049 {
2050         BT_DBG("Entered __bt_map_client_event_filter");
2051         bt_event_info_t *event_info;
2052         int result = BLUETOOTH_ERROR_NONE;
2053         event_info = (bt_event_info_t *)user_data;
2054         ret_if(event_info == NULL);
2055
2056         if (strcasecmp(object_path, BT_MAP_CLIENT_PATH) != 0)
2057                 return;
2058         if (strcasecmp(interface_name, BT_EVENT_SERVICE) != 0)
2059                 return;
2060
2061         ret_if(signal_name == NULL);
2062
2063         if (strcasecmp(signal_name, BT_MAP_CONNECTED) == 0) {
2064                 const char *address = NULL;
2065                 int request_id = 0;
2066                 bluetooth_device_address_t dev_address = { {0} };
2067
2068                 g_variant_get(parameters, "(i&si)", &result,
2069                                                 &address, &request_id);
2070
2071                 if (__bt_is_request_id_exist(request_id) == FALSE) {
2072                         BT_ERR("Different request id!");
2073                         return;
2074                 }
2075
2076                 _bt_convert_addr_string_to_type(dev_address.addr,
2077                                                 address);
2078
2079                 _bt_common_event_cb(BLUETOOTH_EVENT_MAP_CONNECTED,
2080                                 result, &dev_address,
2081                                 event_info->cb, event_info->user_data);
2082
2083                 if (result != BLUETOOTH_ERROR_NONE)
2084                         __bt_remove_push_request_id(request_id);
2085         } else if (strcasecmp(signal_name, BT_MAP_DISCONNECTED) == 0) {
2086                 const char *address = NULL;
2087                 int request_id = 0;
2088                 bluetooth_device_address_t dev_address = { {0} };
2089
2090                 g_variant_get(parameters, "(i&si)", &result, &address,
2091                                 &request_id);
2092
2093                 if (__bt_is_request_id_exist(request_id) == FALSE) {
2094                         BT_ERR("Different request id!");
2095                         return;
2096                 }
2097
2098                 _bt_convert_addr_string_to_type(dev_address.addr,
2099                                 address);
2100
2101                 _bt_common_event_cb(BLUETOOTH_EVENT_MAP_DISCONNECTED,
2102                                 result, &dev_address,
2103                                 event_info->cb, event_info->user_data);
2104
2105                 __bt_remove_push_request_id(request_id);
2106         } else if (strcasecmp(signal_name, BT_MAP_LIST_FOLDERS_COMPLETE) == 0) {
2107                 int request_id = 0;
2108                 GVariant* folder_list_var = NULL;
2109
2110                 g_variant_get(parameters, "(iiv)", &result, &request_id, &folder_list_var);
2111                 if (__bt_is_request_id_exist(request_id) == FALSE) {
2112                         BT_ERR("Different request id!");
2113                         return;
2114                 }
2115
2116                 GVariantIter* iter;
2117
2118                 bt_map_client_folders_s folders_struct = {0,};
2119                 g_variant_get(folder_list_var, "(aa{sv})", &iter);
2120
2121                 folders_struct.size = g_variant_iter_n_children(iter);
2122                 folders_struct.names = (char**) g_malloc0(folders_struct.size * sizeof(*(folders_struct.names)));
2123                 BT_DBG("g_variant_iter_n_children: %d", folders_struct.size);
2124                 GVariantIter* res = NULL;
2125                 int i = 0;
2126                 while (g_variant_iter_loop(iter, "a{sv}", &res)) {
2127                         char* key = NULL;
2128                         GVariant* value = NULL;
2129                         while (g_variant_iter_loop(res, "{sv}", &key, &value)) {
2130                                 char* string_value = NULL;
2131                                 g_variant_get(value, "s", &string_value);
2132                                 BT_DBG("got folder name: %s", string_value);
2133                                 folders_struct.names[i] = strdup(string_value);
2134                         }
2135                         ++i;
2136                 }
2137                 _bt_common_event_cb(BLUETOOTH_EVENT_MAP_LIST_FOLDERS_COMPLETE,
2138                                 result, &folders_struct,
2139                                 event_info->cb, event_info->user_data);
2140
2141                 __bt_remove_push_request_id(request_id);
2142
2143                 // freeing resources
2144                 while (--i >= 0) {
2145                         free(folders_struct.names[i]);
2146                         folders_struct.names[i] = NULL;
2147                 }
2148                 g_free(folders_struct.names);
2149
2150                 g_variant_unref(folder_list_var);
2151
2152         } else if (strcasecmp(signal_name, BT_MAP_FILTER_FIELDS_COMPLETE) == 0) {
2153                 BT_DBG("BT_MAP_LIST_FOLDERS_COMPLETE");
2154
2155                 GVariant *value;
2156                 int request_id = 0;
2157                 int i = 0;
2158                 bt_map_list_filter_fields_info_t fields_info = {0,};
2159
2160                 g_variant_get(parameters, "(ivi)", &result, &value, &request_id);
2161
2162                 if (__bt_is_request_id_exist(request_id) == FALSE) {
2163                         BT_ERR("Different request id!");
2164                         return;
2165                 }
2166
2167                 if (value) {
2168                         GVariantIter *iter = NULL;
2169                         g_variant_get(value, "(as)", &iter);
2170                         fields_info.size  = g_variant_iter_n_children(iter);
2171                         char* field = NULL;
2172
2173                         fields_info.fields = g_malloc0(fields_info.size * sizeof(char*));
2174                         while (g_variant_iter_loop(iter, "s", &field)) {
2175                                 fields_info.fields[i] = strdup(field);
2176                                 i++;
2177                         }
2178                 }
2179
2180                 _bt_common_event_cb(BLUETOOTH_EVENT_MAP_LIST_FILTER_FIELD_COMPLETE,
2181                                 request_id, &fields_info,
2182                                 event_info->cb, event_info->user_data);
2183
2184                 while (--i >= 0) {
2185                         free(fields_info.fields[i]);
2186                         fields_info.fields[i] = NULL;
2187                 }
2188                 g_free(fields_info.fields);
2189
2190                 __bt_remove_push_request_id(request_id);
2191                 g_variant_unref(value);
2192         } else if (strcasecmp(signal_name, BT_MAP_LIST_MESSAGES_COMPLETE) == 0) {
2193                 int request_id = 0;
2194                 GVariant* messages_list_var = NULL;
2195                 g_variant_get(parameters, "(iiv)", &result, &request_id, &messages_list_var);
2196                 if (__bt_is_request_id_exist(request_id) == FALSE) {
2197                         BT_ERR("Different request id!");
2198                         return;
2199                 }
2200
2201                 bt_map_client_message_items_s messages_struct = {0,};
2202
2203                 GVariantIter* iter;
2204                 g_variant_get(messages_list_var, "(a{oa{sv}})", &iter);
2205                 messages_struct.size = g_variant_iter_n_children(iter);
2206                 messages_struct.message_items = (bt_map_client_message_item_t*)
2207                         g_malloc(messages_struct.size * sizeof(*(messages_struct.message_items)));
2208                 BT_DBG("g_variant_iter_n_children: %d", messages_struct.size);
2209
2210                 char *object = NULL;
2211                 GVariantIter *properites = NULL;
2212                 int i = 0;
2213                 while (g_variant_iter_loop(iter, "{oa{sv}}", &object, &properites)) {
2214                         messages_struct.message_items[i].message_object = strdup(object);
2215                         BT_DBG("Message found: %s", messages_struct.message_items[i].message_object);
2216                         messages_struct.message_items[i].folder = NULL;
2217                         messages_struct.message_items[i].subject = NULL;
2218                         messages_struct.message_items[i].timestamp = NULL;
2219                         messages_struct.message_items[i].sender = NULL;
2220                         messages_struct.message_items[i].sender_address = NULL;
2221                         messages_struct.message_items[i].reply_to = NULL;
2222                         messages_struct.message_items[i].recipient = NULL;
2223                         messages_struct.message_items[i].recipient_address = NULL;
2224                         messages_struct.message_items[i].type = NULL;
2225                         messages_struct.message_items[i].size = -1;
2226                         messages_struct.message_items[i].is_text = -1;
2227                         messages_struct.message_items[i].status = NULL;
2228                         messages_struct.message_items[i].attachment_size = -1;
2229                         messages_struct.message_items[i].is_priority = -1;
2230                         messages_struct.message_items[i].is_read = -1;
2231                         messages_struct.message_items[i].is_sent = -1;
2232                         messages_struct.message_items[i].is_protected = -1;
2233                         char *key = NULL;
2234                         GVariant *value = NULL;
2235                         while (g_variant_iter_loop(properites, "{sv}", &key, &value)) {
2236                                 char *value_string = NULL;
2237                                 uint64_t value_int = -1;
2238                                 bool value_bool = false;
2239                                 if (strcmp(key, "Folder") == 0) {
2240                                         g_variant_get(value, "s", &value_string);
2241                                         messages_struct.message_items[i].folder = strdup(value_string);
2242                                         BT_DBG("  Folder: %s", value_string);
2243                                 } else if (strcmp(key, "Subject") == 0) {
2244                                         g_variant_get(value, "s", &value_string);
2245                                         messages_struct.message_items[i].subject = strdup(value_string);
2246                                         BT_DBG("  Subject: %s", value_string);
2247                                 } else if (strcmp(key, "Timestamp") == 0) {
2248                                         g_variant_get(value, "s", &value_string);
2249                                         messages_struct.message_items[i].timestamp = strdup(value_string);
2250                                         BT_DBG("  Timestamp: %s", value_string);
2251                                 } else if (strcmp(key, "Sender") == 0) {
2252                                         g_variant_get(value, "s", &value_string);
2253                                         messages_struct.message_items[i].sender = strdup(value_string);
2254                                         BT_DBG("  Sender: %s", value_string);
2255                                 } else if (strcmp(key, "SenderAddress") == 0) {
2256                                         g_variant_get(value, "s", &value_string);
2257                                         messages_struct.message_items[i].sender_address = strdup(value_string);
2258                                         BT_DBG("  SenderAddress: %s", value_string);
2259                                 } else if (strcmp(key, "ReplyTo") == 0) {
2260                                         g_variant_get(value, "s", &value_string);
2261                                         messages_struct.message_items[i].reply_to = strdup(value_string);
2262                                         BT_DBG("  ReplyTo: %s", value_string);
2263                                 } else if (strcmp(key, "Recipient") == 0) {
2264                                         g_variant_get(value, "s", &value_string);
2265                                         messages_struct.message_items[i].recipient = strdup(value_string);
2266                                         BT_DBG("  Recipient: %s", value_string);
2267                                 } else if (strcmp(key, "RecipientAddress") == 0) {
2268                                         g_variant_get(value, "s", &value_string);
2269                                         messages_struct.message_items[i].recipient_address = strdup(value_string);
2270                                         BT_DBG("  RecipientAddress: %s", value_string);
2271                                 } else if (strcmp(key, "Type") == 0) {
2272                                         g_variant_get(value, "s", &value_string);
2273                                         messages_struct.message_items[i].type = strdup(value_string);
2274                                         BT_DBG("  Type: %s", value_string);
2275                                 } else if (strcmp(key, "Size") == 0) {
2276                                         g_variant_get(value, "t", &value_int);
2277                                         messages_struct.message_items[i].size = value_int;
2278                                         BT_DBG("  Size: %d", value_int);
2279                                 } else if (strcmp(key, "Text") == 0) {
2280                                         g_variant_get(value, "b", &value_bool);
2281                                         messages_struct.message_items[i].is_text = value_bool ? 1 : 0;
2282                                         BT_DBG("  Text: %s", value_bool ? "true" : "false");
2283                                 } else if (strcmp(key, "Status") == 0) {
2284                                         g_variant_get(value, "s", &value_string);
2285                                         messages_struct.message_items[i].status = strdup(value_string);
2286                                         BT_DBG("  Status: %s", value_string);
2287                                 } else if (strcmp(key, "AttachmentSize") == 0) {
2288                                         g_variant_get(value, "t", &value_int);
2289                                         messages_struct.message_items[i].attachment_size = value_int;
2290                                         BT_DBG("  AttachmentSize: %d", value_int);
2291                                 } else if (strcmp(key, "Priority") == 0) {
2292                                         g_variant_get(value, "b", &value_bool);
2293                                         messages_struct.message_items[i].is_priority = value_bool ? 1 : 0;
2294                                         BT_DBG("  Priority: %s", value_bool ? "true" : "false");
2295                                 } else if (strcmp(key, "Read") == 0) {
2296                                         g_variant_get(value, "b", &value_bool);
2297                                         messages_struct.message_items[i].is_read = value_bool ? 1 : 0;
2298                                         BT_DBG("  Read: %s", value_bool ? "true" : "false");
2299                                 } else if (strcmp(key, "Sent") == 0) {
2300                                         g_variant_get(value, "b", &value_bool);
2301                                         messages_struct.message_items[i].is_sent = value_bool ? 1 : 0;
2302                                         BT_DBG("  Sent: %s", value_bool ? "true" : "false");
2303                                 } else if (strcmp(key, "Protected") == 0) {
2304                                         g_variant_get(value, "b", &value_bool);
2305                                         messages_struct.message_items[i].is_protected = value_bool ? 1 : 0;
2306                                         BT_DBG("  Protected: %s", value_bool ? "true" : "false");
2307                                 }
2308                         }
2309                         ++i;
2310                 }
2311
2312                 _bt_common_event_cb(BLUETOOTH_EVENT_MAP_LIST_MESSAGES_COMPLETE,
2313                                 result, &messages_struct,
2314                                 event_info->cb, event_info->user_data);
2315
2316                 __bt_remove_push_request_id(request_id);
2317
2318                 while (--i >= 0) {
2319                         free(messages_struct.message_items[i].folder);
2320                         free(messages_struct.message_items[i].subject);
2321                         free(messages_struct.message_items[i].timestamp);
2322                         free(messages_struct.message_items[i].sender);
2323                         free(messages_struct.message_items[i].sender_address);
2324                         free(messages_struct.message_items[i].reply_to);
2325                         free(messages_struct.message_items[i].recipient);
2326                         free(messages_struct.message_items[i].recipient_address);
2327                         free(messages_struct.message_items[i].type);
2328                         free(messages_struct.message_items[i].status);
2329                 }
2330                 g_free(messages_struct.message_items);
2331
2332                 g_variant_unref(messages_list_var);
2333         } else if (strcasecmp(signal_name, BT_MAP_GET_MESSAGE_COMPLETE) == 0) {
2334                 BT_DBG("BT_MAP_GET_MESSAGE_COMPLETE");
2335                 int request_id = 0;
2336
2337                 g_variant_get(parameters, "(ii)", &result, &request_id);
2338                 if (__bt_is_request_id_exist(request_id) == FALSE) {
2339                         BT_ERR("Different request id!");
2340                         return;
2341                 }
2342
2343                 // currently there is no result value passed from here, just passing NULL
2344                 void* some_result_value = NULL;
2345                 _bt_common_event_cb(BLUETOOTH_EVENT_MAP_GET_MESSAGE_COMPLETE,
2346                                 result, some_result_value, event_info->cb, event_info->user_data);
2347
2348                 __bt_remove_push_request_id(request_id);
2349         } else if (strcasecmp(signal_name, BT_MAP_PUSH_MESSAGE_COMPLETE) == 0) {
2350                 BT_DBG("BT_MAP_PUSH_MESSAGE_COMPLETE");
2351                 int request_id = 0;
2352
2353                 g_variant_get(parameters, "(ii)", &result, &request_id);
2354                 if (__bt_is_request_id_exist(request_id) == FALSE) {
2355                         BT_ERR("Different request id!");
2356                         return;
2357                 }
2358
2359                 // currently there is no result value passed from here, just passing NULL
2360                 void* some_result_value = NULL;
2361                 _bt_common_event_cb(BLUETOOTH_EVENT_MAP_PUSH_MESSAGE_COMPLETE,
2362                                 result, some_result_value, event_info->cb, event_info->user_data);
2363
2364                 __bt_remove_push_request_id(request_id);
2365         }
2366
2367 }
2368
2369 void __bt_pbap_client_event_filter(GDBusConnection *connection,
2370                                                  const gchar *sender_name,
2371                                                  const gchar *object_path,
2372                                                  const gchar *interface_name,
2373                                                  const gchar *signal_name,
2374                                                  GVariant *parameters,
2375                                                  gpointer user_data)
2376 {
2377         bt_event_info_t *event_info;
2378         int result = BLUETOOTH_ERROR_NONE;
2379         event_info = (bt_event_info_t *)user_data;
2380
2381         ret_if(event_info == NULL);
2382
2383         if (strcasecmp(object_path, BT_PBAP_CLIENT_PATH) != 0)
2384                 return;
2385
2386         if (strcasecmp(interface_name, BT_EVENT_SERVICE) != 0)
2387                 return;
2388
2389         ret_if(signal_name == NULL);
2390
2391         BT_DBG("Type: %s", g_variant_get_type_string(parameters));
2392
2393         if (strcasecmp(signal_name, BT_PBAP_CONNECTED) == 0) {
2394                 bt_pbap_connected_t connected = { { { 0 }, }, };
2395                 char *address = NULL;
2396
2397                 g_variant_get(parameters, "(i&s)", &result, &address);
2398                 BT_DBG("address: %s", address);
2399
2400                 _bt_convert_addr_string_to_type(connected.btaddr.addr,
2401                                                 address);
2402                 if (result == 0)
2403                         connected.connected = 1;
2404                 else
2405                         connected.connected = 0;
2406
2407                 _bt_common_event_cb(BLUETOOTH_PBAP_CONNECTED,
2408                                 result, &connected,
2409                                 event_info->cb, event_info->user_data);
2410         } else if (strcasecmp(signal_name, BT_PBAP_DISCONNECTED) == 0) {
2411                 bt_pbap_connected_t disconnected = { { { 0 }, }, };
2412                 char *address = NULL;
2413
2414                 g_variant_get(parameters, "(i&s)", &result, &address);
2415                 BT_DBG("address: %s", address);
2416
2417                 _bt_convert_addr_string_to_type(disconnected.btaddr.addr,
2418                                                 address);
2419                 disconnected.connected = 0;
2420
2421                 _bt_common_event_cb(BLUETOOTH_PBAP_DISCONNECTED,
2422                                 result, &disconnected,
2423                                 event_info->cb, event_info->user_data);
2424         } else if (strcasecmp(signal_name, BT_PBAP_PHONEBOOK_SIZE) == 0) {
2425                 bt_pbap_phonebook_size_t pb_size = { { { 0 }, }, };
2426                 char *address = NULL;
2427                 int size = 0;
2428
2429                 g_variant_get(parameters, "(i&si)", &result, &address, &size);
2430
2431                 BT_DBG("address: %s, size: %d", address, size);
2432
2433                 _bt_convert_addr_string_to_type(pb_size.btaddr.addr,
2434                                                 address);
2435                 pb_size.size = size;
2436
2437                 _bt_common_event_cb(BLUETOOTH_PBAP_PHONEBOOK_SIZE,
2438                                 result, &pb_size,
2439                                 event_info->cb, event_info->user_data);
2440         } else if (strcasecmp(signal_name, BT_PBAP_PHONEBOOK_PULL) == 0) {
2441                 bt_pbap_phonebook_pull_t pb_pull = { { { 0 } }, };
2442                 char *address = NULL;
2443                 char *vcf_file = NULL;
2444                 int success = -1;
2445
2446                 g_variant_get(parameters, "(i&s&si)", &result, &address, &vcf_file, &success);
2447
2448                 BT_DBG("address: %s, vcf_file: %s, success: %d",
2449                                                 address, vcf_file, success);
2450
2451                 _bt_convert_addr_string_to_type(pb_pull.btaddr.addr,
2452                                                 address);
2453                 pb_pull.vcf_file = vcf_file;
2454                 pb_pull.success = success;
2455                 _bt_common_event_cb(BLUETOOTH_PBAP_PHONEBOOK_PULL,
2456                                 result, &pb_pull,
2457                                 event_info->cb, event_info->user_data);
2458         } else if (strcasecmp(signal_name, BT_PBAP_VCARD_LIST) == 0) {
2459                 bt_pbap_vcard_list_t vc_list = { { { 0 } }, };
2460                 char *address = NULL;
2461                 gsize count = 0;
2462                 gchar **list = NULL;
2463                 GVariant *string_var;
2464                 int success = -1;
2465                 int i = 0;
2466
2467                 g_variant_get(parameters, "(i&sv)", &result, &address, &string_var);
2468
2469                 list = (gchar **)g_variant_get_strv(string_var, &count);
2470
2471                 success = !result;
2472
2473                 for (i = 0; i < count; i++)
2474                         BT_DBG("%s", list[i]);
2475
2476                 BT_DBG("address: %s, result: %d, count: %d, success: %d",
2477                                         address, result, count, success);
2478
2479                 _bt_convert_addr_string_to_type(vc_list.btaddr.addr,
2480                                                 address);
2481                 vc_list.vcards = list;
2482                 vc_list.length = count;
2483                 vc_list.success = success;
2484                 _bt_common_event_cb(BLUETOOTH_PBAP_VCARD_LIST,
2485                                 result, &vc_list,
2486                                 event_info->cb, event_info->user_data);
2487
2488                 g_variant_unref(string_var);
2489                 //free lists
2490         } else if (strcasecmp(signal_name, BT_PBAP_VCARD_PULL) == 0) {
2491                 bt_pbap_vcard_pull_t vc_pull = { { { 0 } }, };
2492                 char *address = NULL;
2493                 char *vcf_file = NULL;
2494                 int success = -1;
2495
2496                 g_variant_get(parameters, "(i&s&si)",
2497                                         &result, &address, &vcf_file, &success);
2498
2499                 BT_DBG("address: %s, vcf_file: %s, success: %d",
2500                                                 address, vcf_file, success);
2501
2502                 _bt_convert_addr_string_to_type(vc_pull.btaddr.addr, address);
2503                 vc_pull.vcf_file = vcf_file;
2504                 vc_pull.success = success;
2505                 _bt_common_event_cb(BLUETOOTH_PBAP_VCARD_PULL,
2506                                 result, &vc_pull,
2507                                 event_info->cb, event_info->user_data);
2508         } else if (strcasecmp(signal_name, BT_PBAP_SEARCH_PHONEBOOK) == 0) {
2509                 bt_pbap_phonebook_search_list_t vc_list = { { { 0 } }, };
2510                 char *address = NULL;
2511                 gsize count = 0;
2512                 gchar **list = NULL;
2513                 GVariant *string_var;
2514                 int success = -1;
2515                 int i = 0;
2516
2517                 g_variant_get(parameters, "(i&s@as)", &result, &address, &string_var);
2518
2519                 list = (gchar **)g_variant_get_strv(string_var, &count);
2520                 success = !result;
2521                 for (i = 0; i < count; i++)
2522                         BT_DBG("%s", list[i]);
2523
2524                 BT_DBG("address: %s success: %d", address, success);
2525
2526                 _bt_convert_addr_string_to_type(vc_list.btaddr.addr, address);
2527                 vc_list.vcards = list;
2528                 vc_list.length = count;
2529                 vc_list.success = success;
2530                 _bt_common_event_cb(BLUETOOTH_PBAP_PHONEBOOK_SEARCH,
2531                                 result, &vc_list,
2532                                 event_info->cb, event_info->user_data);
2533
2534                 g_variant_unref(string_var);
2535                 //free lists
2536         }
2537 }
2538
2539 void __bt_rfcomm_client_event_filter(GDBusConnection *connection,
2540                                                  const gchar *sender_name,
2541                                                  const gchar *object_path,
2542                                                  const gchar *interface_name,
2543                                                  const gchar *signal_name,
2544                                                  GVariant *parameters,
2545                                                  gpointer user_data)
2546 {
2547         bt_event_info_t *event_info;
2548         int result = BLUETOOTH_ERROR_NONE;
2549         event_info = (bt_event_info_t *)user_data;
2550         ret_if(event_info == NULL);
2551
2552         if (strcasecmp(object_path, BT_RFCOMM_CLIENT_PATH) != 0)
2553                 return;
2554         if (strcasecmp(interface_name, BT_EVENT_SERVICE) != 0)
2555                 return;
2556
2557         ret_if(signal_name == NULL);
2558
2559         if (strcasecmp(signal_name, BT_RFCOMM_CONNECTED) == 0) {
2560                 const char *address = NULL;
2561                 const char *uuid = NULL;
2562                 int socket_fd = 0;
2563                 bluetooth_rfcomm_connection_t conn_info;
2564
2565                 g_variant_get(parameters, "(i&s&sn)", &result, &address,
2566                                                         &uuid, &socket_fd);
2567
2568                 memset(&conn_info, 0x00, sizeof(bluetooth_rfcomm_connection_t));
2569                 conn_info.device_role = RFCOMM_ROLE_CLIENT;
2570                 g_strlcpy(conn_info.uuid, uuid, BLUETOOTH_UUID_STRING_MAX);
2571                 conn_info.socket_fd = socket_fd;
2572                 _bt_convert_addr_string_to_type(conn_info.device_addr.addr,
2573                                                 address);
2574
2575                 _bt_common_event_cb(BLUETOOTH_EVENT_RFCOMM_CONNECTED,
2576                                 result, &conn_info,
2577                                 event_info->cb, event_info->user_data);
2578         } else if (strcasecmp(signal_name, BT_RFCOMM_DISCONNECTED) == 0) {
2579                 const char *address = NULL;
2580                 const char *uuid = NULL;
2581                 int socket_fd = 0;
2582                 bluetooth_rfcomm_disconnection_t disconn_info;
2583
2584                 g_variant_get(parameters, "(i&s&sn)", &result, &address,
2585                                                                 &uuid, &socket_fd);
2586
2587                 memset(&disconn_info, 0x00, sizeof(bluetooth_rfcomm_disconnection_t));
2588                 disconn_info.device_role = RFCOMM_ROLE_CLIENT;
2589                 g_strlcpy(disconn_info.uuid, uuid, BLUETOOTH_UUID_STRING_MAX);
2590                 disconn_info.socket_fd = socket_fd;
2591                 _bt_convert_addr_string_to_type(disconn_info.device_addr.addr,
2592                                                 address);
2593
2594                 _bt_common_event_cb(BLUETOOTH_EVENT_RFCOMM_DISCONNECTED,
2595                                 result, &disconn_info,
2596                                 event_info->cb, event_info->user_data);
2597         } else if (strcasecmp(signal_name, BT_RFCOMM_DATA_RECEIVED) == 0) {
2598                 char *buffer;
2599                 int buffer_len = 0;
2600                 int socket_fd = 0;
2601                 bluetooth_rfcomm_received_data_t data_r;
2602                 GVariant *byte_var;
2603
2604                 g_variant_get(parameters, "(in@ay)", &result, &socket_fd,
2605                                                                 &byte_var);
2606
2607                 buffer_len = g_variant_get_size(byte_var);
2608                 buffer = (char *) g_variant_get_data(byte_var);
2609
2610                 data_r.socket_fd = socket_fd;
2611                 data_r.buffer_size = buffer_len;
2612                 data_r.buffer = buffer;
2613
2614                 _bt_common_event_cb(BLUETOOTH_EVENT_RFCOMM_DATA_RECEIVED,
2615                                 result, &data_r,
2616                                 event_info->cb, event_info->user_data);
2617                 g_variant_unref(byte_var);
2618         }
2619 }
2620
2621 void __bt_rfcomm_server_event_filter(GDBusConnection *connection,
2622                                                  const gchar *sender_name,
2623                                                  const gchar *object_path,
2624                                                  const gchar *interface_name,
2625                                                  const gchar *signal_name,
2626                                                  GVariant *parameters,
2627                                                  gpointer user_data)
2628 {
2629         bt_event_info_t *event_info;
2630         int result = BLUETOOTH_ERROR_NONE;
2631         event_info = (bt_event_info_t *)user_data;
2632         ret_if(event_info == NULL);
2633
2634         if (strcasecmp(object_path, BT_RFCOMM_SERVER_PATH) != 0)
2635                 return;
2636         if (strcasecmp(interface_name, BT_EVENT_SERVICE) != 0)
2637                 return;
2638
2639         ret_if(signal_name == NULL);
2640
2641         if (strcasecmp(signal_name, BT_RFCOMM_CONNECTED) == 0) {
2642                 const char *address = NULL;
2643                 const char *uuid = NULL;
2644                 int socket_fd = 0;
2645                 bluetooth_rfcomm_connection_t conn_info;
2646
2647                 g_variant_get(parameters, "(i&s&sn)", &result, &address,
2648                                                         &uuid, &socket_fd);
2649
2650                 memset(&conn_info, 0x00, sizeof(bluetooth_rfcomm_connection_t));
2651                 conn_info.device_role = RFCOMM_ROLE_SERVER;
2652                 g_strlcpy(conn_info.uuid, uuid, BLUETOOTH_UUID_STRING_MAX);
2653                 conn_info.socket_fd = socket_fd;
2654                 _bt_convert_addr_string_to_type(conn_info.device_addr.addr,
2655                                                 address);
2656
2657                 _bt_common_event_cb(BLUETOOTH_EVENT_RFCOMM_CONNECTED,
2658                                 result, &conn_info,
2659                                 event_info->cb, event_info->user_data);
2660         } else if (strcasecmp(signal_name, BT_RFCOMM_DISCONNECTED) == 0) {
2661                 const char *address = NULL;
2662                 const char *uuid = NULL;
2663                 int socket_fd = 0;
2664                 bluetooth_rfcomm_disconnection_t disconn_info;
2665
2666                 g_variant_get(parameters, "(i&s&sn)", &result, &address,
2667                                                                 &uuid, &socket_fd);
2668
2669                 memset(&disconn_info, 0x00, sizeof(bluetooth_rfcomm_disconnection_t));
2670                 disconn_info.device_role = RFCOMM_ROLE_SERVER;
2671                 g_strlcpy(disconn_info.uuid, uuid, BLUETOOTH_UUID_STRING_MAX);
2672                 disconn_info.socket_fd = socket_fd;
2673                 _bt_convert_addr_string_to_type(disconn_info.device_addr.addr,
2674                                                 address);
2675
2676                 _bt_common_event_cb(BLUETOOTH_EVENT_RFCOMM_DISCONNECTED,
2677                                 result, &disconn_info,
2678                                 event_info->cb, event_info->user_data);
2679         } else if (strcasecmp(signal_name, BT_CONNECTION_AUTHORIZED) == 0) {
2680                 /* OSP only event */
2681                 bluetooth_rfcomm_connection_request_t req_ind;
2682                 char *address = NULL;
2683                 char *uuid = NULL;
2684                 int socket_fd = 0;
2685 #ifdef TIZEN_FEATURE_BT_RFCOMM_DIRECT
2686                 char *name = NULL;
2687                 char *path = NULL;
2688
2689                 g_variant_get(parameters, "(i&s&s&s&sn)", &result, &address,
2690                                                 &uuid, &name, &path, &socket_fd);
2691
2692                 if (_check_uuid_path(path, uuid) == FALSE)
2693                         return;
2694 #else
2695                 gboolean auto_accept = FALSE;
2696
2697                 g_variant_get(parameters, "(i&s&s)", &result, &address, &uuid);
2698                 socket_fd = _get_rfcomm_server_id(uuid, &auto_accept);
2699                 if (0 > socket_fd)
2700                         return;
2701
2702                 _bt_rfcomm_server_set_pending_conn(socket_fd, address);
2703                 if (auto_accept) {
2704                         bluetooth_rfcomm_accept_connection(socket_fd);
2705                         return;
2706                 }
2707 #endif
2708                 memset(&req_ind, 0x00, sizeof(bluetooth_rfcomm_connection_request_t));
2709                 _bt_convert_addr_string_to_type(req_ind.device_addr.addr,
2710                                                 address);
2711
2712                 req_ind.socket_fd = socket_fd;
2713
2714                 _bt_common_event_cb(BLUETOOTH_EVENT_RFCOMM_AUTHORIZE,
2715                                 result, &req_ind,
2716                                 event_info->cb, event_info->user_data);
2717         } else if (strcasecmp(signal_name, BT_RFCOMM_SERVER_REMOVED) == 0) {
2718                 /* OSP only event */
2719                 int socket_fd = 0;
2720
2721                 g_variant_get(parameters, "(in)", &result, &socket_fd);
2722
2723                 ret_if(__bt_is_server_exist(socket_fd) == FALSE);
2724
2725                 _bt_remove_server(socket_fd);
2726         } else if (strcasecmp(signal_name, BT_RFCOMM_DATA_RECEIVED) == 0) {
2727                 char *buffer = NULL;
2728                 int buffer_len = 0;
2729                 int socket_fd = 0;
2730                 bluetooth_rfcomm_received_data_t data_r;
2731                 GVariant *byte_var;
2732
2733                 g_variant_get(parameters, "(in@ay)", &result,
2734                                                 &socket_fd, &byte_var);
2735
2736                 buffer_len = g_variant_get_size(byte_var);
2737                 buffer = (char *) g_variant_get_data(byte_var);
2738
2739                 data_r.socket_fd = socket_fd;
2740                 data_r.buffer_size = buffer_len;
2741                 data_r.buffer = buffer;
2742
2743                 _bt_common_event_cb(BLUETOOTH_EVENT_RFCOMM_DATA_RECEIVED,
2744                                 result, &data_r,
2745                                 event_info->cb, event_info->user_data);
2746                 g_variant_unref(byte_var);
2747         }
2748 }
2749
2750 void __bt_hf_agent_event_filter(GDBusConnection *connection,
2751                                                  const gchar *sender_name,
2752                                                  const gchar *object_path,
2753                                                  const gchar *interface_name,
2754                                                  const gchar *signal_name,
2755                                                  GVariant *parameters,
2756                                                  gpointer user_data)
2757 {
2758         BT_DBG("+\n");
2759
2760         bt_event_info_t *event_info;
2761         int result = BLUETOOTH_ERROR_NONE;
2762         event_info = (bt_event_info_t *)user_data;
2763         ret_if(event_info == NULL);
2764
2765         BT_DBG("+\n");
2766         if (strcasecmp(object_path, BT_HF_AGENT_PATH) != 0)
2767                 return;
2768         if (strcasecmp(interface_name, BT_HF_SERVICE_INTERFACE) != 0)
2769                 return;
2770
2771         ret_if(signal_name == NULL);
2772
2773         BT_DBG("%s", signal_name);
2774         if (strcasecmp(signal_name, "Connected") == 0) {
2775                 char *address = NULL;
2776
2777                 g_variant_get(parameters, "(&s)", &address);
2778                 _bt_hf_event_cb(BLUETOOTH_EVENT_HF_CONNECTED,
2779                                 result, address,
2780                                 event_info->cb, event_info->user_data);
2781         } else if (strcasecmp(signal_name, "Disconnected") == 0) {
2782                 char *address = NULL;
2783
2784                 g_variant_get(parameters, "(&s)", &address);
2785                 _bt_hf_event_cb(BLUETOOTH_EVENT_HF_DISCONNECTED,
2786                                 result, address,
2787                                 event_info->cb, event_info->user_data);
2788         } else if (strcasecmp(signal_name, "AudioConnected") == 0) {
2789                 _bt_hf_event_cb(BLUETOOTH_EVENT_HF_AUDIO_CONNECTED,
2790                                 result, NULL,
2791                                 event_info->cb, event_info->user_data);
2792         } else if (strcasecmp(signal_name, "AudioDisconnected") == 0) {
2793                 _bt_hf_event_cb(BLUETOOTH_EVENT_HF_AUDIO_DISCONNECTED,
2794                                 result, NULL,
2795                                 event_info->cb, event_info->user_data);
2796         } else if (strcasecmp(signal_name, "Ring") == 0) {
2797                 char *phoneno = NULL;
2798
2799                 g_variant_get(parameters, "(&s)", &phoneno);
2800
2801                 _bt_hf_event_cb(BLUETOOTH_EVENT_HF_RING_INDICATOR,
2802                                 result, phoneno,
2803                                 event_info->cb, event_info->user_data);
2804         } else if (strcasecmp(signal_name, "CallWaiting") == 0) {
2805                 char *phoneno = NULL;
2806
2807                 g_variant_get(parameters, "(&s)", &phoneno);
2808
2809                 _bt_hf_event_cb(BLUETOOTH_EVENT_HF_CALL_WAITING,
2810                                 result, phoneno,
2811                                 event_info->cb, event_info->user_data);
2812         }  else if (strcasecmp(signal_name, "CallTerminated") == 0) {
2813                 _bt_hf_event_cb(BLUETOOTH_EVENT_HF_CALL_TERMINATED,
2814                                 result, NULL,
2815                                 event_info->cb, event_info->user_data);
2816         }  else if (strcasecmp(signal_name, "FailedToDial") == 0) {
2817                 _bt_hf_event_cb(BLUETOOTH_EVENT_HF_CALL_FAILED_TO_DIAL,
2818                                 result, NULL,
2819                                 event_info->cb, event_info->user_data);
2820         } else if (strcasecmp(signal_name, "CallIdle") == 0) {
2821                 _bt_hf_event_cb(BLUETOOTH_EVENT_HF_CALL_IDLE,
2822                                 result, NULL,
2823                                 event_info->cb, event_info->user_data);
2824         } else if (strcasecmp(signal_name, "CallSetupIncoming") == 0) {
2825                 _bt_hf_event_cb(BLUETOOTH_EVENT_HF_CALLSETUP_INCOMING,
2826                                 result, NULL,
2827                                 event_info->cb, event_info->user_data);
2828         } else if (strcasecmp(signal_name, "CallSetupDialing") == 0) {
2829                 _bt_hf_event_cb(BLUETOOTH_EVENT_HF_CALLSETUP_DIALING,
2830                                 result, NULL,
2831                                 event_info->cb, event_info->user_data);
2832         } else if (strcasecmp(signal_name, "CallSetupAlerting") == 0) {
2833                 _bt_hf_event_cb(BLUETOOTH_EVENT_HF_CALLSETUP_ALERTING,
2834                                 result, NULL,
2835                                 event_info->cb, event_info->user_data);
2836         } else if (strcasecmp(signal_name, "CallStarted") == 0) {
2837                 _bt_hf_event_cb(BLUETOOTH_EVENT_HF_CALL_STARTED,
2838                                 result, NULL,
2839                                 event_info->cb, event_info->user_data);
2840         } else if (strcasecmp(signal_name, "CallEnded") == 0) {
2841                 _bt_hf_event_cb(BLUETOOTH_EVENT_HF_CALL_ENDED,
2842                                 result, NULL,
2843                                 event_info->cb, event_info->user_data);
2844         }  else if (strcasecmp(signal_name, "NoCallsHeld") == 0) {
2845                 _bt_hf_event_cb(BLUETOOTH_EVENT_HF_CALL_UNHOLD,
2846                                 result, NULL,
2847                                 event_info->cb, event_info->user_data);
2848         } else if (strcasecmp(signal_name, "CallsSwapped") == 0) {
2849                 _bt_hf_event_cb(BLUETOOTH_EVENT_HF_CALL_SWAPPED,
2850                                 result, NULL,
2851                                 event_info->cb, event_info->user_data);
2852         } else if (strcasecmp(signal_name, "CallOnHold") == 0) {
2853                 _bt_hf_event_cb(BLUETOOTH_EVENT_HF_CALL_ON_HOLD,
2854                                 result, NULL,
2855                                 event_info->cb, event_info->user_data);
2856         } else if (strcasecmp(signal_name, "CallStatusUpdate") == 0) {
2857                 int call_count;
2858                 GVariant *var_data = NULL;
2859                 char *number = NULL;
2860                 int idx, dir, status, mpart;
2861                 bt_hf_call_list_s *handle = NULL;
2862
2863                 g_variant_get(parameters, "(i@a(siiii))", &call_count,
2864                                                                 &var_data);
2865                 BT_DBG("call count : %d", call_count);
2866
2867                 if (var_data) {
2868                         GVariantIter *iter = NULL;
2869                         __bt_call_list_create(&handle);
2870
2871                         g_variant_get(var_data, "a(siiii)", &iter);
2872                         while (g_variant_iter_loop(iter, "(siiii)", &number,
2873                                                 &dir, &status, &mpart, &idx)) {
2874                                 BT_DBG("call number:%s, dir:%d, status : %d",
2875                                                         number, dir, status);
2876                                 BT_DBG("call mpart : %d, idx : %d", mpart, idx);
2877                                 __bt_call_list_add(handle, number, dir,
2878                                                         status, mpart, idx);
2879                         }
2880                         g_variant_iter_free(iter);
2881                         g_variant_unref(var_data);
2882                 }
2883
2884                 if (handle && (call_count == g_list_length(handle->list))) {
2885                         handle->count = call_count;
2886                         _bt_hf_event_cb(BLUETOOTH_EVENT_HF_CALL_STATUS,
2887                                         result, handle,
2888                                         event_info->cb, event_info->user_data);
2889                 } else {
2890                         BT_ERR(" Mismatch in call count : %d", call_count);
2891                 }
2892
2893                 __bt_call_list_destroy(handle);
2894         } else if (strcasecmp(signal_name, "VoiceRecognition") == 0) {
2895                 int status;
2896                 g_variant_get(parameters, "(i)", &status);
2897                 BT_DBG("status = [%d]\n", status);
2898                 if (status)
2899                         _bt_hf_event_cb(BLUETOOTH_EVENT_HF_VOICE_RECOGNITION_ENABLED,
2900                                         result, NULL,
2901                                         event_info->cb, event_info->user_data);
2902                 else
2903                         _bt_hf_event_cb(BLUETOOTH_EVENT_HF_VOICE_RECOGNITION_DISABLED,
2904                                         result, NULL,
2905                                         event_info->cb, event_info->user_data);
2906         } else if (strcasecmp(signal_name, "VolumeSpeaker") == 0) {
2907                 int value;
2908                 g_variant_get(parameters, "(i)", &value);
2909                 BT_DBG("Value = [%d]\n", value);
2910                         _bt_hf_event_cb(BLUETOOTH_EVENT_HF_VOLUME_SPEAKER,
2911                                         result, &value,
2912                                         event_info->cb, event_info->user_data);
2913         } else if (strcasecmp(signal_name, "SamsungXSAT") == 0) {
2914                 int value = 0;
2915                 char *msg = NULL;
2916                 bluetooth_vendor_dep_at_cmd_t cmd;
2917                 g_variant_get(parameters, "(i&s)", &value, &msg);
2918                 BT_DBG("Value = [%d], message = %s\n", value, msg);
2919                 cmd.app_id =  value;
2920                 cmd.message = msg;
2921                 _bt_hf_event_cb(BLUETOOTH_EVENT_HF_VENDOR_DEP_CMD,
2922                                 result, &cmd,
2923                                 event_info->cb, event_info->user_data);
2924         } else if (strcasecmp(signal_name, "PropertyChanged") == 0) {
2925                 GVariant *value;
2926                 gchar *property;
2927                 bluetooth_hf_ciev_device_event_t dev_event;
2928
2929                 g_variant_get(parameters, "(&sv)", &property, &value);
2930                 dev_event.value  = g_variant_get_uint16(value);
2931
2932                 BT_DBG("Property: %s , value: %d", property, dev_event.value);
2933                 g_variant_unref(value);
2934
2935                 if (strcasecmp(property, "BatteryCharge") == 0) {
2936                         dev_event.event = BLUETOOTH_HF_CIEV_BATTCHG;
2937                         _bt_hf_event_cb(BLUETOOTH_EVENT_HF_CIEV_DEVICE_STATUS_CHANGED,
2938                                         result, &dev_event,
2939                                         event_info->cb, event_info->user_data);
2940                 } else if (strcasecmp(property, "SignalStrength") == 0) {
2941                         dev_event.event = BLUETOOTH_HF_CIEV_SIGNAL;
2942                         _bt_hf_event_cb(BLUETOOTH_EVENT_HF_CIEV_DEVICE_STATUS_CHANGED,
2943                                         result, &dev_event,
2944                                         event_info->cb, event_info->user_data);
2945                 } else if (strcasecmp(property, "RegistrationStatus") == 0) {
2946                         dev_event.event = BLUETOOTH_HF_CIEV_SERVICE;
2947                         _bt_hf_event_cb(BLUETOOTH_EVENT_HF_CIEV_DEVICE_STATUS_CHANGED,
2948                                         result, &dev_event,
2949                                         event_info->cb, event_info->user_data);
2950                 }
2951         }
2952         BT_DBG("-\n");
2953 }
2954
2955 static void __bt_tds_event_filter(GDBusConnection *connection,
2956                 const gchar *sender_name,
2957                 const gchar *object_path,
2958                 const gchar *interface_name,
2959                 const gchar *signal_name,
2960                 GVariant *parameters,
2961                 gpointer user_data)
2962 {
2963         bt_event_info_t *event_info;
2964         event_info = (bt_event_info_t *)user_data;
2965         int result = BLUETOOTH_ERROR_NONE;
2966
2967         ret_if(event_info == NULL);
2968
2969         if (strcasecmp(object_path, BT_TDS_PATH) != 0)
2970                 return;
2971         if (strcasecmp(interface_name, BT_EVENT_SERVICE) != 0)
2972                 return;
2973
2974         ret_if(signal_name == NULL);
2975
2976         BT_DBG("+");
2977
2978         if (strcasecmp(signal_name, BT_TDS_ACTIVATION_REQUESTED) == 0) {
2979                 bluetooth_tds_activation_req_t act_req;
2980                 const char *address = NULL;
2981                 char *buffer = NULL;
2982                 int transport = 0;
2983                 GVariant *byte_var;
2984
2985                 g_variant_get(parameters, "(&si@ay)", &address,
2986                                 &transport, &byte_var);
2987
2988                 memset(&act_req, 0x00, sizeof(bluetooth_tds_activation_req_t));
2989
2990                 act_req.transport = transport;
2991
2992                 act_req.tds_data.length = g_variant_get_size(byte_var);
2993                 if (act_req.tds_data.length > BLUETOOTH_TDS_DATA_LENGTH_MAX) {
2994                         BT_INFO("tds data length > BLUETOOTH_TDS_DATA_LENGTH_MAX");
2995                         act_req.tds_data.length = BLUETOOTH_TDS_DATA_LENGTH_MAX;
2996                 }
2997                 buffer = (char *) g_variant_get_data(byte_var);
2998                 memcpy(act_req.tds_data.data, buffer, act_req.tds_data.length);
2999                 g_variant_unref(byte_var);
3000
3001                 _bt_convert_addr_string_to_type(act_req.rem_addr.addr, address);
3002
3003                 _bt_common_event_cb(BLUETOOTH_EVENT_TDS_ACTIVATION_REQUESTED,
3004                                 BLUETOOTH_ERROR_NONE, &act_req,
3005                                 event_info->cb, event_info->user_data);
3006         } else if (strcasecmp(signal_name, BT_TDS_TRANSPORT_DATA_RECEIVED) == 0) {
3007                 BT_DBG("TDS Complete Block Data received");
3008                 const char *address = NULL;
3009                 char *data;
3010                 int data_len = 0;
3011                 int k;
3012                 GVariant *var = NULL;
3013                 bluetooth_tds_transport_data_info_t *info = NULL;
3014
3015                 /* Extract data from DBUS params */
3016                 g_variant_get(parameters, "(i&sn@ay)", &result, &address, &data_len, &var);
3017                 data = (char *)g_variant_get_data(var);
3018
3019                 if (data) {
3020                         BT_DBG("Address [%s]", address);
3021                         BT_DBG("Data len [%d]", data_len);
3022
3023                         /* DEBUG */
3024                         for (k = 0; k < data_len ; k++)
3025                                 BT_DBG("Data[%d] [0x%x]", k, data[k]);
3026
3027                         if (data_len == 0) {
3028                                 BT_ERR("No data");
3029                                 g_variant_unref(var);
3030                                 return;
3031                         }
3032
3033                         info = g_malloc0(sizeof(bluetooth_tds_transport_data_info_t));
3034                         info->data_length = data_len;
3035                         info->data = g_memdup(data, data_len);
3036
3037                         _bt_convert_addr_string_to_type(info->device_address.addr,
3038                                         address);
3039
3040                         _bt_common_event_cb(BLUETOOTH_EVENT_TDS_TRANSPORT_DATA_RECEIVED,
3041                                         result, info,
3042                                         event_info->cb, event_info->user_data);
3043
3044                         if (info->data) {
3045                                 g_free(info->data);
3046                                 g_free(info);
3047                         }
3048                 }
3049                 g_variant_unref(var);
3050         } else if (strcasecmp(signal_name, BT_TDS_ACTIVATION_RESULT) == 0) {
3051                 BT_DBG("TDS Control point Activation result");
3052                 const char *address = NULL;
3053                 bluetooth_device_address_t dev_address = { {0} };
3054
3055                 /* Extract data from DBUS params */
3056                 g_variant_get(parameters, "(i&s)", &result, &address);
3057                 BT_DBG("Address [%s]", address);
3058                 BT_DBG("Result  [%d]", result);
3059
3060                 _bt_convert_addr_string_to_type(dev_address.addr,
3061                                 address);
3062
3063                 _bt_common_event_cb(BLUETOOTH_EVENT_TDS_ACTIVATION_RESULT,
3064                                 result, &dev_address,
3065                                 event_info->cb, event_info->user_data);
3066         } else if (strcasecmp(signal_name, BT_TDS_ACTIVATION_INDICATION) == 0) {
3067                 BT_DBG("TDS Control point Indication Response");
3068                 bluetooth_tds_indication_res_t ind_res;
3069                 const char *address = NULL;
3070                 char *buffer = NULL;
3071                 GVariant *byte_var = NULL;
3072
3073                 g_variant_get(parameters, "(&s@ay)", &address, &byte_var);
3074
3075                 memset(&ind_res, 0x00, sizeof(bluetooth_tds_indication_res_t));
3076
3077                 ind_res.tds_data.length = g_variant_get_size(byte_var);
3078
3079                 buffer = (char *) g_variant_get_data(byte_var);
3080                 BT_DBG("[len = %d]", ind_res.tds_data.length);
3081                 memcpy(ind_res.tds_data.data, buffer, ind_res.tds_data.length);
3082
3083                 _bt_convert_addr_string_to_type(ind_res.rem_addr.addr, address);
3084
3085                 _bt_common_event_cb(BLUETOOTH_EVENT_TDS_ACTIVATION_INDICATION,
3086                                 BLUETOOTH_ERROR_NONE,  &ind_res,
3087                                 event_info->cb, event_info->user_data);
3088
3089                 g_variant_unref(byte_var);
3090         } else if (strcasecmp(signal_name, BT_TDS_CONTROL_POINT_ENABLED) == 0) {
3091                 BT_DBG("TDS Control point Enabled event");
3092                 const char *address = NULL;
3093                 bluetooth_device_address_t dev_address = { {0} };
3094
3095                 /* Extract data from DBUS params */
3096                 g_variant_get(parameters, "(i&s)", &result, &address);
3097                 BT_DBG("Address [%s]", address);
3098                 BT_DBG("Result  [%d]", result);
3099
3100                 _bt_convert_addr_string_to_type(dev_address.addr,
3101                                 address);
3102
3103                 _bt_common_event_cb(BLUETOOTH_EVENT_TDS_CONTROL_POINT_ENABLED,
3104                                 result, &dev_address,
3105                                 event_info->cb, event_info->user_data);
3106         }
3107
3108         BT_DBG("-");
3109 }
3110
3111 static void __bt_otp_event_filter(GDBusConnection *connection,
3112                 const gchar *sender_name,
3113                 const gchar *object_path,
3114                 const gchar *interface_name,
3115                 const gchar *signal_name,
3116                 GVariant *parameters,
3117                 gpointer user_data)
3118 {
3119         bt_event_info_t *event_info;
3120         event_info = (bt_event_info_t *)user_data;
3121         int result = BLUETOOTH_ERROR_NONE;
3122
3123         ret_if(event_info == NULL);
3124
3125         if (strcasecmp(object_path, BT_OTP_PATH) != 0)
3126                 return;
3127         if (strcasecmp(interface_name, BT_EVENT_SERVICE) != 0)
3128                 return;
3129
3130         ret_if(signal_name == NULL);
3131
3132         BT_DBG("+");
3133
3134         if (strcasecmp(signal_name, BT_OTP_SERVER_STATE_CHANGED) == 0) {
3135                 BT_DBG("OTP Server State Changed Event");
3136                 bool status = FALSE;
3137
3138                 /* Extract data from DBUS params */
3139                 g_variant_get(parameters, "(ib)", &result, &status);
3140                 BT_DBG("Result [%d]", result);
3141                 BT_DBG("Status  [%s]", status ? "enabled" : "disabled");
3142
3143                 _bt_common_event_cb(BLUETOOTH_EVENT_OTP_SERVER_STATE_CHANGED,
3144                                 result, &status, event_info->cb, event_info->user_data);
3145         } else if (strcasecmp(signal_name, BT_OTP_READ_CHAR_VAL) == 0) {
3146                 BT_DBG("OTP Read Data received");
3147                 const char *handle = NULL;
3148                 char *data;
3149                 int data_len = 0;
3150                 GVariant *var = NULL;
3151                 bluetooth_otp_resp_info_t *info = NULL;
3152
3153                 /* Extract data from DBUS params */
3154                 g_variant_get(parameters, "(i&sn@ay)", &result, &handle, &data_len, &var);
3155                 if (!var) {
3156                         BT_ERR("No data");
3157                         return;
3158                 }
3159                 data = (char *)g_variant_get_data(var);
3160
3161                 BT_DBG("Handle [%s]", handle);
3162                 BT_DBG("Data len [%d]", data_len);
3163
3164                 if (data_len == 0) {
3165                         BT_ERR("No data");
3166                         if (var)
3167                                 g_variant_unref(var);
3168                         return;
3169                 }
3170
3171                 info = g_malloc0(sizeof(bluetooth_otp_resp_info_t));
3172                 info->data_length = data_len;
3173                 info->data = g_memdup(data, data_len);
3174                 info->handle = g_strdup(handle);
3175
3176                 _bt_common_event_cb(BLUETOOTH_EVENT_OTP_READ_CHAR_VAL,
3177                                 result, info,
3178                                 event_info->cb, event_info->user_data);
3179
3180                 if (info->handle)
3181                         g_free(info->handle);
3182
3183                 if (info->data) {
3184                         g_free(info->data);
3185                         g_free(info);
3186                 }
3187                 g_variant_unref(var);
3188         } else if (strcasecmp(signal_name, BT_OTP_NOTIFICATION_ENABLED) == 0) {
3189                 BT_DBG("OTP Notification Enabled event");
3190                 char *handle = NULL;
3191
3192                 /* Extract data from DBUS params */
3193                 g_variant_get(parameters, "(i&s)", &result, &handle);
3194                 BT_DBG("Handle [%s]", handle);
3195                 BT_DBG("Result  [%d]", result);
3196
3197                 _bt_common_event_cb(BLUETOOTH_EVENT_OTP_NOTIFICATION_ENABLED,
3198                                 result, handle,
3199                                 event_info->cb, event_info->user_data);
3200         } else if (strcasecmp(signal_name, BT_OTP_WRITE_CHAR_VAL) == 0) {
3201                 BT_DBG("OTP Control point Activation result");
3202                 char *handle = NULL;
3203
3204                 /* Extract data from DBUS params */
3205                 g_variant_get(parameters, "(i&s)", &result, &handle);
3206                 BT_DBG("Handle [%s]", handle);
3207                 BT_DBG("Result  [%d]", result);
3208
3209                 _bt_common_event_cb(BLUETOOTH_EVENT_OTP_WRITE_CHAR_VAL,
3210                                 result, handle,
3211                                 event_info->cb, event_info->user_data);
3212         } else if (strcasecmp(signal_name, BT_OTP_INDICATION) == 0) {
3213                 BT_DBG("OTP Control point Indication Response");
3214                 bluetooth_otp_resp_info_t *ind_res = NULL;
3215                 char *buffer = NULL;
3216                 GVariant *byte_var = NULL;
3217                 char *handle = NULL;
3218
3219                 g_variant_get(parameters, "(i&s@ay)", &result, &handle, &byte_var);
3220                 if (!byte_var) {
3221                         BT_ERR("No Indication data from Server");
3222                         return;
3223                 }
3224
3225                 ind_res = g_malloc0(sizeof(bluetooth_otp_resp_info_t));
3226                 ind_res->data_length = g_variant_get_size(byte_var);
3227                 buffer = (char *)g_variant_get_data(byte_var);
3228                 ind_res->data = g_memdup(buffer, ind_res->data_length);
3229                 ind_res->handle = g_strdup(handle);
3230
3231                 _bt_common_event_cb(BLUETOOTH_EVENT_OTP_INDICATION,
3232                                 result,  ind_res,
3233                                 event_info->cb, event_info->user_data);
3234
3235                 if (ind_res->handle)
3236                         g_free(ind_res->handle);
3237
3238                 if (ind_res->data) {
3239                         g_free(ind_res->data);
3240                         g_free(ind_res);
3241                 }
3242                 g_variant_unref(byte_var);
3243         }  else if (strcasecmp(signal_name, BT_OTC_STATE_CHANGED) == 0) {
3244                 BT_DBG("OTC State Changed");
3245                 char *address = NULL;
3246                 int fd = -1;
3247                 gboolean connected = FALSE;
3248                 bluetooth_otc_info_t *otc_info = NULL;
3249
3250                 /* Extract data from DBUS params */
3251                 g_variant_get(parameters, "(ib&sn)", &result, &connected, &address, &fd);
3252                 BT_DBG("Result  [%d]", result);
3253                 BT_DBG("Address [%s]", address);
3254                 BT_DBG("Connected [%d]", connected);
3255                 BT_DBG("Fd  [%d]", fd);
3256
3257                 otc_info = g_malloc0(sizeof(bluetooth_otc_info_t));
3258                 otc_info->fd = fd;
3259                 otc_info->connected = connected;
3260                 otc_info->address = g_strdup(address);
3261
3262                 _bt_common_event_cb(BLUETOOTH_EVENT_OTC_STATE_CHANGED,
3263                                 result, otc_info,
3264                                 event_info->cb, event_info->user_data);
3265         }
3266
3267         BT_DBG("-");
3268 }
3269
3270 void __bt_hdp_event_filter(GDBusConnection *connection,
3271                                                  const gchar *sender_name,
3272                                                  const gchar *object_path,
3273                                                  const gchar *interface_name,
3274                                                  const gchar *signal_name,
3275                                                  GVariant *parameters,
3276                                                  gpointer user_data)
3277 {
3278         bt_event_info_t *event_info;
3279         int result = BLUETOOTH_ERROR_NONE;
3280
3281         BT_DBG("+");
3282         event_info = (bt_event_info_t *)user_data;
3283         ret_if(event_info == NULL);
3284
3285         if (strcasecmp(object_path, BT_HDP_DEVICE_PATH) != 0)
3286                 return;
3287         if (strcasecmp(interface_name, BT_EVENT_SERVICE) != 0)
3288                 return;
3289
3290         ret_if(signal_name == NULL);
3291
3292         if (strcasecmp(signal_name, BT_HDP_CONNECTED) == 0) {
3293                 const char *address = NULL;
3294                 char *app_handle = NULL;
3295                 bt_hdp_connected_t conn_info;
3296
3297                 g_variant_get(parameters, "(i&s&sui)", &result,
3298                                 &address, &app_handle,
3299                                 &(conn_info.channel_id), &(conn_info.type));
3300
3301                 conn_info.app_handle = app_handle;
3302
3303                 BT_DBG("address: %s, app_handle: %s, ch_id: %d, ch_type: %d",
3304                         address, conn_info.app_handle, conn_info.channel_id, conn_info.type);
3305                 _bt_convert_addr_string_to_type(conn_info.device_address.addr, address);
3306
3307                 if (BLUETOOTH_ERROR_NONE == result)
3308                         result = _bt_hdp_app_acquire_fd(&conn_info);
3309
3310                 _bt_common_event_cb(BLUETOOTH_EVENT_HDP_CONNECTED,
3311                                 result, &conn_info,
3312                                 event_info->cb, event_info->user_data);
3313         } else if (strcasecmp(signal_name, BT_HDP_DISCONNECTED) == 0) {
3314                 const char *address = NULL;
3315                 bt_hdp_disconnected_t disconn_info;
3316
3317                 g_variant_get(parameters, "(i&su)", &result,
3318                                 &address, &(disconn_info.channel_id));
3319
3320                 BT_DBG("address: %s", address);
3321                 _bt_convert_addr_string_to_type(disconn_info.device_address.addr, address);
3322
3323                 _bt_hdp_app_remove_obj_info(disconn_info.channel_id);
3324                 _bt_common_event_cb(BLUETOOTH_EVENT_HDP_DISCONNECTED,
3325                                 result, &disconn_info,
3326                                 event_info->cb, event_info->user_data);
3327         }
3328
3329         BT_DBG("-");
3330 }
3331
3332 static void __bt_remove_all_events(void)
3333 {
3334         bt_event_info_t *info;
3335
3336         while ((info = g_slist_nth_data(event_list, 0)) != NULL)
3337                 _bt_unregister_event(info->event_type);
3338
3339         if (event_list) {
3340                 g_slist_free(event_list);
3341                 event_list = NULL;
3342         }
3343 }
3344
3345 static gboolean __bt_event_is_registered(int event_type)
3346 {
3347         GSList *l;
3348         bt_event_info_t *info;
3349
3350         for (l = event_list; l != NULL; l = g_slist_next(l)) {
3351                 info = l->data;
3352                 if (info == NULL)
3353                         continue;
3354
3355                 if (info->event_type == event_type)
3356                         return TRUE;
3357         }
3358
3359         return FALSE;
3360 }
3361
3362 bt_event_info_t *_bt_event_get_cb_data(int event_type)
3363 {
3364         GSList *l;
3365         bt_event_info_t *info;
3366
3367         for (l = event_list; l != NULL; l = g_slist_next(l)) {
3368                 info = l->data;
3369                 if (info == NULL)
3370                         continue;
3371
3372                 if (info->event_type == event_type)
3373                         return info;
3374         }
3375
3376         return NULL;
3377 }
3378
3379 void _bt_add_server(int server_fd)
3380 {
3381         bt_server_info_t *info;
3382
3383         info = g_new0(bt_server_info_t, 1);
3384         info->server_fd = server_fd;
3385
3386         server_list = g_slist_append(server_list, info);
3387 }
3388
3389 void _bt_remove_server(int server_fd)
3390 {
3391         GSList *l;
3392         bt_server_info_t *info;
3393
3394         for (l = server_list; l != NULL; l = g_slist_next(l)) {
3395                 info = l->data;
3396                 if (info == NULL)
3397                         continue;
3398
3399                 if (info->server_fd == server_fd)
3400                         server_list = g_slist_remove(server_list, (void *)info);
3401
3402                 g_free(info);
3403         }
3404 }
3405
3406 void _bt_set_obex_server_id(int server_type)
3407 {
3408         obex_server_id = server_type;
3409 }
3410
3411 int _bt_get_obex_server_id(void)
3412 {
3413         return obex_server_id;
3414 }
3415
3416 int _bt_init_event_handler(void)
3417 {
3418         if (is_initialized == TRUE) {
3419                 BT_ERR("Connection already exist");
3420                 return BLUETOOTH_ERROR_ALREADY_INITIALIZED;
3421         }
3422
3423         __bt_remove_all_events();
3424
3425         is_initialized = TRUE;
3426
3427         return BLUETOOTH_ERROR_NONE;
3428 }
3429
3430 int _bt_deinit_event_handler(void)
3431 {
3432         if (is_initialized == FALSE) {
3433                 BT_ERR("Connection dose not exist");
3434                 return BLUETOOTH_ERROR_INTERNAL;
3435         }
3436
3437         __bt_remove_all_events();
3438
3439         if (disable_timer_id > 0) {
3440                 g_source_remove(disable_timer_id);
3441                 disable_timer_id = 0;
3442         }
3443
3444         is_initialized = FALSE;
3445
3446         return BLUETOOTH_ERROR_NONE;
3447 }
3448
3449 static void __bt_event_data_free(void *data)
3450 {
3451         bt_event_info_t *cb_data = data;
3452
3453         ret_if(cb_data == NULL);
3454
3455         g_free(cb_data);
3456 }
3457
3458 #ifdef TIZEN_GATT_CLIENT
3459 static void __bt_gatt_client_event_filter(GDBusConnection *connection,
3460                 const gchar *sender_name,
3461                 const gchar *object_path,
3462                 const gchar *interface_name,
3463                 const gchar *signal_name,
3464                 GVariant *parameters,
3465                 gpointer user_data)
3466 {
3467         BT_DBG("GATT Client event handler Entry >>");
3468
3469         bt_event_info_t *event_info;
3470         int result = BLUETOOTH_ERROR_NONE;
3471
3472         event_info = (bt_event_info_t *)user_data;
3473         ret_if(event_info == NULL);
3474
3475         if (strcasecmp(signal_name, BT_GATT_CHAR_VAL_CHANGED) == 0) { /* Done */
3476                 /* Event: BLUETOOTH_EVENT_GATT_CHAR_VAL_CHANGED */
3477                 BT_INFO("GATT Client event[BT_GATT_CHAR_VAL_CHANGED]");
3478                 bt_gatt_char_property_t char_prop;
3479                 const char *address = NULL;
3480                 GVariant *data_var = NULL;
3481                 GVariant *svc_uuid_var = NULL;
3482                 int svc_inst;
3483                 GVariant *char_uuid_var = NULL;
3484                 int svc_uuid_len = 0;
3485                 int char_uuid_len = 0;
3486                 unsigned int i;
3487
3488                 memset(&char_prop, 0x00, sizeof(bt_gatt_char_property_t));
3489
3490                 /* Extract data from DBUS params */
3491                 g_variant_get(parameters, "(i&sn@ayin@ayin@ay)",
3492                                 &result,
3493                                 &address,
3494                                 &svc_uuid_len,
3495                                 &svc_uuid_var,
3496                                 &svc_inst,
3497                                 &char_uuid_len,
3498                                 &char_uuid_var,
3499                                 &char_prop.prop.instance_id,
3500                                 &char_prop.val_len,
3501                                 &data_var);
3502                 g_strlcpy(char_prop.address, address, BT_ADDRESS_STRING_SIZE);
3503
3504                 BT_INFO("GATT Client Char value changed in remote Server [%s]", address);
3505                 BT_INFO("GATT Client Char Val len: [%d]", char_prop.val_len);
3506
3507                 /* Copy Data */
3508                 memcpy(&char_prop.value, g_variant_get_data(data_var), char_prop.val_len);
3509                 memcpy(&char_prop.prop.uuid, g_variant_get_data(char_uuid_var), 16);
3510
3511                 /* DEBUG */
3512                 for (i = 0; i < char_prop.val_len; i++)
3513                         BT_INFO("Data[%d] = [0x%x]", i, char_prop.value[i]);
3514
3515                 _bt_gatt_client_event_cb(BLUETOOTH_EVENT_GATT_CHAR_VAL_CHANGED,
3516                                 result, &char_prop,
3517                                 event_info->cb, event_info->user_data);
3518         } else if (strcasecmp(signal_name, BT_GATT_CLIENT_READ_CHAR) == 0) { /* Done */
3519                 /* Event: BLUETOOTH_EVENT_GATT_READ_CHAR */
3520                 BT_INFO("GATT Client event[BT_GATT_CLIENT_READ_CHAR]");
3521                 bt_gatt_char_property_t char_prop;
3522                 const char *address = NULL;
3523                 GVariant *data_var = NULL;
3524                 GVariant *svc_uuid_var = NULL;
3525                 int svc_inst = 0;
3526                 GVariant *char_uuid_var = NULL;
3527                 int svc_uuid_len = 0;
3528                 int char_uuid_len = 0;
3529                 unsigned int i;
3530
3531                 memset(&char_prop, 0x00, sizeof(bt_gatt_char_property_t));
3532
3533                 /* Extract data from DBUS params */
3534                 g_variant_get(parameters, "(i&sn@ayin@ayin@ay)",
3535                                 &result,
3536                                 &address,
3537                                 &svc_uuid_len,
3538                                 &svc_uuid_var,
3539                                 &svc_inst,
3540                                 &char_uuid_len,
3541                                 &char_uuid_var,
3542                                 &char_prop.prop.instance_id,
3543                                 &char_prop.val_len,
3544                                 &data_var);
3545                 g_strlcpy(char_prop.address, address, BT_ADDRESS_STRING_SIZE);
3546
3547                 BT_INFO("GATT Client Read Callback from [%s] svc inst [%d] char val len [%d] char inst [%d]",
3548                                 address, svc_inst, char_prop.val_len, char_prop.prop.instance_id);
3549
3550                 /* Copy Data */
3551                 memcpy(&char_prop.value, g_variant_get_data(data_var), char_prop.val_len);
3552                 memcpy(&char_prop.prop.uuid, g_variant_get_data(char_uuid_var), 16);
3553
3554                 /* Copy Svc Data */
3555                 memcpy(&char_prop.svc_prop.uuid, g_variant_get_data(svc_uuid_var), 16);
3556                 char_prop.svc_prop.instance_id = svc_inst;
3557
3558                 /* DEBUG */
3559                 for (i = 0; i < char_prop.val_len; i++)
3560                         BT_INFO("Data[%d] = [0x%x]", i, char_prop.value[i]);
3561
3562
3563                 _bt_gatt_client_event_cb(BLUETOOTH_EVENT_GATT_READ_CHAR,
3564                                 result, &char_prop,
3565                                 event_info->cb, event_info->user_data);
3566         } else if (strcasecmp(signal_name, BT_GATT_CLIENT_WRITE_CHAR) == 0) { /* Done */
3567                 /* Event: BLUETOOTH_EVENT_GATT_WRITE_CHAR */
3568                 BT_INFO("GATT Client event[BT_GATT_CLIENT_WRITE_CHAR]");
3569                 bt_gatt_char_property_t char_prop;
3570                 const char *address = NULL;
3571                 GVariant *svc_uuid_var = NULL;
3572                 int svc_inst = 0;
3573                 GVariant *char_uuid_var = NULL;
3574                 int svc_uuid_len = 0;
3575                 int char_uuid_len = 0;
3576
3577                 memset(&char_prop, 0x00, sizeof(bt_gatt_char_property_t));
3578
3579                 /* Extract data from DBUS params */
3580                 g_variant_get(parameters, "(i&sn@ayin@ayi)",
3581                                 &result,
3582                                 &address,
3583                                 &svc_uuid_len,
3584                                 &svc_uuid_var,
3585                                 &svc_inst,
3586                                 &char_uuid_len,
3587                                 &char_uuid_var,
3588                                 &char_prop.prop.instance_id);
3589
3590                 g_strlcpy(char_prop.address, address, BT_ADDRESS_STRING_SIZE);
3591
3592                 BT_DBG("GATT Client Char Write Done in remote Server [%s]", address);
3593
3594                 /* Copy Data */
3595                 memcpy(&char_prop.prop.uuid, g_variant_get_data(char_uuid_var), 16);
3596
3597                 /* Copy Svc Data */
3598                 memcpy(&char_prop.svc_prop.uuid, g_variant_get_data(svc_uuid_var), 16);
3599                 char_prop.svc_prop.instance_id = svc_inst;
3600
3601                 _bt_gatt_client_event_cb(BLUETOOTH_EVENT_GATT_WRITE_CHAR,
3602                                 result, &char_prop,
3603                                 event_info->cb, event_info->user_data);
3604         } else if (strcasecmp(signal_name, BT_GATT_CLIENT_READ_DESC) == 0) { /* Done */
3605                 /* Event: BLUETOOTH_EVENT_GATT_READ_DESC */
3606                 BT_INFO("GATT Client event[BT_GATT_CLIENT_READ_DESC]");
3607                 bt_gatt_char_descriptor_property_t desc_prop;
3608                 const char *address = NULL;
3609                 GVariant *data_var = NULL;
3610                 GVariant *svc_uuid_var = NULL;
3611                 int svc_inst = 0;
3612                 GVariant *char_uuid_var = NULL;
3613                 int char_inst = 0;
3614                 GVariant *desc_uuid_var = NULL;
3615                 int svc_uuid_len = 0;
3616                 int char_uuid_len = 0;
3617                 int desc_uuid_len = 0;
3618                 unsigned int i;
3619
3620                 memset(&desc_prop, 0x00, sizeof(bt_gatt_char_descriptor_property_t));
3621
3622                 /* Extract data from DBUS params */
3623                 g_variant_get(parameters, "(i&sn@ayin@ayin@ayin@ay)",
3624                                 &result,
3625                                 &address,
3626                                 &svc_uuid_len,
3627                                 &svc_uuid_var,
3628                                 &svc_inst,
3629                                 &char_uuid_len,
3630                                 &char_uuid_var,
3631                                 &char_inst,
3632                                 &desc_uuid_len,
3633                                 &desc_uuid_var,
3634                                 &desc_prop.prop.instance_id,
3635                                 &desc_prop.val_len,
3636                                 &data_var);
3637                 g_strlcpy(desc_prop.address, address, BT_ADDRESS_STRING_SIZE);
3638
3639                 BT_DBG("GATT Client Read Descriptor Callback from [%s]", address);
3640                 BT_DBG("GATT Client Descriptor Val len: [%d]", desc_prop.val_len);
3641
3642                 /* Copy Data */
3643                 memcpy(&desc_prop.value, g_variant_get_data(data_var), desc_prop.val_len);
3644                 memcpy(&desc_prop.prop.uuid, g_variant_get_data(desc_uuid_var), 16);
3645
3646                 /* Copy Char Data */
3647                 memcpy(&desc_prop.char_prop.uuid, g_variant_get_data(char_uuid_var), 16);
3648                 desc_prop.char_prop.instance_id = char_inst;
3649
3650                 /* Copy Svc Data */
3651                 memcpy(&desc_prop.svc_prop.uuid, g_variant_get_data(svc_uuid_var), 16);
3652                 desc_prop.svc_prop.instance_id = svc_inst;
3653
3654                 /* DEBUG */
3655                 for (i = 0; i < desc_prop.val_len; i++)
3656                         BT_INFO("Data[%d] = [0x%x]", i, desc_prop.value[i]);
3657
3658                 _bt_gatt_client_event_cb(BLUETOOTH_EVENT_GATT_READ_DESC,
3659                                 result, &desc_prop,
3660                                 event_info->cb, event_info->user_data);
3661         } else if (strcasecmp(signal_name, BT_GATT_CLIENT_WRITE_DESC) == 0) { /* Done */
3662                 /* Event: BLUETOOTH_EVENT_GATT_WRITE_DESC */
3663                 BT_INFO("GATT Client event[BT_GATT_CLIENT_WRITE_DESC]");
3664                 bt_gatt_char_descriptor_property_t desc_prop;
3665                 const char *address = NULL;
3666                 GVariant *svc_uuid_var = NULL;
3667                 int svc_inst = 0;
3668                 GVariant *char_uuid_var = NULL;
3669                 int char_inst;
3670                 GVariant *desc_uuid_var = NULL;
3671                 int svc_uuid_len = 0;
3672                 int char_uuid_len = 0;
3673                 int desc_uuid_len = 0;
3674
3675                 memset(&desc_prop, 0x00, sizeof(bt_gatt_char_descriptor_property_t));
3676
3677                 /* Extract data from DBUS params */
3678                 g_variant_get(parameters, "(i&sn@ayin@ayin@ayi)",
3679                                 &result,
3680                                 &address,
3681                                 &svc_uuid_len,
3682                                 &svc_uuid_var,
3683                                 &svc_inst,
3684                                 &char_uuid_len,
3685                                 &char_uuid_var,
3686                                 &char_inst,
3687                                 &desc_uuid_len,
3688                                 &desc_uuid_var,
3689                                 &desc_prop.prop.instance_id);
3690
3691                 g_strlcpy(desc_prop.address, address, BT_ADDRESS_STRING_SIZE);
3692
3693                 BT_INFO("GATT Client Write Descriptor Callback from [%s]", address);
3694                 BT_INFO("GATT Client Descriptor Val len: [%d]", desc_prop.val_len);
3695
3696                 /* Copy Data */
3697                 memcpy(&desc_prop.prop.uuid, g_variant_get_data(desc_uuid_var), 16);
3698
3699                 /* Copy Char Data */
3700                 memcpy(&desc_prop.char_prop.uuid, g_variant_get_data(char_uuid_var), 16);
3701                 desc_prop.char_prop.instance_id = char_inst;
3702
3703                 /* Copy Svc Data */
3704                 memcpy(&desc_prop.svc_prop.uuid, g_variant_get_data(svc_uuid_var), 16);
3705                 desc_prop.svc_prop.instance_id = svc_inst;
3706
3707                 _bt_gatt_client_event_cb(BLUETOOTH_EVENT_GATT_WRITE_DESC,
3708                                 result, &desc_prop,
3709                                 event_info->cb, event_info->user_data);
3710         }
3711
3712         BT_DBG("GATT Client event handler Exit <<");
3713 }
3714
3715 #endif
3716
3717
3718 #ifndef GATT_DIRECT
3719 static void __bt_gatt_server_event_filter(GDBusConnection *connection,
3720                 const gchar *sender_name,
3721                 const gchar *object_path,
3722                 const gchar *interface_name,
3723                 const gchar *signal_name,
3724                 GVariant *parameters,
3725                 gpointer user_data)
3726 {
3727         BT_INFO("GATT Server event handler Entry >>");
3728
3729         bt_event_info_t *event_info;
3730         int result = BLUETOOTH_ERROR_NONE;
3731
3732         event_info = (bt_event_info_t *)user_data;
3733         ret_if(event_info == NULL);
3734 #ifdef TIZEN_GATT_CLIENT
3735         if (strcasecmp(signal_name, BT_GATT_VALUE_CHANGED) == 0) {
3736 #else
3737         if (strcasecmp(signal_name, BT_GATT_CONNECTED) == 0) {
3738                 const char *address = NULL;
3739                 bluetooth_device_address_t dev_address = { {0} };
3740                 BT_DBG("BT_GATT_CONNECTED");
3741                 g_variant_get(parameters, "(i&s)", &result, &address);
3742
3743                 _bt_convert_addr_string_to_type(dev_address.addr, address);
3744                 _bt_gatt_server_event_cb(BLUETOOTH_EVENT_GATT_CONNECTED,
3745                                 result, &dev_address,
3746                                 event_info->cb, event_info->user_data);
3747         } else if (strcasecmp(signal_name, BT_GATT_DISCONNECTED) == 0) {
3748                 const char *address = NULL;
3749                 bluetooth_device_address_t dev_address = { {0} };
3750                 BT_DBG("BT_GATT_DISCONNECTED");
3751                 g_variant_get(parameters, "(i&s)", &result, &address);
3752
3753                 _bt_convert_addr_string_to_type(dev_address.addr, address);
3754                 _bt_gatt_server_event_cb(BLUETOOTH_EVENT_GATT_DISCONNECTED,
3755                                 result, &dev_address,
3756                                 event_info->cb, event_info->user_data);
3757         } else if (strcasecmp(signal_name, BT_GATT_VALUE_CHANGED) == 0) {
3758 #endif
3759                 BT_INFO("GATT Server event[BT_GATT_SERVER_WRITE_REQUESTED]");
3760                 const char *address = NULL;
3761                 GVariant *data_var = NULL;
3762                 int i;
3763                 bluetooth_device_address_t dev_address = { {0} };
3764
3765                 bluetooth_gatt_server_write_requested_info_t write_info;
3766                 memset(&write_info, 0x00, sizeof(bluetooth_gatt_server_write_requested_info_t));
3767
3768                 /* Extract data from DBUS params */
3769                 g_variant_get(parameters, "(iiiiiibb&sn@ay)",
3770                                 &result,
3771                                 &write_info.connection_id,
3772                                 &write_info.request_id,
3773                                 &write_info.attribute_handle,
3774                                 &write_info.offset,
3775                                 &write_info.length,
3776                                 &write_info.need_resp,
3777                                 &write_info.is_prep_write,
3778                                 &address,
3779                                 &write_info.length,
3780                                 &data_var);
3781
3782                 _bt_convert_addr_string_to_type(dev_address.addr,
3783                                 address);
3784
3785                 BT_DBG("GATT Server Write From Remote Client [%s]", address);
3786                 BT_DBG("GATT Server Write len: [%d]", write_info.length);
3787                 BT_DBG("GATT Server Conn ID:   [%d]", write_info.connection_id);
3788                 BT_DBG("GATT Server Req ID:    [%d]", write_info.request_id);
3789                 BT_DBG("GATT Server att handle:[%d]", write_info.attribute_handle);
3790                 BT_DBG("GATT Server Offset:    [%d]", write_info.offset);
3791                 BT_DBG("GATT Server Need Resp: [%d]", write_info.need_resp);
3792                 BT_DBG("GATT Server Is Prep:   [%d]", write_info.is_prep_write);
3793
3794                 /* Copy Data */
3795                 memcpy(&write_info.data.data, g_variant_get_data(data_var), write_info.length);
3796
3797                 memcpy(write_info.device_address.addr,
3798                                 dev_address.addr,
3799                                 BLUETOOTH_ADDRESS_LENGTH);
3800
3801                 /* DEBUG */
3802                 for (i = 0; i < write_info.length; i++)
3803                         BT_DBG("Data[%d] = [0x%x]", i, write_info.data.data[i]);
3804
3805                 _bt_gatt_server_event_cb(BLUETOOTH_EVENT_GATT_SERVER_VALUE_CHANGED,
3806                                 BLUETOOTH_ERROR_NONE, &write_info,
3807                                 event_info->cb, event_info->user_data);
3808         } else if (strcasecmp(signal_name, BT_GATT_SERVER_READ_REQ) == 0) {
3809                 const char *address = NULL;
3810                 bluetooth_device_address_t dev_address = { {0} };
3811                 bluetooth_gatt_server_read_requested_info_t read_info;
3812
3813                 memset(&read_info, 0x00, sizeof(bluetooth_gatt_server_read_requested_info_t));
3814
3815                 /* Extract data from DBUS params */
3816                 g_variant_get(parameters, "(iiiiib&s)", &result,
3817                                 &read_info.connection_id, &read_info.request_id,
3818                                 &read_info.attribute_handle, &read_info.offset,
3819                                 &read_info.is_long, &address);
3820
3821                 _bt_convert_addr_string_to_type(dev_address.addr,
3822                                 address);
3823                 /* Copy Data */
3824                 memcpy(read_info.device_address.addr,
3825                                 dev_address.addr,
3826                                 BLUETOOTH_ADDRESS_LENGTH);
3827
3828                 _bt_gatt_server_event_cb(BLUETOOTH_EVENT_GATT_SERVER_READ_REQUESTED,
3829                                 result, &read_info,
3830                                 event_info->cb, event_info->user_data);
3831         } else if (strcasecmp(signal_name, BT_GATT_SERVER_NOTIFICATION_COMPLETED) == 0) {
3832                 const char *address = NULL;
3833                 bluetooth_device_address_t dev_address = { {0} };
3834                 bluetooth_gatt_server_indicate_confirmed_info_t info;
3835                 memset(&info, 0x00, sizeof(bluetooth_gatt_server_indicate_confirmed_info_t));
3836
3837                 BT_INFO("GATT Server event[BT_GATT_SERVER_NOTIFICATION_COMPLETED]");
3838                 /* Extract data from DBUS params */
3839                 g_variant_get(parameters, "(i&sib)", &result, &address, &info.handle, &info.completed);
3840
3841                 _bt_convert_addr_string_to_type(dev_address.addr,
3842                                 address);
3843                 /* Copy Data */
3844                 memcpy(info.device_address.addr,
3845                                 dev_address.addr,
3846                                 BLUETOOTH_ADDRESS_LENGTH);
3847
3848                 BT_INFO("GATT Server: Indicate confirmed Handle: [%d] address [%s] completed [%d] result [%d]",
3849                                 info.handle, address, info.completed, result);
3850
3851
3852                 _bt_gatt_server_event_cb(BLUETOOTH_EVENT_GATT_SERVER_NOTIFICATION_COMPLETED,
3853                                 result, &info,
3854                                 event_info->cb, event_info->user_data);
3855         } else if (strcasecmp(signal_name, BT_GATT_SERVER_NOTIFICATION_CHANGED) == 0) {
3856                 const char *address = NULL;
3857                 bluetooth_device_address_t dev_address = { {0} };
3858                 bluetooth_gatt_server_notification_changed_t info;
3859                 memset(&info, 0x00, sizeof(bluetooth_gatt_server_notification_changed_t));
3860
3861                 BT_INFO("GATT Server event[BT_GATT_SERVER_NOTIFICATION_COMPLETED]");
3862                 /* Extract data from DBUS params */
3863                 g_variant_get(parameters, "(i&sib)", &result, &address, &info.handle, &info.notification);
3864
3865                 _bt_convert_addr_string_to_type(dev_address.addr,
3866                                 address);
3867                 /* Copy Data */
3868                 memcpy(info.device_address.addr,
3869                                 dev_address.addr,
3870                                 BLUETOOTH_ADDRESS_LENGTH);
3871
3872                 BT_INFO("GATT Server: Notification Enabled?? Handle: [%d] address [%s] Is Enabled [%d] result [%d]",
3873                                 info.handle, address, info.notification, result);
3874
3875                 _bt_gatt_server_event_cb(BLUETOOTH_EVENT_GATT_SERVER_NOTIFICATION_STATE_CHANGED,
3876                                 result, &info,
3877                                 event_info->cb, event_info->user_data);
3878         }
3879
3880         BT_INFO("GATT Server event handler Exit <<");
3881 }
3882 #endif
3883
3884 int _bt_register_event(int event_type, void *event_cb, void *user_data)
3885 {
3886         GDBusConnection *connection_type;
3887         GDBusSignalCallback event_func;
3888         bt_event_info_t *cb_data;
3889         const char *path;
3890         const char *interface = BT_EVENT_SERVICE;
3891
3892         if (is_initialized == FALSE)
3893                 _bt_init_event_handler();
3894
3895         if (__bt_event_is_registered(event_type) == TRUE) {
3896                 BT_ERR("The event is already registed");
3897                 return BLUETOOTH_ERROR_ALREADY_INITIALIZED;
3898         }
3899
3900         switch (event_type) {
3901         case BT_ADAPTER_EVENT:
3902                 event_func = __bt_adapter_event_filter;
3903                 path = BT_ADAPTER_PATH;
3904                 break;
3905         case BT_LE_ADAPTER_EVENT:
3906                 event_func = __bt_adapter_le_event_filter;
3907                 path = BT_LE_ADAPTER_PATH;
3908                 break;
3909         case BT_DEVICE_EVENT:
3910                 event_func = __bt_device_event_filter;
3911                 path = BT_DEVICE_PATH;
3912                 break;
3913         case BT_HID_EVENT:
3914                 event_func = __bt_hid_event_filter;
3915                 path = BT_HID_PATH;
3916                 break;
3917         case BT_HEADSET_EVENT:
3918                 event_func = __bt_headset_event_filter;
3919                 path = BT_HEADSET_PATH;
3920         break;
3921         case BT_NETWORK_EVENT:
3922                 event_func = __bt_network_event_filter;
3923                 path = BT_NETWORK_PATH;
3924         break;
3925         case BT_AVRCP_EVENT:
3926                 event_func = __bt_avrcp_event_filter;
3927                 path = BT_AVRCP_PATH;
3928                 break;
3929         case BT_AVRCP_CONTROL_EVENT:
3930                 event_func = __bt_avrcp_control_event_filter;
3931                 path = BT_AVRCP_CONTROL_PATH;
3932                 break;
3933         case BT_OPP_CLIENT_EVENT:
3934                 event_func = __bt_opp_client_event_filter;
3935                 path = BT_OPP_CLIENT_PATH;
3936                 break;
3937         case BT_OPP_SERVER_EVENT:
3938                 event_func = __bt_opp_server_event_filter;
3939                 path = BT_OPP_SERVER_PATH;
3940                 break;
3941         case BT_MAP_CLIENT_EVENT:
3942                 event_func = __bt_map_client_event_filter;
3943                 path = BT_MAP_CLIENT_PATH;
3944                 break;
3945         case BT_PBAP_CLIENT_EVENT:
3946                 event_func = __bt_pbap_client_event_filter;
3947                 path = BT_PBAP_CLIENT_PATH;
3948                 break;
3949         case BT_RFCOMM_CLIENT_EVENT:
3950                 event_func = __bt_rfcomm_client_event_filter;
3951                 path = BT_RFCOMM_CLIENT_PATH;
3952                 break;
3953         case BT_RFCOMM_SERVER_EVENT:
3954                 event_func = __bt_rfcomm_server_event_filter;
3955                 path = BT_RFCOMM_SERVER_PATH;
3956                 break;
3957         case BT_HF_AGENT_EVENT:
3958                 BT_DBG("BT_HF_AGENT_EVENT\n");
3959                 event_func = __bt_hf_agent_event_filter;
3960                 path = BT_HF_AGENT_PATH;
3961                 interface = BT_HF_SERVICE_INTERFACE;
3962                 break;
3963         case BT_A2DP_SOURCE_EVENT:
3964                 BT_DBG("BT_A2DP_SOURCE_EVENT");
3965                 event_func = __bt_a2dp_source_event_filter;
3966                 path = BT_A2DP_SOURCE_PATH;
3967                 break;
3968         case BT_HID_DEVICE_EVENT:
3969                 BT_DBG("BT_HID_DEVICE_EVENT");
3970                 event_func = __bt_hid_device_event_filter;
3971                 path = BT_HID_DEVICE_PATH;
3972                 break;
3973 #ifdef GATT_NO_RELAY
3974         case BT_GATT_BLUEZ_EVENT:
3975                 BT_DBG("BT_GATT_BLUEZ_EVENT");
3976                 event_func = __bt_device_event_filter;
3977                 interface = BT_GATT_CHARACTERISTIC_INTERFACE;
3978                 path = NULL;
3979                 break;
3980 #endif
3981         case BT_TDS_EVENT:
3982                 BT_DBG("BT_TDS_EVENT");
3983                 event_func = __bt_tds_event_filter;
3984                 path = BT_TDS_PATH;
3985                 break;
3986         case BT_OTP_EVENT:
3987                 BT_DBG("BT_OTP_EVENT");
3988                 event_func = __bt_otp_event_filter;
3989                 path = BT_OTP_PATH;
3990                 break;
3991         case BT_HDP_EVENT:
3992                 BT_DBG("BT_HDP_EVENT");
3993                 event_func = __bt_hdp_event_filter;
3994                 path = BT_HDP_DEVICE_PATH;
3995                 break;
3996 #ifndef GATT_DIRECT
3997         case BT_GATT_SERVER_EVENT:
3998                 event_func = __bt_gatt_server_event_filter;
3999                 path = BT_GATT_SERVER_PATH;
4000                 break;
4001 #endif
4002
4003 #ifdef TIZEN_GATT_CLIENT
4004         case BT_GATT_CLIENT_EVENT:
4005                 event_func = __bt_gatt_client_event_filter;
4006                 path = BT_GATT_CLIENT_PATH;
4007                 break;
4008 #endif
4009         default:
4010                 BT_ERR("Unknown event");
4011                 return BLUETOOTH_ERROR_INTERNAL;
4012         }
4013
4014         connection_type = _bt_gdbus_get_system_gconn();
4015         if (connection_type == NULL)
4016                 return BLUETOOTH_ERROR_INTERNAL;
4017
4018         cb_data = g_new0(bt_event_info_t, 1);
4019
4020         cb_data->event_type = event_type;
4021         cb_data->cb = event_cb;
4022         cb_data->user_data = user_data;
4023
4024         cb_data->id = g_dbus_connection_signal_subscribe(connection_type,
4025                                 NULL, interface, NULL, path, NULL, 0,
4026                                 event_func, cb_data, NULL);
4027
4028         event_list = g_slist_append(event_list, cb_data);
4029
4030         return BLUETOOTH_ERROR_NONE;
4031 }
4032
4033 int _bt_unregister_event(int event_type)
4034 {
4035         GDBusConnection *connection_type;
4036         bt_event_info_t *cb_data;
4037
4038         if (is_initialized == FALSE) {
4039                 BT_ERR("Event is not registered");
4040                 return BLUETOOTH_ERROR_NOT_INITIALIZED;
4041         }
4042
4043         if (__bt_event_is_registered(event_type) == FALSE) {
4044                 BT_ERR("Not registered event");
4045                 return BLUETOOTH_ERROR_INTERNAL;
4046         }
4047
4048         cb_data = _bt_event_get_cb_data(event_type);
4049
4050         if (cb_data == NULL) {
4051                 BT_ERR("No matched event data");
4052                 return BLUETOOTH_ERROR_INTERNAL;
4053         }
4054
4055         connection_type = _bt_gdbus_get_system_gconn();
4056
4057         event_list = g_slist_remove(event_list, (void *)cb_data);
4058
4059         retv_if(connection_type == NULL, BLUETOOTH_ERROR_INTERNAL);
4060
4061         g_dbus_connection_signal_unsubscribe(connection_type, cb_data->id);
4062
4063         __bt_event_data_free((void *)cb_data);
4064
4065         return BLUETOOTH_ERROR_NONE;
4066 }
4067
4068 static void __bt_name_owner_changed(GDBusConnection *connection,
4069                                                  const gchar *sender_name,
4070                                                  const gchar *object_path,
4071                                                  const gchar *interface_name,
4072                                                  const gchar *signal_name,
4073                                                  GVariant *parameters,
4074                                                  gpointer user_data)
4075 {
4076         const char *name = NULL;
4077         const char *old_owner = NULL;
4078         const char *new_owner = NULL;
4079         bt_event_info_t *event_info;
4080
4081         g_variant_get(parameters, "(&s&s&s)", &name, &old_owner, &new_owner);
4082
4083         if (g_strcmp0(name, BT_DBUS_NAME) == 0 &&
4084                         (new_owner != NULL && *new_owner == '\0')) {
4085                 BT_DBG("bt-service is terminated");
4086                 event_info = _bt_event_get_cb_data(BT_ADAPTER_EVENT);
4087                 if (event_info == NULL)
4088                         return;
4089
4090                 if (disable_timer_id > 0)
4091                         g_source_remove(disable_timer_id);
4092
4093                 disable_timer_id = g_timeout_add(BT_RELIABLE_DISABLE_TIME,
4094                                 (GSourceFunc)__bt_reliable_disable_cb,
4095                                 event_info);
4096         }
4097 }
4098
4099 void _bt_register_name_owner_changed(void)
4100 {
4101         GDBusConnection *connection_type;
4102
4103         connection_type = _bt_gdbus_get_system_gconn();
4104         if (connection_type == NULL) {
4105                 BT_ERR("Unable to get the bus");
4106                 return;
4107         }
4108         owner_sig_id = g_dbus_connection_signal_subscribe(connection_type,
4109                                 NULL, BT_EVENT_FREEDESKTOP,
4110                                 BT_NAME_OWNER_CHANGED, NULL, NULL, 0,
4111                                 __bt_name_owner_changed, NULL, NULL);
4112 }
4113
4114 void _bt_unregister_name_owner_changed(void)
4115 {
4116         GDBusConnection *connection_type;
4117
4118         connection_type = _bt_gdbus_get_system_gconn();
4119         if (connection_type != NULL && owner_sig_id > 0) {
4120                 g_dbus_connection_signal_unsubscribe(connection_type,
4121                                                         owner_sig_id);
4122                 owner_sig_id = 0;
4123         }
4124 }
4125
4126 static void __bt_gatt_get_uuid_from_path(char *path, char **service_uuid)
4127 {
4128         GDBusProxy *proxy = NULL;
4129         GError *err = NULL;
4130         GDBusConnection *g_conn;
4131         GVariant *ret = NULL;
4132         GVariant *value = NULL;
4133
4134         g_conn = _bt_gdbus_get_system_gconn();
4135         ret_if(g_conn == NULL);
4136
4137         proxy = g_dbus_proxy_new_sync(g_conn,
4138                                 G_DBUS_PROXY_FLAGS_NONE, NULL,
4139                                 BT_BLUEZ_NAME,
4140                                 path,
4141                                 BT_PROPERTIES_INTERFACE,
4142                                 NULL, &err);
4143
4144         ret_if(proxy == NULL);
4145
4146         ret = g_dbus_proxy_call_sync(proxy, "Get",
4147                         g_variant_new("(ss)", GATT_SERV_INTERFACE, "UUID"),
4148                         G_DBUS_CALL_FLAGS_NONE, -1, NULL, &err);
4149         if (err) {
4150                 BT_ERR("DBus Error : %s", err->message);
4151                 g_clear_error(&err);
4152         } else {
4153                 g_variant_get(ret, "(v)", &value);
4154                 *service_uuid = g_variant_dup_string(value, NULL);
4155                 g_variant_unref(value);
4156                 g_variant_unref(ret);
4157         }
4158
4159         if (proxy)
4160                 g_object_unref(proxy);
4161
4162         return;
4163 }
4164
4165
4166 static void __bt_manager_event_filter(GDBusConnection *connection,
4167                                         const gchar *sender_name,
4168                                         const gchar *object_path,
4169                                         const gchar *interface_name,
4170                                         const gchar *signal_name,
4171                                         GVariant *parameters,
4172                                         gpointer user_data)
4173 {
4174         char *path = NULL;
4175         GVariantIter *interface_iter = NULL;
4176         char *interface_str = NULL;
4177         bt_gatt_service_change_t change;
4178         char secure_address[BT_ADDRESS_STRING_SIZE] = { 0 };
4179         bt_user_info_t *user_info = NULL;
4180
4181         user_info = _bt_get_user_data(BT_COMMON);
4182         if (user_info == NULL) {
4183                 BT_ERR("There is no registered common event callback");
4184                 return;
4185         }
4186
4187         if (strcasecmp(signal_name, "GattServiceAdded") == 0) {
4188                 g_variant_get(parameters, "(&s)", &path);
4189
4190                 _bt_convert_device_path_to_addr_type(path, change.device_addr.addr);
4191                 _bt_convert_addr_type_to_secure_string(secure_address,
4192                                                        change.device_addr.addr);
4193
4194                 if (_bluetooth_gatt_check_service_change_watcher_address(&change.device_addr)
4195                         == FALSE) {
4196                         BT_INFO("GATT Service [%s] added, but no watcher for %s",
4197                                                         path, secure_address);
4198                         return;
4199                 } else {
4200                         char *uuid = NULL;
4201                         char *name = NULL;
4202                         __bt_gatt_get_uuid_from_path(path, &uuid);
4203                         bluetooth_get_uuid_name(uuid, &name);
4204
4205                         BT_INFO(" ### GATT Service added [%s] [%s]",
4206                                                         path, name);
4207                         g_free(name);
4208                         g_free(uuid);
4209                 }
4210
4211                 change.svc_path = g_strdup(path);
4212                 change.change_type = BLUETOOTH_GATT_SERVICE_CHANGE_TYPE_ADD;
4213                 _bt_common_event_cb(BLUETOOTH_EVENT_GATT_CLIENT_SERVICE_CHANGED,
4214                                     BLUETOOTH_ERROR_NONE, &change,
4215                                     user_info->cb, user_info->user_data);
4216                 g_free(change.svc_path);
4217         } else if (strcasecmp(signal_name, "InterfacesRemoved") == 0) {
4218                 g_variant_get(parameters, "(&oas)", &path, &interface_iter);
4219                 if (!path) {
4220                         BT_ERR("Invalid adapter path");
4221                         g_variant_iter_free(interface_iter);
4222                         return;
4223                 }
4224
4225                 _bt_convert_device_path_to_addr_type(path, change.device_addr.addr);
4226                 if (!_bluetooth_gatt_check_service_change_watcher_address(&change.device_addr)) {
4227                         g_variant_iter_free(interface_iter);
4228                         return;
4229                 }
4230
4231                 while (g_variant_iter_loop(interface_iter, "&s", &interface_str)) {
4232                         if (g_strcmp0(interface_str, GATT_SERV_INTERFACE) != 0)
4233                                 continue;
4234
4235                         BT_INFO(" ### GATT Service removed [%s]", path);
4236
4237                         change.svc_path = g_strdup(path);
4238                         change.change_type = BLUETOOTH_GATT_SERVICE_CHANGE_TYPE_REMOVE;
4239                         _bt_common_event_cb(
4240                                         BLUETOOTH_EVENT_GATT_CLIENT_SERVICE_CHANGED,
4241                                         BLUETOOTH_ERROR_NONE, &change,
4242                                         user_info->cb, user_info->user_data);
4243                         g_free(change.svc_path);
4244                         break;
4245                 }
4246                 g_variant_iter_free(interface_iter);
4247         }
4248 }
4249
4250 int _bt_register_manager_subscribe_signal(gboolean subscribe)
4251 {
4252         GDBusConnection *g_conn;
4253         static guint service_added_id = 0;
4254         static guint interface_removed_id = 0;
4255
4256         g_conn = _bt_gdbus_get_system_gconn();
4257         if (g_conn == NULL)
4258                 return BLUETOOTH_ERROR_INTERNAL;
4259
4260         if (subscribe == TRUE) {
4261                 if (service_added_id == 0) {
4262                         service_added_id = g_dbus_connection_signal_subscribe(g_conn,
4263                                         NULL, GATT_SERV_INTERFACE,
4264                                         "GattServiceAdded", NULL, NULL, 0,
4265                                         __bt_manager_event_filter,
4266                                         NULL, NULL);
4267                 }
4268                 if (interface_removed_id == 0) {
4269                         interface_removed_id = g_dbus_connection_signal_subscribe(g_conn,
4270                                         NULL, BT_MANAGER_INTERFACE,
4271                                         "InterfacesRemoved", NULL, NULL, 0,
4272                                         __bt_manager_event_filter,
4273                                         NULL, NULL);
4274                 }
4275         } else {
4276                 if (service_added_id > 0) {
4277                         g_dbus_connection_signal_unsubscribe(g_conn,
4278                                         service_added_id);
4279                         service_added_id = 0;
4280                 }
4281                 if (interface_removed_id > 0) {
4282                         g_dbus_connection_signal_unsubscribe(g_conn,
4283                                         interface_removed_id);
4284                         interface_removed_id = 0;
4285                 }
4286         }
4287
4288         return BLUETOOTH_ERROR_NONE;
4289 }
4290