bt-api/bt-event-handler.c

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