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_LE_DATA_LENGTH_CHANGED) == 0) {
1024                 const char *address = NULL;
1025                 bluetooth_device_address_t dev_address = { {0} };
1026                 uint tx_octets = 0;
1027                 uint tx_time = 0;
1028                 uint rx_octets = 0;
1029                 uint rx_time = 0;
1030                 bt_le_data_length_params_t params;
1031
1032                 BT_DBG("BT_LE_DATA_LENGTH_CHANGED");
1033
1034                 g_variant_get(parameters, "(i&sqqqq)", &result, &address,
1035                                 tx_octets, tx_time, rx_octets, rx_time);
1036
1037                 params.max_tx_octets = tx_octets;
1038                 params.max_tx_time = tx_time;
1039                 params.max_rx_octets = rx_octets;
1040                 params.max_rx_time = rx_time;
1041
1042                 _bt_convert_addr_string_to_type(dev_address.addr, address);
1043
1044                 memcpy(&params.device_address,
1045                         &dev_address, BLUETOOTH_ADDRESS_LENGTH);
1046
1047                 _bt_common_event_cb(BLUETOOTH_EVENT_LE_DATA_LENGTH_CHANGED,
1048                                 result, &params, event_info->cb, event_info->user_data);
1049         }
1050 }
1051
1052 void __bt_hid_event_filter(GDBusConnection *connection,
1053                                                  const gchar *sender_name,
1054                                                  const gchar *object_path,
1055                                                  const gchar *interface_name,
1056                                                  const gchar *signal_name,
1057                                                  GVariant *parameters,
1058                                                  gpointer user_data)
1059 {
1060         bt_event_info_t *event_info;
1061         int result = BLUETOOTH_ERROR_NONE;
1062
1063         event_info = (bt_event_info_t *)user_data;
1064         ret_if(event_info == NULL);
1065
1066         if (strcasecmp(object_path, BT_HID_PATH) != 0)
1067                 return;
1068         if (strcasecmp(interface_name, BT_EVENT_SERVICE) != 0)
1069                 return;
1070
1071         ret_if(signal_name == NULL);
1072
1073         if (strcasecmp(signal_name, BT_INPUT_CONNECTED) == 0) {
1074                 const char *address = NULL;
1075                 bluetooth_device_address_t dev_address = { {0} };
1076
1077                 g_variant_get(parameters, "(i&s)", &result, &address);
1078
1079                 _bt_convert_addr_string_to_type(dev_address.addr,
1080                                                 address);
1081
1082                 _bt_input_event_cb(BLUETOOTH_HID_CONNECTED,
1083                                 result, &dev_address,
1084                                 event_info->cb, event_info->user_data);
1085         } else if (strcasecmp(signal_name, BT_INPUT_DISCONNECTED) == 0) {
1086                 const char *address = NULL;
1087                 bluetooth_device_address_t dev_address = { {0} };
1088
1089                 g_variant_get(parameters, "(i&s)", &result, &address);
1090
1091                 BT_DBG("address: %s", address);
1092
1093                 _bt_convert_addr_string_to_type(dev_address.addr,
1094                                                 address);
1095
1096                 _bt_input_event_cb(BLUETOOTH_HID_DISCONNECTED,
1097                                 result, &dev_address,
1098                                 event_info->cb, event_info->user_data);
1099         }
1100 }
1101
1102 void __bt_headset_event_filter(GDBusConnection *connection,
1103                                                  const gchar *sender_name,
1104                                                  const gchar *object_path,
1105                                                  const gchar *interface_name,
1106                                                  const gchar *signal_name,
1107                                                  GVariant *parameters,
1108                                                  gpointer user_data)
1109 {
1110         bt_event_info_t *event_info;
1111         int result = BLUETOOTH_ERROR_NONE;
1112         event_info = (bt_event_info_t *)user_data;
1113         ret_if(event_info == NULL);
1114
1115         if (strcasecmp(object_path, BT_HEADSET_PATH) != 0)
1116                 return;
1117         if (strcasecmp(interface_name, BT_EVENT_SERVICE) != 0)
1118                 return;
1119
1120         ret_if(signal_name == NULL);
1121
1122         if (strcasecmp(signal_name, BT_HEADSET_CONNECTED) == 0) {
1123                 char *address = NULL;
1124
1125                 g_variant_get(parameters, "(i&s)", &result, &address);
1126
1127                 _bt_headset_event_cb(BLUETOOTH_EVENT_AG_CONNECTED,
1128                                 result, address,
1129                                 event_info->cb, event_info->user_data);
1130         } else if (strcasecmp(signal_name, BT_HEADSET_DISCONNECTED) == 0) {
1131                 char *address = NULL;
1132
1133                 g_variant_get(parameters, "(i&s)", &result, &address);
1134
1135                 _bt_headset_event_cb(BLUETOOTH_EVENT_AG_DISCONNECTED,
1136                                 result, address,
1137                                 event_info->cb, event_info->user_data);
1138         } else if (strcasecmp(signal_name, BT_STEREO_HEADSET_CONNECTED) == 0) {
1139                 char *address = NULL;
1140
1141                 g_variant_get(parameters, "(i&s)", &result, &address);
1142
1143                 _bt_headset_event_cb(BLUETOOTH_EVENT_AV_CONNECTED,
1144                                 result, address,
1145                                 event_info->cb, event_info->user_data);
1146         } else if (strcasecmp(signal_name, BT_STEREO_HEADSET_DISCONNECTED) == 0) {
1147                 char *address = NULL;
1148
1149                 g_variant_get(parameters, "(i&s)", &result, &address);
1150
1151                 _bt_headset_event_cb(BLUETOOTH_EVENT_AV_DISCONNECTED,
1152                                 result, address,
1153                                 event_info->cb, event_info->user_data);
1154         } else if (strcasecmp(signal_name, BT_A2DP_SOURCE_CONNECTED) == 0) {
1155                 char *address = NULL;
1156
1157                 g_variant_get(parameters, "(i&s)", &result, &address);
1158                 _bt_a2dp_source_event_cb(BLUETOOTH_EVENT_AV_SOURCE_CONNECTED,
1159                                                 result, address,
1160                                                 event_info->cb, event_info->user_data);
1161         } else if (strcasecmp(signal_name, BT_A2DP_SOURCE_DISCONNECTED) == 0) {
1162                 char *address = NULL;
1163
1164                 g_variant_get(parameters, "(i&s)", &result, &address);
1165
1166                 _bt_a2dp_source_event_cb(BLUETOOTH_EVENT_AV_SOURCE_DISCONNECTED,
1167                                                 result, address,
1168                                                 event_info->cb, event_info->user_data);
1169         } else if (strcasecmp(signal_name, BT_SPEAKER_GAIN) == 0) {
1170                 unsigned int gain;
1171                 guint16 spkr_gain;
1172                 char *address = NULL;
1173
1174                 g_variant_get(parameters, "(i&sq)", &result, &address,
1175                                                                 &spkr_gain);
1176                 gain = (unsigned int)spkr_gain;
1177
1178                 _bt_headset_event_cb(BLUETOOTH_EVENT_AG_SPEAKER_GAIN,
1179                                 result, &gain,
1180                                 event_info->cb, event_info->user_data);
1181         } else if (strcasecmp(signal_name, BT_MICROPHONE_GAIN) == 0) {
1182                 unsigned int gain;
1183                 guint16 mic_gain;
1184                 char *address = NULL;
1185
1186                 g_variant_get(parameters, "(i&sq)", &result,
1187                                                 &address, &mic_gain);
1188                 gain = (unsigned int)mic_gain;
1189
1190                 _bt_headset_event_cb(BLUETOOTH_EVENT_AG_MIC_GAIN,
1191                                 result, &gain,
1192                                 event_info->cb, event_info->user_data);
1193         }
1194 }
1195
1196 void __bt_hid_device_event_filter(GDBusConnection *connection,
1197                                                  const gchar *sender_name,
1198                                                  const gchar *object_path,
1199                                                  const gchar *interface_name,
1200                                                  const gchar *signal_name,
1201                                                  GVariant *parameters,
1202                                                  gpointer user_data)
1203 {
1204         bt_event_info_t *event_info;
1205         int result = BLUETOOTH_ERROR_NONE;
1206
1207         event_info = (bt_event_info_t *)user_data;
1208         ret_if(event_info == NULL);
1209
1210         if (strcasecmp(object_path, BT_HID_DEVICE_PATH) != 0)
1211                 return;
1212         if (strcasecmp(interface_name, BT_EVENT_SERVICE) != 0)
1213                 return;
1214
1215         ret_if(signal_name == NULL);
1216
1217         if (strcasecmp(signal_name, BT_HID_DEVICE_CONNECTED) == 0) {
1218                 const char *address = NULL;
1219                 bluetooth_device_address_t dev_address = { {0} };
1220
1221                 g_variant_get(parameters, "(i&s)", &result, &address);
1222
1223                 _bt_convert_addr_string_to_type(dev_address.addr,
1224                                                 address);
1225
1226                 _bt_input_event_cb(BLUETOOTH_HID_DEVICE_CONNECTED,
1227                                 result, &dev_address,
1228                                 event_info->cb, event_info->user_data);
1229         } else if (strcasecmp(signal_name, BT_HID_DEVICE_DISCONNECTED) == 0) {
1230                 const char *address = NULL;
1231                 bluetooth_device_address_t dev_address = { {0} };
1232
1233                 g_variant_get(parameters, "(i&s)", &result, &address);
1234
1235                 BT_DBG("address: %s", address);
1236
1237                 _bt_convert_addr_string_to_type(dev_address.addr,
1238                                                 address);
1239
1240                 _bt_input_event_cb(BLUETOOTH_HID_DEVICE_DISCONNECTED,
1241                                 result, &dev_address,
1242                                 event_info->cb, event_info->user_data);
1243         }
1244 }
1245 void __bt_a2dp_source_event_filter(GDBusConnection *connection,
1246                                                  const gchar *sender_name,
1247                                                  const gchar *object_path,
1248                                                  const gchar *interface_name,
1249                                                  const gchar *signal_name,
1250                                                  GVariant *parameters,
1251                                                  gpointer user_data)
1252 {
1253         bt_event_info_t *event_info;
1254         int result = BLUETOOTH_ERROR_NONE;
1255         event_info = (bt_event_info_t *)user_data;
1256         ret_if(event_info == NULL);
1257
1258         if (strcasecmp(object_path, BT_A2DP_SOURCE_PATH) != 0)
1259                 return;
1260         if (strcasecmp(interface_name, BT_EVENT_SERVICE) != 0)
1261                 return;
1262
1263         ret_if(signal_name == NULL);
1264
1265         if (strcasecmp(signal_name, BT_A2DP_SOURCE_CONNECTED) == 0) {
1266                 char *address = NULL;
1267
1268                 g_variant_get(parameters, "(i&s)", &result, &address);
1269                 _bt_a2dp_source_event_cb(BLUETOOTH_EVENT_AV_SOURCE_CONNECTED,
1270                                                 result, address,
1271                                                 event_info->cb, event_info->user_data);
1272         } else if (strcasecmp(signal_name, BT_A2DP_SOURCE_DISCONNECTED) == 0) {
1273                 char *address = NULL;
1274
1275                 g_variant_get(parameters, "(i&s)", &result, &address);
1276
1277                 _bt_a2dp_source_event_cb(BLUETOOTH_EVENT_AV_SOURCE_DISCONNECTED,
1278                                                 result, address,
1279                                                 event_info->cb, event_info->user_data);
1280         }
1281 }
1282
1283 void __bt_network_event_filter(GDBusConnection *connection,
1284                                                  const gchar *sender_name,
1285                                                  const gchar *object_path,
1286                                                  const gchar *interface_name,
1287                                                  const gchar *signal_name,
1288                                                  GVariant *parameters,
1289                                                  gpointer user_data)
1290 {
1291         bt_event_info_t *event_info;
1292         int result = BLUETOOTH_ERROR_NONE;
1293         event_info = (bt_event_info_t *)user_data;
1294         ret_if(event_info == NULL);
1295
1296         if (strcasecmp(object_path, BT_NETWORK_PATH) != 0)
1297                 return;
1298         if (strcasecmp(interface_name, BT_EVENT_SERVICE) != 0)
1299                 return;
1300
1301         ret_if(signal_name == NULL);
1302
1303         if (strcasecmp(signal_name, BT_NETWORK_CONNECTED) == 0) {
1304                 const char *address = NULL;
1305                 bluetooth_device_address_t dev_address = { {0} };
1306
1307                 g_variant_get(parameters, "(i&s)", &result, &address);
1308
1309                 _bt_convert_addr_string_to_type(dev_address.addr,
1310                                                 address);
1311
1312                 _bt_common_event_cb(BLUETOOTH_EVENT_NETWORK_CONNECTED,
1313                                 result, &dev_address,
1314                                 event_info->cb, event_info->user_data);
1315         } else if (strcasecmp(signal_name, BT_NETWORK_DISCONNECTED) == 0) {
1316                 const char *address = NULL;
1317                 bluetooth_device_address_t dev_address = { {0} };
1318
1319                 g_variant_get(parameters, "(i&s)", &result, &address);
1320
1321                 _bt_convert_addr_string_to_type(dev_address.addr,
1322                                                 address);
1323
1324                 _bt_common_event_cb(BLUETOOTH_EVENT_NETWORK_DISCONNECTED,
1325                                 result, &dev_address,
1326                                 event_info->cb, event_info->user_data);
1327         } else if (strcasecmp(signal_name, BT_NETWORK_SERVER_CONNECTED) == 0) {
1328                 const char *device = NULL;
1329                 const char *address = NULL;
1330                 bluetooth_network_device_info_t network_info;
1331
1332                 g_variant_get(parameters, "(i&s&s)", &result,
1333                                                         &device, &address);
1334
1335                 memset(&network_info, 0x00, sizeof(bluetooth_network_device_info_t));
1336
1337                 _bt_convert_addr_string_to_type(network_info.device_address.addr,
1338                                                 address);
1339
1340                 _bt_print_device_address_t(&network_info.device_address);
1341                 g_strlcpy(network_info.interface_name, device,
1342                                         sizeof(network_info.interface_name));
1343
1344                 DBG_SECURE("Interface: %s", network_info.interface_name);
1345
1346                 _bt_common_event_cb(BLUETOOTH_EVENT_NETWORK_SERVER_CONNECTED,
1347                                 result, &network_info,
1348                                 event_info->cb, event_info->user_data);
1349         } else if (strcasecmp(signal_name, BT_NETWORK_SERVER_DISCONNECTED) == 0) {
1350                 const char *device = NULL;
1351                 const char *address = NULL;
1352                 bluetooth_network_device_info_t network_info;
1353
1354                 g_variant_get(parameters, "(i&s&s)", &result, &device, &address);
1355
1356                 memset(&network_info, 0x00, sizeof(bluetooth_network_device_info_t));
1357
1358                 _bt_convert_addr_string_to_type(network_info.device_address.addr,
1359                                                 address);
1360
1361                 _bt_print_device_address_t(&network_info.device_address);
1362
1363                 _bt_common_event_cb(BLUETOOTH_EVENT_NETWORK_SERVER_DISCONNECTED,
1364                                 result, &network_info,
1365                                 event_info->cb, event_info->user_data);
1366         }
1367 }
1368
1369 void __bt_avrcp_event_filter(GDBusConnection *connection,
1370                                                  const gchar *sender_name,
1371                                                  const gchar *object_path,
1372                                                  const gchar *interface_name,
1373                                                  const gchar *signal_name,
1374                                                  GVariant *parameters,
1375                                                  gpointer user_data)
1376 {
1377         bt_event_info_t *event_info;
1378         int result = BLUETOOTH_ERROR_NONE;
1379         event_info = (bt_event_info_t *)user_data;
1380         ret_if(event_info == NULL);
1381
1382         if (strcasecmp(object_path, BT_AVRCP_PATH) != 0)
1383                 return;
1384         if (strcasecmp(interface_name, BT_EVENT_SERVICE) != 0)
1385                 return;
1386
1387         ret_if(signal_name == NULL);
1388
1389         if (strcasecmp(signal_name, BT_AVRCP_CONNECTED) == 0) {
1390                 char *address = NULL;
1391
1392                 g_variant_get(parameters, "(i&s)", &result, &address);
1393
1394                 _bt_avrcp_event_cb(BLUETOOTH_EVENT_AVRCP_CONNECTED,
1395                                 result, address,
1396                                 event_info->cb, event_info->user_data);
1397         } else if (strcasecmp(signal_name, BT_AVRCP_DISCONNECTED) == 0) {
1398                 char *address = NULL;
1399
1400                 g_variant_get(parameters, "(i&s)", &result, &address);
1401
1402                 _bt_avrcp_event_cb(BLUETOOTH_EVENT_AVRCP_DISCONNECTED,
1403                                 result, address,
1404                                 event_info->cb, event_info->user_data);
1405         } else if (strcasecmp(signal_name, BT_MEDIA_SHUFFLE_STATUS) == 0) {
1406                 unsigned int status;
1407
1408                 g_variant_get(parameters, "(u)", &status);
1409                 _bt_avrcp_event_cb(BLUETOOTH_EVENT_AVRCP_SETTING_SHUFFLE_STATUS,
1410                                 result, &status,
1411                                 event_info->cb, event_info->user_data);
1412         } else if (strcasecmp(signal_name, BT_MEDIA_EQUALIZER_STATUS) == 0) {
1413                 unsigned int status;
1414
1415                 g_variant_get(parameters, "(u)", &status);
1416                 _bt_avrcp_event_cb(BLUETOOTH_EVENT_AVRCP_SETTING_EQUALIZER_STATUS,
1417                                 result, &status,
1418                                 event_info->cb, event_info->user_data);
1419         } else if (strcasecmp(signal_name, BT_MEDIA_REPEAT_STATUS) == 0) {
1420                 unsigned int status;
1421
1422                 g_variant_get(parameters, "(u)", &status);
1423                 _bt_avrcp_event_cb(BLUETOOTH_EVENT_AVRCP_SETTING_REPEAT_STATUS,
1424                                 result, &status,
1425                                 event_info->cb, event_info->user_data);
1426         }  else if (strcasecmp(signal_name, BT_MEDIA_SCAN_STATUS) == 0) {
1427                 unsigned int status;
1428
1429                 g_variant_get(parameters, "(u)", &status);
1430                 _bt_avrcp_event_cb(BLUETOOTH_EVENT_AVRCP_SETTING_SCAN_STATUS,
1431                                 result, &status,
1432                                 event_info->cb, event_info->user_data);
1433         }
1434 }
1435
1436 void __bt_avrcp_control_event_filter(GDBusConnection *connection,
1437                                                 const gchar *sender_name,
1438                                                 const gchar *object_path,
1439                                                 const gchar *interface_name,
1440                                                 const gchar *signal_name,
1441                                                 GVariant *parameters,
1442                                                 gpointer user_data)
1443 {
1444         bt_event_info_t *event_info;
1445         int result = BLUETOOTH_ERROR_NONE;
1446         event_info = (bt_event_info_t *)user_data;
1447         ret_if(event_info == NULL);
1448
1449         if (strcasecmp(object_path, BT_AVRCP_CONTROL_PATH) != 0)
1450                 return;
1451         if (strcasecmp(interface_name, BT_EVENT_SERVICE) != 0)
1452                 return;
1453
1454         ret_if(signal_name == NULL);
1455
1456         if (strcasecmp(signal_name, BT_AVRCP_CONNECTED) == 0) {
1457                 char *address = NULL;
1458
1459                 g_variant_get(parameters, "(i&s)", &result, &address);
1460
1461                 _bt_avrcp_event_cb(BLUETOOTH_EVENT_AVRCP_CONTROL_CONNECTED,
1462                                 result, address,
1463                                 event_info->cb, event_info->user_data);
1464         } else if (strcasecmp(signal_name, BT_AVRCP_DISCONNECTED) == 0) {
1465                 char *address = NULL;
1466
1467                 g_variant_get(parameters, "(i&s)", &result, &address);
1468
1469                 _bt_avrcp_event_cb(BLUETOOTH_EVENT_AVRCP_CONTROL_DISCONNECTED,
1470                                 result, address,
1471                                 event_info->cb, event_info->user_data);
1472         } else if (strcasecmp(signal_name, BT_MEDIA_SHUFFLE_STATUS) == 0) {
1473                 unsigned int status;
1474
1475                 g_variant_get(parameters, "(u)", &status);
1476                 _bt_avrcp_event_cb(BLUETOOTH_EVENT_AVRCP_CONTROL_SHUFFLE_STATUS,
1477                                 result, &status,
1478                                 event_info->cb, event_info->user_data);
1479         } else if (strcasecmp(signal_name, BT_MEDIA_EQUALIZER_STATUS) == 0) {
1480                 unsigned int status;
1481
1482                 g_variant_get(parameters, "(u)", &status);
1483                 _bt_avrcp_event_cb(BLUETOOTH_EVENT_AVRCP_CONTROL_EQUALIZER_STATUS,
1484                                 result, &status,
1485                                 event_info->cb, event_info->user_data);
1486         } else if (strcasecmp(signal_name, BT_MEDIA_REPEAT_STATUS) == 0) {
1487                 unsigned int status;
1488
1489                 g_variant_get(parameters, "(u)", &status);
1490                 _bt_avrcp_event_cb(BLUETOOTH_EVENT_AVRCP_CONTROL_REPEAT_STATUS,
1491                                 result, &status,
1492                                 event_info->cb, event_info->user_data);
1493         }  else if (strcasecmp(signal_name, BT_MEDIA_SCAN_STATUS) == 0) {
1494                 unsigned int status;
1495
1496                 g_variant_get(parameters, "(u)", &status);
1497                 _bt_avrcp_event_cb(BLUETOOTH_EVENT_AVRCP_CONTROL_SCAN_STATUS,
1498                                 result, &status,
1499                                 event_info->cb, event_info->user_data);
1500         } else if (strcasecmp(signal_name, BT_MEDIA_PLAY_STATUS) == 0) {
1501                 unsigned int status;
1502
1503                 g_variant_get(parameters, "(u)", &status);
1504                 _bt_avrcp_event_cb(BLUETOOTH_EVENT_AVRCP_PLAY_STATUS_CHANGED,
1505                                 result, &status,
1506                                 event_info->cb, event_info->user_data);
1507         } else if (strcasecmp(signal_name, BT_MEDIA_POSITION_STATUS) == 0) {
1508                 unsigned int status;
1509
1510                 g_variant_get(parameters, "(u)", &status);
1511                 _bt_avrcp_event_cb(BLUETOOTH_EVENT_AVRCP_SONG_POSITION_STATUS,
1512                                 result, &status,
1513                                 event_info->cb, event_info->user_data);
1514         } else if (strcasecmp(signal_name, BT_MEDIA_TRACK_CHANGE) == 0) {
1515                 media_metadata_attributes_t metadata;
1516                 const char *title;
1517                 const char *artist;
1518                 const char *album;
1519                 const char *genre;
1520                 unsigned int total_tracks;
1521                 unsigned int number;
1522                 unsigned int duration;
1523
1524                 g_variant_get(parameters, "(&s&s&s&suuu)", &title,
1525                                                 &artist, &album, &genre,
1526                                                 &total_tracks, &number,
1527                                                 &duration);
1528                 memset(&metadata, 0x00, sizeof(media_metadata_attributes_t));
1529
1530                 metadata.title = title;
1531                 metadata.artist = artist;
1532                 metadata.album = album;
1533                 metadata.genre = genre;
1534                 metadata.total_tracks = total_tracks;
1535                 metadata.number = number;
1536                 metadata.duration = (int64_t)duration;
1537
1538                 _bt_avrcp_event_cb(BLUETOOTH_EVENT_AVRCP_TRACK_CHANGED,
1539                                 result, &metadata,
1540                                 event_info->cb, event_info->user_data);
1541         }
1542 }
1543
1544 void __bt_opp_client_event_filter(GDBusConnection *connection,
1545                                                  const gchar *sender_name,
1546                                                  const gchar *object_path,
1547                                                  const gchar *interface_name,
1548                                                  const gchar *signal_name,
1549                                                  GVariant *parameters,
1550                                                  gpointer user_data)
1551 {
1552         bt_event_info_t *event_info;
1553         int result = BLUETOOTH_ERROR_NONE;
1554         event_info = (bt_event_info_t *)user_data;
1555         ret_if(event_info == NULL);
1556
1557         if (strcasecmp(object_path, BT_OPP_CLIENT_PATH) != 0)
1558                 return;
1559         if (strcasecmp(interface_name, BT_EVENT_SERVICE) != 0)
1560                 return;
1561
1562         ret_if(signal_name == NULL);
1563
1564         if (strcasecmp(signal_name, BT_OPP_CONNECTED) == 0) {
1565                 const char *address = NULL;
1566                 int request_id = 0;
1567                 bluetooth_device_address_t dev_address = { {0} };
1568
1569                 g_variant_get(parameters, "(i&si)", &result,
1570                                                 &address, &request_id);
1571
1572                 if (__bt_is_request_id_exist(request_id) == FALSE) {
1573                         BT_ERR("Different request id!");
1574                         return;
1575                 }
1576
1577                 _bt_convert_addr_string_to_type(dev_address.addr,
1578                                                 address);
1579
1580                 _bt_common_event_cb(BLUETOOTH_EVENT_OPC_CONNECTED,
1581                                 result, &dev_address,
1582                                 event_info->cb, event_info->user_data);
1583
1584                 if (result != BLUETOOTH_ERROR_NONE) {
1585                         __bt_remove_push_request_id(request_id);
1586                 }
1587         } else if (strcasecmp(signal_name, BT_OPP_DISCONNECTED) == 0) {
1588                 const char *address = NULL;
1589                 int request_id = 0;
1590                 bluetooth_device_address_t dev_address = { {0} };
1591
1592                 g_variant_get(parameters, "(i&si)", &result, &address,
1593                                                         &request_id);
1594
1595                 if (__bt_is_request_id_exist(request_id) == FALSE) {
1596                         BT_ERR("Different request id!");
1597                         return;
1598                 }
1599
1600                 _bt_convert_addr_string_to_type(dev_address.addr,
1601                                                 address);
1602
1603                 _bt_common_event_cb(BLUETOOTH_EVENT_OPC_DISCONNECTED,
1604                                 result, &dev_address,
1605                                 event_info->cb, event_info->user_data);
1606
1607                 __bt_remove_push_request_id(request_id);
1608         } else if (strcasecmp(signal_name, BT_TRANSFER_STARTED) == 0) {
1609                 const char *file_name = NULL;
1610                 int request_id = 0;
1611                 guint64 size = 0;
1612                 bt_opc_transfer_info_t transfer_info;
1613
1614                 g_variant_get(parameters, "(i&sti)", &result, &file_name,
1615                                                 &size, &request_id);
1616
1617                 if (__bt_is_request_id_exist(request_id) == FALSE) {
1618                         BT_ERR("Different request id!");
1619                         return;
1620                 }
1621
1622                 memset(&transfer_info, 0x00, sizeof(bt_opc_transfer_info_t));
1623
1624                 transfer_info.filename = g_strdup(file_name);
1625                 transfer_info.size = size;
1626
1627                 _bt_common_event_cb(BLUETOOTH_EVENT_OPC_TRANSFER_STARTED,
1628                                 result, &transfer_info,
1629                                 event_info->cb, event_info->user_data);
1630
1631                 g_free(transfer_info.filename);
1632         } else if (strcasecmp(signal_name, BT_TRANSFER_PROGRESS) == 0) {
1633                 const char *file_name = NULL;
1634                 int request_id = 0;
1635                 guint64 size = 0;
1636                 int progress = 0;
1637                 bt_opc_transfer_info_t transfer_info;
1638
1639                 g_variant_get(parameters, "(i&stii)", &result,
1640                         &file_name, &size, &progress, &request_id);
1641
1642                 if (__bt_is_request_id_exist(request_id) == FALSE) {
1643                         BT_ERR("Different request id!");
1644                         return;
1645                 }
1646
1647                 memset(&transfer_info, 0x00, sizeof(bt_opc_transfer_info_t));
1648
1649                 transfer_info.filename = g_strdup(file_name);
1650                 transfer_info.size = size;
1651                 transfer_info.percentage = progress;
1652
1653                 _bt_common_event_cb(BLUETOOTH_EVENT_OPC_TRANSFER_PROGRESS,
1654                                 result, &transfer_info,
1655                                 event_info->cb, event_info->user_data);
1656
1657                 g_free(transfer_info.filename);
1658         } else if (strcasecmp(signal_name, BT_TRANSFER_COMPLETED) == 0) {
1659                 const char *file_name = NULL;
1660                 int request_id = 0;
1661                 guint64 size = 0;
1662                 bt_opc_transfer_info_t transfer_info;
1663
1664                 g_variant_get(parameters, "(i&sti)", &result,
1665                                         &file_name, &size, &request_id);
1666
1667                 if (__bt_is_request_id_exist(request_id) == FALSE) {
1668                         BT_ERR("Different request id!");
1669                         return;
1670                 }
1671
1672                 memset(&transfer_info, 0x00, sizeof(bt_opc_transfer_info_t));
1673
1674                 transfer_info.filename = g_strdup(file_name);
1675                 transfer_info.size = size;
1676
1677                 _bt_common_event_cb(BLUETOOTH_EVENT_OPC_TRANSFER_COMPLETE,
1678                                 result, &transfer_info,
1679                                 event_info->cb, event_info->user_data);
1680
1681                 g_free(transfer_info.filename);
1682         }
1683 }
1684
1685 void __bt_opp_server_event_filter(GDBusConnection *connection,
1686                                                  const gchar *sender_name,
1687                                                  const gchar *object_path,
1688                                                  const gchar *interface_name,
1689                                                  const gchar *signal_name,
1690                                                  GVariant *parameters,
1691                                                  gpointer user_data)
1692 {
1693         bt_event_info_t *event_info;
1694         int result = BLUETOOTH_ERROR_NONE;
1695         event_info = (bt_event_info_t *)user_data;
1696         ret_if(event_info == NULL);
1697
1698         if (strcasecmp(object_path, BT_OPP_SERVER_PATH) != 0)
1699                 return;
1700         if (strcasecmp(interface_name, BT_EVENT_SERVICE) != 0)
1701                 return;
1702
1703         ret_if(signal_name == NULL);
1704
1705         if (strcasecmp(signal_name, BT_TRANSFER_AUTHORIZED) == 0) {
1706                 /* Native only event */
1707                 const char *file_name = NULL;
1708                 guint64 size = 0;
1709                 bt_obex_server_authorize_into_t auth_info;
1710
1711                 g_variant_get(parameters, "(i&st)", &result, &file_name, &size);
1712
1713                 /* OSP server: Don't get this event */
1714                 ret_if(obex_server_id == BT_CUSTOM_SERVER);
1715
1716                 memset(&auth_info, 0x00, sizeof(bt_obex_server_authorize_into_t));
1717
1718                 auth_info.filename = g_strdup(file_name);
1719                 auth_info.length = size;
1720
1721                 _bt_common_event_cb(BLUETOOTH_EVENT_OBEX_SERVER_TRANSFER_AUTHORIZE,
1722                                 result, &auth_info,
1723                                 event_info->cb, event_info->user_data);
1724
1725                 g_free(auth_info.filename);
1726         } else if (strcasecmp(signal_name, BT_CONNECTION_AUTHORIZED) == 0) {
1727                 /* OSP only event */
1728                 const char *address = NULL;
1729                 const char *name = NULL;
1730                 bluetooth_device_address_t dev_address = { {0} };
1731
1732                 g_variant_get(parameters, "(i&s&s)", &result, &address, &name);
1733
1734                 /* Native server: Don't get this event */
1735                 ret_if(obex_server_id == BT_NATIVE_SERVER);
1736
1737                 _bt_convert_addr_string_to_type(dev_address.addr,
1738                                                 address);
1739
1740                 _bt_common_event_cb(BLUETOOTH_EVENT_OBEX_SERVER_CONNECTION_AUTHORIZE,
1741                                 result, &dev_address,
1742                                 event_info->cb, event_info->user_data);
1743         } else if (strcasecmp(signal_name, BT_TRANSFER_CONNECTED) == 0) {
1744
1745                 g_variant_get(parameters, "(i)", &result);
1746
1747                 _bt_common_event_cb(BLUETOOTH_EVENT_OBEX_SERVER_TRANSFER_CONNECTED,
1748                                         result, NULL, event_info->cb,
1749                                         event_info->user_data);
1750         } else if (strcasecmp(signal_name, BT_TRANSFER_DISCONNECTED) == 0) {
1751
1752                 g_variant_get(parameters, "(i)", &result);
1753
1754                 _bt_common_event_cb(BLUETOOTH_EVENT_OBEX_SERVER_TRANSFER_DISCONNECTED,
1755                                         result, NULL, event_info->cb,
1756                                         event_info->user_data);
1757         } else if (strcasecmp(signal_name, BT_TRANSFER_STARTED) == 0) {
1758                 const char *file_name = NULL;
1759                 const char *type = NULL;
1760                 int transfer_id = 0;
1761                 int server_type = 0; /* bt_server_type_t */
1762                 guint64 size = 0;
1763                 bt_obex_server_transfer_info_t transfer_info;
1764
1765                 g_variant_get(parameters, "(i&s&stii)", &result, &file_name,
1766                                 &type, &size, &transfer_id, &server_type);
1767
1768                 /* Other server's event */
1769                 ret_if(obex_server_id != server_type &&
1770                         server_type != BT_FTP_SERVER);
1771
1772                 memset(&transfer_info, 0x00, sizeof(bt_obex_server_transfer_info_t));
1773
1774                 transfer_info.filename = g_strdup(file_name);
1775                 transfer_info.type = g_strdup(type);
1776                 transfer_info.file_size = size;
1777                 transfer_info.transfer_id = transfer_id;
1778                 transfer_info.server_type = (server_type == BT_FTP_SERVER) ?
1779                                                 FTP_SERVER : OPP_SERVER;
1780
1781                 _bt_common_event_cb(BLUETOOTH_EVENT_OBEX_SERVER_TRANSFER_STARTED,
1782                                 result, &transfer_info,
1783                                 event_info->cb, event_info->user_data);
1784
1785                 g_free(transfer_info.filename);
1786                 g_free(transfer_info.type);
1787         } else if (strcasecmp(signal_name, BT_TRANSFER_PROGRESS) == 0) {
1788                 const char *file_name = NULL;
1789                 const char *type = NULL;
1790                 int transfer_id = 0;
1791                 int progress = 0;
1792                 int server_type = 0; /* bt_server_type_t */
1793                 guint64 size = 0;
1794                 bt_obex_server_transfer_info_t transfer_info;
1795
1796                 g_variant_get(parameters, "(i&s&stiii)", &result, &file_name,
1797                                                 &type, &size, &transfer_id,
1798                                                 &progress, &server_type);
1799
1800                 /* Other server's event */
1801                 ret_if(obex_server_id != server_type &&
1802                         server_type != BT_FTP_SERVER);
1803
1804                 memset(&transfer_info, 0x00, sizeof(bt_obex_server_transfer_info_t));
1805
1806                 transfer_info.filename = g_strdup(file_name);
1807                 transfer_info.type = g_strdup(type);
1808                 transfer_info.file_size = size;
1809                 transfer_info.transfer_id = transfer_id;
1810                 transfer_info.percentage = progress;
1811                 transfer_info.server_type = (server_type == BT_FTP_SERVER) ?
1812                                                 FTP_SERVER : OPP_SERVER;
1813
1814                 _bt_common_event_cb(BLUETOOTH_EVENT_OBEX_SERVER_TRANSFER_PROGRESS,
1815                                 result, &transfer_info,
1816                                 event_info->cb, event_info->user_data);
1817
1818                 g_free(transfer_info.filename);
1819                 g_free(transfer_info.type);
1820         } else if (strcasecmp(signal_name, BT_TRANSFER_COMPLETED) == 0) {
1821                 const char *file_name = NULL;
1822                 const char *device_name = NULL;
1823                 const char *type = NULL;
1824                 const char *file_path;
1825                 int transfer_id = 0;
1826                 int server_type = 0; /* bt_server_type_t */
1827                 guint64 size = 0;
1828                 bt_obex_server_transfer_info_t transfer_info;
1829
1830                 g_variant_get(parameters, "(i&s&s&s&stii)", &result, &file_name,
1831                                         &type, &device_name, &file_path, &size,
1832                                         &transfer_id, &server_type);
1833
1834                 /* Other server's event */
1835                 ret_if(obex_server_id != server_type &&
1836                         server_type != BT_FTP_SERVER);
1837
1838                 memset(&transfer_info, 0x00, sizeof(bt_obex_server_transfer_info_t));
1839
1840                 transfer_info.filename = g_strdup(file_name);
1841                 transfer_info.type = g_strdup(type);
1842                 transfer_info.device_name = g_strdup(device_name);
1843                 transfer_info.file_path = g_strdup(file_path);
1844                 transfer_info.file_size = size;
1845                 transfer_info.transfer_id = transfer_id;
1846                 transfer_info.server_type = (server_type == BT_FTP_SERVER) ?
1847                                                 FTP_SERVER : OPP_SERVER;
1848
1849                 _bt_common_event_cb(BLUETOOTH_EVENT_OBEX_SERVER_TRANSFER_COMPLETED,
1850                                 result, &transfer_info,
1851                                 event_info->cb, event_info->user_data);
1852
1853                 g_free(transfer_info.filename);
1854                 g_free(transfer_info.type);
1855                 g_free(transfer_info.device_name);
1856                 g_free(transfer_info.file_path);
1857         }
1858 }
1859
1860 void __bt_pbap_client_event_filter(GDBusConnection *connection,
1861                                                  const gchar *sender_name,
1862                                                  const gchar *object_path,
1863                                                  const gchar *interface_name,
1864                                                  const gchar *signal_name,
1865                                                  GVariant *parameters,
1866                                                  gpointer user_data)
1867 {
1868         bt_event_info_t *event_info;
1869         int result = BLUETOOTH_ERROR_NONE;
1870         event_info = (bt_event_info_t *)user_data;
1871         ret_if(event_info == NULL);
1872
1873         if (strcasecmp(object_path, BT_PBAP_CLIENT_PATH) != 0)
1874                 return;
1875         if (strcasecmp(interface_name, BT_EVENT_SERVICE) != 0)
1876                 return;
1877
1878         ret_if(signal_name == NULL);
1879         BT_DBG("Type: %s", g_variant_get_type_string(parameters));
1880         if (strcasecmp(signal_name, BT_PBAP_CONNECTED) == 0) {
1881                 bt_pbap_connected_t connected = { { { 0 }, }, };
1882                 char *address = NULL;
1883
1884                 g_variant_get(parameters, "(is)", &result, &address);
1885                 BT_DBG("address: %s", address);
1886
1887                 _bt_convert_addr_string_to_type(connected.btaddr.addr,
1888                                                 address);
1889                 if (result == 0)
1890                         connected.connected = 1;
1891                 else
1892                         connected.connected = 0;
1893
1894                 _bt_common_event_cb(BLUETOOTH_PBAP_CONNECTED,
1895                                 result, &connected,
1896                                 event_info->cb, event_info->user_data);
1897         } else if (strcasecmp(signal_name, BT_PBAP_DISCONNECTED) == 0) {
1898                 bt_pbap_connected_t disconnected = { { { 0 }, }, };
1899                 char *address = NULL;
1900
1901                 g_variant_get(parameters, "(is)", &result, &address);
1902                 BT_DBG("address: %s", address);
1903
1904                 _bt_convert_addr_string_to_type(disconnected.btaddr.addr,
1905                                                 address);
1906                 disconnected.connected = 0;
1907
1908                 _bt_common_event_cb(BLUETOOTH_PBAP_CONNECTED,
1909                                 result, &disconnected,
1910                                 event_info->cb, event_info->user_data);
1911         } else if (strcasecmp(signal_name, BT_PBAP_PHONEBOOK_SIZE) == 0) {
1912                 bt_pbap_phonebook_size_t pb_size = { { { 0 }, }, };
1913                 char *address = NULL;
1914                 int size = 0;
1915
1916                 g_variant_get(parameters, "(isi)", &result, &address, &size);
1917
1918                 BT_DBG("address: %s", address);
1919                 BT_DBG("size: %d", size);
1920
1921                 _bt_convert_addr_string_to_type(pb_size.btaddr.addr,
1922                                                 address);
1923                 pb_size.size = size;
1924
1925                 _bt_common_event_cb(BLUETOOTH_PBAP_PHONEBOOK_SIZE,
1926                                 result, &pb_size,
1927                                 event_info->cb, event_info->user_data);
1928         } else if (strcasecmp(signal_name, BT_PBAP_PHONEBOOK_PULL) == 0) {
1929                 bt_pbap_phonebook_pull_t pb_pull = { { { 0 } }, };
1930                 char *address = NULL;
1931                 char *vcf_file = NULL;
1932                 int success = -1;
1933
1934                 g_variant_get(parameters, "(issi)", &result, &address, &vcf_file, &success);
1935
1936                 BT_DBG("address: %s", address);
1937                 BT_DBG("vcf_file: %s", vcf_file);
1938                 BT_DBG("success: %d", success);
1939
1940                 _bt_convert_addr_string_to_type(pb_pull.btaddr.addr,
1941                                                 address);
1942                 pb_pull.vcf_file = vcf_file;
1943                 pb_pull.success = success;
1944                 _bt_common_event_cb(BLUETOOTH_PBAP_PHONEBOOK_PULL,
1945                                 result, &pb_pull,
1946                                 event_info->cb, event_info->user_data);
1947         } else if (strcasecmp(signal_name, BT_PBAP_VCARD_LIST) == 0) {
1948                 bt_pbap_vcard_list_t vc_list = { { { 0 } }, };
1949                 char *address = NULL;
1950                 gsize count = 0;
1951                 gchar **list = NULL;
1952                 GVariant *string_var;
1953                 int success = -1;
1954                 int i = 0;
1955
1956                 g_variant_get(parameters, "(isv)", &result, &address, &string_var);
1957
1958                 list = (gchar **)g_variant_get_strv(string_var, &count);
1959
1960                 success = !result;
1961                 BT_DBG("address: %s", address);
1962                 BT_DBG("result: %d", result);
1963                 BT_DBG("count: %d", count);
1964                 for(i = 0; i < count; i++)
1965                         BT_DBG("%s", list[i]);
1966                 BT_DBG("success: %d", success);
1967
1968                 _bt_convert_addr_string_to_type(vc_list.btaddr.addr,
1969                                                 address);
1970                 vc_list.vcards = list;
1971                 vc_list.length = count;
1972                 vc_list.success = success;
1973                 _bt_common_event_cb(BLUETOOTH_PBAP_VCARD_LIST,
1974                                 result, &vc_list,
1975                                 event_info->cb, event_info->user_data);
1976
1977                 g_variant_unref(string_var);
1978                 //free lists
1979         } else if (strcasecmp(signal_name, BT_PBAP_VCARD_PULL) == 0) {
1980                 bt_pbap_vcard_pull_t vc_pull = { { { 0 } }, };
1981                 char *address = NULL;
1982                 char *vcf_file = NULL;
1983                 int success = -1;
1984
1985                 g_variant_get(parameters, "(issi)", &result, &address, &vcf_file, &success);
1986
1987                 BT_DBG("address: %s", address);
1988                 BT_DBG("vcf_file: %s", vcf_file);
1989                 BT_DBG("success: %d", success);
1990
1991                 _bt_convert_addr_string_to_type(vc_pull.btaddr.addr,
1992                                                 address);
1993                 vc_pull.vcf_file = vcf_file;
1994                 vc_pull.success = success;
1995                 _bt_common_event_cb(BLUETOOTH_PBAP_VCARD_PULL,
1996                                 result, &vc_pull,
1997                                 event_info->cb, event_info->user_data);
1998         } else if (strcasecmp(signal_name, BT_PBAP_SEARCH_PHONEBOOK) == 0) {
1999                 bt_pbap_phonebook_search_list_t vc_list = { { { 0 } }, };
2000                 char *address = NULL;
2001                 gsize count = 0;
2002                 gchar **list = NULL;
2003                 GVariant *string_var;
2004                 int success = -1;
2005                 int i = 0;
2006
2007                 g_variant_get(parameters, "(is@as)", &result, &address, &string_var);
2008
2009                 list = (gchar **)g_variant_get_strv(string_var, &count);
2010                 success = !result;
2011                 BT_DBG("address: %s", address);
2012                 for(i = 0; i < count; i++)
2013                         BT_DBG("%s", list[i]);
2014                 BT_DBG("success: %d", success);
2015
2016                 _bt_convert_addr_string_to_type(vc_list.btaddr.addr,
2017                                                 address);
2018                 vc_list.vcards = list;
2019                 vc_list.length = count;
2020                 vc_list.success = success;
2021                 _bt_common_event_cb(BLUETOOTH_PBAP_PHONEBOOK_SEARCH,
2022                                 result, &vc_list,
2023                                 event_info->cb, event_info->user_data);
2024
2025                 g_variant_unref(string_var);
2026                 //free lists
2027         }
2028 }
2029
2030 void __bt_rfcomm_client_event_filter(GDBusConnection *connection,
2031                                                  const gchar *sender_name,
2032                                                  const gchar *object_path,
2033                                                  const gchar *interface_name,
2034                                                  const gchar *signal_name,
2035                                                  GVariant *parameters,
2036                                                  gpointer user_data)
2037 {
2038         bt_event_info_t *event_info;
2039         int result = BLUETOOTH_ERROR_NONE;
2040         event_info = (bt_event_info_t *)user_data;
2041         ret_if(event_info == NULL);
2042
2043         if (strcasecmp(object_path, BT_RFCOMM_CLIENT_PATH) != 0)
2044                 return;
2045         if (strcasecmp(interface_name, BT_EVENT_SERVICE) != 0)
2046                 return;
2047
2048         ret_if(signal_name == NULL);
2049
2050         if (strcasecmp(signal_name, BT_RFCOMM_CONNECTED) == 0) {
2051                 const char *address = NULL;
2052                 const char *uuid = NULL;
2053                 int socket_fd = 0;
2054                 bluetooth_rfcomm_connection_t conn_info;
2055
2056                 g_variant_get(parameters, "(i&s&sn)", &result, &address,
2057                                                         &uuid, &socket_fd);
2058
2059                 memset(&conn_info, 0x00, sizeof(bluetooth_rfcomm_connection_t));
2060                 conn_info.device_role = RFCOMM_ROLE_CLIENT;
2061                 g_strlcpy(conn_info.uuid, uuid, BLUETOOTH_UUID_STRING_MAX);
2062                 conn_info.socket_fd = socket_fd;
2063                 _bt_convert_addr_string_to_type(conn_info.device_addr.addr,
2064                                                 address);
2065
2066                 _bt_common_event_cb(BLUETOOTH_EVENT_RFCOMM_CONNECTED,
2067                                 result, &conn_info,
2068                                 event_info->cb, event_info->user_data);
2069         } else if (strcasecmp(signal_name, BT_RFCOMM_DISCONNECTED) == 0) {
2070                 const char *address = NULL;
2071                 const char *uuid = NULL;
2072                 int socket_fd = 0;
2073                 bluetooth_rfcomm_disconnection_t disconn_info;
2074
2075                 g_variant_get(parameters, "(i&s&sn)", &result, &address,
2076                                                                 &uuid, &socket_fd);
2077
2078                 memset(&disconn_info, 0x00, sizeof(bluetooth_rfcomm_disconnection_t));
2079                 disconn_info.device_role = RFCOMM_ROLE_CLIENT;
2080                 g_strlcpy(disconn_info.uuid, uuid, BLUETOOTH_UUID_STRING_MAX);
2081                 disconn_info.socket_fd = socket_fd;
2082                 _bt_convert_addr_string_to_type(disconn_info.device_addr.addr,
2083                                                 address);
2084
2085                 _bt_common_event_cb(BLUETOOTH_EVENT_RFCOMM_DISCONNECTED,
2086                                 result, &disconn_info,
2087                                 event_info->cb, event_info->user_data);
2088         } else if (strcasecmp(signal_name, BT_RFCOMM_DATA_RECEIVED) == 0) {
2089                 char *buffer;
2090                 int buffer_len = 0;
2091                 int socket_fd = 0;
2092                 bluetooth_rfcomm_received_data_t data_r;
2093                 GVariant *byte_var;
2094
2095                 g_variant_get(parameters, "(in@ay)", &result, &socket_fd,
2096                                                                 &byte_var);
2097
2098                 buffer_len = g_variant_get_size( byte_var);
2099                 buffer = (char *) g_variant_get_data(byte_var);
2100
2101                 data_r.socket_fd = socket_fd;
2102                 data_r.buffer_size = buffer_len;
2103                 data_r.buffer = buffer;
2104
2105                 _bt_common_event_cb(BLUETOOTH_EVENT_RFCOMM_DATA_RECEIVED,
2106                                 result, &data_r,
2107                                 event_info->cb, event_info->user_data);
2108                 g_variant_unref(byte_var);
2109         }
2110 }
2111
2112 void __bt_rfcomm_server_event_filter(GDBusConnection *connection,
2113                                                  const gchar *sender_name,
2114                                                  const gchar *object_path,
2115                                                  const gchar *interface_name,
2116                                                  const gchar *signal_name,
2117                                                  GVariant *parameters,
2118                                                  gpointer user_data)
2119 {
2120         bt_event_info_t *event_info;
2121         int result = BLUETOOTH_ERROR_NONE;
2122         event_info = (bt_event_info_t *)user_data;
2123         ret_if(event_info == NULL);
2124
2125         if (strcasecmp(object_path, BT_RFCOMM_SERVER_PATH) != 0)
2126                 return;
2127         if (strcasecmp(interface_name, BT_EVENT_SERVICE) != 0)
2128                 return;
2129
2130         ret_if(signal_name == NULL);
2131
2132         if (strcasecmp(signal_name, BT_RFCOMM_CONNECTED) == 0) {
2133                 const char *address = NULL;
2134                 const char *uuid = NULL;
2135                 int socket_fd = 0;
2136                 bluetooth_rfcomm_connection_t conn_info;
2137
2138                 g_variant_get(parameters, "(i&s&sn)", &result, &address,
2139                                                         &uuid, &socket_fd);
2140
2141                 memset(&conn_info, 0x00, sizeof(bluetooth_rfcomm_connection_t));
2142                 conn_info.device_role = RFCOMM_ROLE_SERVER;
2143                 g_strlcpy(conn_info.uuid, uuid, BLUETOOTH_UUID_STRING_MAX);
2144                 conn_info.socket_fd = socket_fd;
2145                 _bt_convert_addr_string_to_type(conn_info.device_addr.addr,
2146                                                 address);
2147
2148                 _bt_common_event_cb(BLUETOOTH_EVENT_RFCOMM_CONNECTED,
2149                                 result, &conn_info,
2150                                 event_info->cb, event_info->user_data);
2151         } else if (strcasecmp(signal_name, BT_RFCOMM_DISCONNECTED) == 0) {
2152                 const char *address = NULL;
2153                 const char *uuid = NULL;
2154                 int socket_fd = 0;
2155                 bluetooth_rfcomm_disconnection_t disconn_info;
2156
2157                 g_variant_get(parameters, "(i&s&sn)", &result, &address,
2158                                                                 &uuid, &socket_fd);
2159
2160                 memset(&disconn_info, 0x00, sizeof(bluetooth_rfcomm_disconnection_t));
2161                 disconn_info.device_role = RFCOMM_ROLE_SERVER;
2162                 g_strlcpy(disconn_info.uuid, uuid, BLUETOOTH_UUID_STRING_MAX);
2163                 disconn_info.socket_fd = socket_fd;
2164                 _bt_convert_addr_string_to_type(disconn_info.device_addr.addr,
2165                                                 address);
2166
2167                 _bt_common_event_cb(BLUETOOTH_EVENT_RFCOMM_DISCONNECTED,
2168                                 result, &disconn_info,
2169                                 event_info->cb, event_info->user_data);
2170         } else if (strcasecmp(signal_name, BT_CONNECTION_AUTHORIZED) == 0) {
2171                 /* OSP only event */
2172                 bluetooth_rfcomm_connection_request_t req_ind;
2173                 char *address = NULL;
2174                 char *uuid = NULL;
2175                 char *name = NULL;
2176                 char *path = NULL;
2177                 int socket_fd = 0;
2178
2179                 g_variant_get(parameters, "(i&s&s&s&sn)", &result, &address,
2180                                                 &uuid, &name, &path, &socket_fd);
2181
2182                 if (_check_uuid_path(path, uuid) == FALSE)
2183                         return;
2184
2185                 memset(&req_ind, 0x00, sizeof(bluetooth_rfcomm_connection_request_t));
2186                 _bt_convert_addr_string_to_type(req_ind.device_addr.addr,
2187                                                 address);
2188
2189                 req_ind.socket_fd = socket_fd;
2190
2191                 _bt_common_event_cb(BLUETOOTH_EVENT_RFCOMM_AUTHORIZE,
2192                                 result, &req_ind,
2193                                 event_info->cb, event_info->user_data);
2194         } else if (strcasecmp(signal_name, BT_RFCOMM_SERVER_REMOVED) == 0) {
2195                 /* OSP only event */
2196                 int socket_fd = 0;
2197
2198                 g_variant_get(parameters, "(in)", &result, &socket_fd);
2199
2200                 ret_if(__bt_is_server_exist(socket_fd) == FALSE);
2201
2202                 _bt_remove_server(socket_fd);
2203         } else if (strcasecmp(signal_name, BT_RFCOMM_DATA_RECEIVED) == 0) {
2204                 char *buffer = NULL;
2205                 int buffer_len = 0;
2206                 int socket_fd = 0;
2207                 bluetooth_rfcomm_received_data_t data_r;
2208                 GVariant *byte_var;
2209
2210                 g_variant_get(parameters, "(in@ay)", &result,
2211                                                 &socket_fd, &byte_var);
2212
2213                 buffer_len = g_variant_get_size( byte_var);
2214                 buffer = (char *) g_variant_get_data(byte_var);
2215
2216                 data_r.socket_fd = socket_fd;
2217                 data_r.buffer_size = buffer_len;
2218                 data_r.buffer = buffer;
2219
2220                 _bt_common_event_cb(BLUETOOTH_EVENT_RFCOMM_DATA_RECEIVED,
2221                                 result, &data_r,
2222                                 event_info->cb, event_info->user_data);
2223                 g_variant_unref(byte_var);
2224         }
2225 }
2226
2227 void __bt_hf_agent_event_filter(GDBusConnection *connection,
2228                                                  const gchar *sender_name,
2229                                                  const gchar *object_path,
2230                                                  const gchar *interface_name,
2231                                                  const gchar *signal_name,
2232                                                  GVariant *parameters,
2233                                                  gpointer user_data)
2234 {
2235         BT_DBG("+\n");
2236
2237         bt_event_info_t *event_info;
2238         int result = BLUETOOTH_ERROR_NONE;
2239         event_info = (bt_event_info_t *)user_data;
2240         ret_if(event_info == NULL);
2241
2242         BT_DBG("+\n");
2243         if (strcasecmp(object_path, BT_HF_AGENT_PATH) != 0)
2244                 return;
2245         if (strcasecmp(interface_name, BT_HF_SERVICE_INTERFACE) != 0)
2246                 return;
2247
2248         ret_if(signal_name == NULL);
2249
2250         BT_DBG("%s",signal_name);
2251         if (strcasecmp(signal_name, "Connected") == 0) {
2252                 char *address = NULL;
2253
2254                 g_variant_get(parameters, "(s)", &address);
2255                 _bt_hf_event_cb(BLUETOOTH_EVENT_HF_CONNECTED,
2256                                 result, address,
2257                                 event_info->cb, event_info->user_data);
2258         } else if (strcasecmp(signal_name, "Disconnected") == 0) {
2259                 char *address = NULL;
2260
2261                 g_variant_get(parameters, "(s)", &address);
2262                 _bt_hf_event_cb(BLUETOOTH_EVENT_HF_DISCONNECTED,
2263                                 result, address,
2264                                 event_info->cb, event_info->user_data);
2265         } else if (strcasecmp(signal_name, "AudioConnected") == 0) {
2266                 _bt_hf_event_cb(BLUETOOTH_EVENT_HF_AUDIO_CONNECTED,
2267                                 result, NULL,
2268                                 event_info->cb, event_info->user_data);
2269         } else if (strcasecmp(signal_name, "AudioDisconnected") == 0) {
2270                 _bt_hf_event_cb(BLUETOOTH_EVENT_HF_AUDIO_DISCONNECTED,
2271                                 result, NULL,
2272                                 event_info->cb, event_info->user_data);
2273         } else if (strcasecmp(signal_name, "Ring") == 0) {
2274                 char *phoneno = NULL;
2275
2276                 g_variant_get(parameters, "(&s)", &phoneno);
2277
2278                 _bt_hf_event_cb(BLUETOOTH_EVENT_HF_RING_INDICATOR,
2279                                 result, phoneno,
2280                                 event_info->cb, event_info->user_data);
2281         } else if (strcasecmp(signal_name, "CallWaiting") == 0) {
2282                 char *phoneno = NULL;
2283
2284                 g_variant_get(parameters, "(&s)", &phoneno);
2285
2286                 _bt_hf_event_cb(BLUETOOTH_EVENT_HF_CALL_WAITING,
2287                                 result, phoneno,
2288                                 event_info->cb, event_info->user_data);
2289         }  else if (strcasecmp(signal_name, "CallTerminated") == 0) {
2290                 _bt_hf_event_cb(BLUETOOTH_EVENT_HF_CALL_TERMINATED,
2291                                 result, NULL,
2292                                 event_info->cb, event_info->user_data);
2293         } else if (strcasecmp(signal_name, "CallStarted") == 0) {
2294                 _bt_hf_event_cb(BLUETOOTH_EVENT_HF_CALL_STARTED,
2295                                 result, NULL,
2296                                 event_info->cb, event_info->user_data);
2297         } else if (strcasecmp(signal_name, "CallEnded") == 0) {
2298                 _bt_hf_event_cb(BLUETOOTH_EVENT_HF_CALL_ENDED,
2299                                 result, NULL,
2300                                 event_info->cb, event_info->user_data);
2301         }  else if (strcasecmp(signal_name, "NoCallsHeld") == 0) {
2302                 _bt_hf_event_cb(BLUETOOTH_EVENT_HF_CALL_UNHOLD,
2303                                 result, NULL,
2304                                 event_info->cb, event_info->user_data);
2305         } else if (strcasecmp(signal_name, "CallsSwapped") == 0) {
2306                 _bt_hf_event_cb(BLUETOOTH_EVENT_HF_CALL_SWAPPED,
2307                                 result, NULL,
2308                                 event_info->cb, event_info->user_data);
2309         } else if (strcasecmp(signal_name, "CallOnHold") == 0) {
2310                 _bt_hf_event_cb(BLUETOOTH_EVENT_HF_CALL_ON_HOLD,
2311                                 result, NULL,
2312                                 event_info->cb, event_info->user_data);
2313         } else if (strcasecmp(signal_name, "CallStatusUpdate") == 0) {
2314                 int call_count;
2315                 GVariant *var_data = NULL;
2316                 char *number = NULL;
2317                 int idx, dir, status, mpart;
2318                 bt_hf_call_list_s *handle = NULL;
2319
2320                 g_variant_get(parameters, "(i@a(siiii))", &call_count,
2321                                                                 &var_data);
2322                 BT_DBG("call count : %d",call_count);
2323
2324                 if (var_data){
2325                         GVariantIter *iter = NULL;
2326                         __bt_call_list_create(&handle);
2327
2328                         g_variant_get(var_data, "a(siiii)", &iter);
2329                         while (g_variant_iter_loop(iter, "(siiii)", &number,
2330                                                 &dir, &status, &mpart, &idx)) {
2331                                 BT_DBG("call number:%s, dir:%d, status : %d",
2332                                                         number, dir, status);
2333                                 BT_DBG("call mpart : %d, idx : %d",mpart, idx);
2334                                 __bt_call_list_add(handle, number, dir,
2335                                                         status, mpart, idx);
2336                         }
2337                         g_variant_iter_free(iter);
2338                         g_variant_unref(var_data);
2339                 }
2340
2341                 if (handle && (call_count == g_list_length(handle->list))) {
2342                         handle->count = call_count;
2343                         _bt_hf_event_cb(BLUETOOTH_EVENT_HF_CALL_STATUS,
2344                                         result, handle,
2345                                         event_info->cb, event_info->user_data);
2346                 } else {
2347                         BT_ERR(" Mismatch in call count : %d",call_count);
2348                 }
2349
2350                 __bt_call_list_destroy(handle);
2351         } else if (strcasecmp(signal_name, "VoiceRecognition") == 0) {
2352                 int status;
2353                 g_variant_get(parameters, "(i)", &status);
2354                 BT_DBG("status = [%d]\n", status);
2355                 if (status)
2356                         _bt_hf_event_cb(BLUETOOTH_EVENT_HF_VOICE_RECOGNITION_ENABLED,
2357                                         result, NULL,
2358                                         event_info->cb, event_info->user_data);
2359                 else
2360                         _bt_hf_event_cb(BLUETOOTH_EVENT_HF_VOICE_RECOGNITION_DISABLED,
2361                                         result, NULL,
2362                                         event_info->cb, event_info->user_data);
2363         } else if (strcasecmp(signal_name, "VolumeSpeaker") == 0) {
2364                 int value;
2365                 g_variant_get(parameters, "(i)", &value);
2366                 BT_DBG("Value = [%d]\n", value);
2367                         _bt_hf_event_cb(BLUETOOTH_EVENT_HF_VOLUME_SPEAKER,
2368                                         result, &value,
2369                                         event_info->cb, event_info->user_data);
2370         } else if (strcasecmp(signal_name, "SamsungXSAT") == 0) {
2371                 int value = 0;
2372                 char *msg = NULL;
2373                 bluetooth_vendor_dep_at_cmd_t cmd;
2374                 g_variant_get(parameters, "(i&s)", &value, &msg);
2375                 BT_DBG("Value = [%d], message = %s\n", value, msg);
2376                 cmd.app_id =  value;
2377                 cmd.message = msg;
2378                 _bt_hf_event_cb(BLUETOOTH_EVENT_HF_VENDOR_DEP_CMD,
2379                                 result, &cmd,
2380                                 event_info->cb, event_info->user_data);
2381         }
2382         BT_DBG("-\n");
2383 }
2384
2385 static void __bt_remove_all_events(void)
2386 {
2387         GSList *l;
2388         bt_event_info_t *info;
2389
2390         for (l = event_list; l != NULL; l = g_slist_next(l)) {
2391                 info = l->data;
2392
2393                 if (info)
2394                         _bt_unregister_event(info->event_type);
2395         }
2396
2397         g_slist_free(event_list);
2398         event_list = NULL;
2399 }
2400
2401 static gboolean __bt_event_is_registered(int event_type)
2402 {
2403         GSList *l;
2404         bt_event_info_t *info;
2405
2406         for (l = event_list; l != NULL; l = g_slist_next(l)) {
2407                 info = l->data;
2408                 if (info == NULL)
2409                         continue;
2410
2411                 if (info->event_type == event_type)
2412                         return TRUE;
2413         }
2414
2415         return FALSE;
2416 }
2417
2418 bt_event_info_t *_bt_event_get_cb_data(int event_type)
2419 {
2420         GSList *l;
2421         bt_event_info_t *info;
2422
2423         for (l = event_list; l != NULL; l = g_slist_next(l)) {
2424                 info = l->data;
2425                 if (info == NULL)
2426                         continue;
2427
2428                 if (info->event_type == event_type)
2429                         return info;
2430         }
2431
2432         return NULL;
2433 }
2434
2435 void _bt_add_server(int server_fd)
2436 {
2437         bt_server_info_t *info;
2438
2439         info = g_new0(bt_server_info_t, 1);
2440         info->server_fd = server_fd;
2441
2442         server_list = g_slist_append(server_list, info);
2443 }
2444
2445 void _bt_remove_server(int server_fd)
2446 {
2447         GSList *l;
2448         bt_server_info_t *info;
2449
2450         for (l = server_list; l != NULL; l = g_slist_next(l)) {
2451                 info = l->data;
2452                 if (info == NULL)
2453                         continue;
2454
2455                 if (info->server_fd == server_fd) {
2456                         server_list = g_slist_remove(server_list, (void *)info);
2457                 }
2458
2459                 g_free(info);
2460         }
2461 }
2462
2463 void _bt_set_obex_server_id(int server_type)
2464 {
2465         obex_server_id = server_type;
2466 }
2467
2468 int _bt_get_obex_server_id(void)
2469 {
2470         return obex_server_id;
2471 }
2472
2473 int _bt_init_event_handler(void)
2474 {
2475         if (is_initialized == TRUE) {
2476                 BT_ERR("Connection already exist");
2477                 return BLUETOOTH_ERROR_ALREADY_INITIALIZED;
2478         }
2479
2480         __bt_remove_all_events();
2481
2482         is_initialized = TRUE;
2483
2484         return BLUETOOTH_ERROR_NONE;
2485 }
2486
2487 int _bt_deinit_event_handler(void)
2488 {
2489         if (is_initialized == FALSE) {
2490                 BT_ERR("Connection dose not exist");
2491                 return BLUETOOTH_ERROR_INTERNAL;
2492         }
2493
2494         __bt_remove_all_events();
2495
2496         if (disable_timer_id > 0) {
2497                 g_source_remove(disable_timer_id);
2498                 disable_timer_id = 0;
2499         }
2500
2501         is_initialized = FALSE;
2502
2503         return BLUETOOTH_ERROR_NONE;
2504 }
2505
2506 static void __bt_event_data_free(void *data)
2507 {
2508         bt_event_info_t *cb_data = data;
2509
2510         ret_if(cb_data == NULL);
2511
2512         g_free(cb_data);
2513 }
2514
2515 int _bt_register_event(int event_type, void *event_cb, void *user_data)
2516 {
2517         GDBusConnection *connection_type;
2518         GDBusSignalCallback event_func;
2519         bt_event_info_t *cb_data;
2520         const char *path;
2521         const char *interface = BT_EVENT_SERVICE;
2522
2523         if (is_initialized == FALSE)
2524                 _bt_init_event_handler();
2525
2526         if (__bt_event_is_registered(event_type) == TRUE) {
2527                 BT_ERR("The event is already registed");
2528                 return BLUETOOTH_ERROR_ALREADY_INITIALIZED;
2529         }
2530
2531         switch (event_type) {
2532         case BT_ADAPTER_EVENT:
2533                 event_func = __bt_adapter_event_filter;
2534                 path = BT_ADAPTER_PATH;
2535                 break;
2536         case BT_LE_ADAPTER_EVENT:
2537                 event_func = __bt_adapter_le_event_filter;
2538                 path = BT_LE_ADAPTER_PATH;
2539                 break;
2540         case BT_DEVICE_EVENT:
2541                 event_func = __bt_device_event_filter;
2542                 path = BT_DEVICE_PATH;
2543                 break;
2544         case BT_HID_EVENT:
2545                 event_func = __bt_hid_event_filter;
2546                 path = BT_HID_PATH;
2547                 break;
2548         case BT_HEADSET_EVENT:
2549                 event_func = __bt_headset_event_filter;
2550                 path = BT_HEADSET_PATH;
2551                 break;
2552         case BT_NETWORK_EVENT:
2553                 event_func = __bt_network_event_filter;
2554                 path = BT_NETWORK_PATH;
2555                 break;
2556         case BT_AVRCP_EVENT:
2557                 event_func = __bt_avrcp_event_filter;
2558                 path = BT_AVRCP_PATH;
2559                 break;
2560         case BT_AVRCP_CONTROL_EVENT:
2561                 event_func = __bt_avrcp_control_event_filter;
2562                 path = BT_AVRCP_CONTROL_PATH;
2563                 break;
2564         case BT_OPP_CLIENT_EVENT:
2565                 event_func = __bt_opp_client_event_filter;
2566                 path = BT_OPP_CLIENT_PATH;
2567                 break;
2568         case BT_OPP_SERVER_EVENT:
2569                 event_func = __bt_opp_server_event_filter;
2570                 path = BT_OPP_SERVER_PATH;
2571                 break;
2572         case BT_PBAP_CLIENT_EVENT:
2573                 event_func = __bt_pbap_client_event_filter;
2574                 path = BT_PBAP_CLIENT_PATH;
2575                 break;
2576         case BT_RFCOMM_CLIENT_EVENT:
2577                 event_func = __bt_rfcomm_client_event_filter;
2578                 path = BT_RFCOMM_CLIENT_PATH;
2579                 break;
2580         case BT_RFCOMM_SERVER_EVENT:
2581                 event_func = __bt_rfcomm_server_event_filter;
2582                 path = BT_RFCOMM_SERVER_PATH;
2583                 break;
2584         case BT_HF_AGENT_EVENT:
2585                 BT_DBG("BT_HF_AGENT_EVENT\n");
2586                 event_func = __bt_hf_agent_event_filter;
2587                 path = BT_HF_AGENT_PATH;
2588                 interface = BT_HF_SERVICE_INTERFACE;
2589                 break;
2590         case BT_A2DP_SOURCE_EVENT:
2591                 BT_DBG("BT_A2DP_SOURCE_EVENT");
2592                 event_func = __bt_a2dp_source_event_filter;
2593                 path = BT_A2DP_SOURCE_PATH;
2594                 break;
2595         case BT_HID_DEVICE_EVENT:
2596                 BT_DBG("BT_HID_DEVICE_EVENT");
2597                 event_func = __bt_hid_device_event_filter;
2598                 path = BT_HID_DEVICE_PATH;
2599                 break;
2600 #ifdef GATT_NO_RELAY
2601         case BT_GATT_BLUEZ_EVENT:
2602                 BT_DBG("BT_GATT_BLUEZ_EVENT");
2603                 event_func = __bt_device_event_filter;
2604                 interface = BT_GATT_CHARACTERISTIC_INTERFACE;
2605                 path = NULL;
2606                 break;
2607 #endif
2608         default:
2609                 BT_ERR("Unknown event");
2610                 return BLUETOOTH_ERROR_INTERNAL;
2611         }
2612
2613         connection_type = _bt_gdbus_get_system_gconn();
2614         if (connection_type == NULL)
2615                 return BLUETOOTH_ERROR_INTERNAL;
2616
2617         cb_data = g_new0(bt_event_info_t, 1);
2618
2619         cb_data->event_type = event_type;
2620         cb_data->cb = event_cb;
2621         cb_data->user_data = user_data;
2622
2623         cb_data->id = g_dbus_connection_signal_subscribe(connection_type,
2624                                 NULL, interface, NULL, path, NULL, 0,
2625                                 event_func, cb_data, NULL);
2626
2627         event_list = g_slist_append(event_list, cb_data);
2628
2629         return BLUETOOTH_ERROR_NONE;
2630 }
2631
2632 int _bt_unregister_event(int event_type)
2633 {
2634         GDBusConnection *connection_type;
2635         bt_event_info_t *cb_data;
2636
2637         if (is_initialized == FALSE) {
2638                 BT_ERR("Event is not registered");
2639                 return BLUETOOTH_ERROR_NOT_INITIALIZED;
2640         }
2641
2642         if (__bt_event_is_registered(event_type) == FALSE) {
2643                 BT_ERR("Not registered event");
2644                 return BLUETOOTH_ERROR_INTERNAL;
2645         }
2646
2647         cb_data = _bt_event_get_cb_data(event_type);
2648
2649         if (cb_data == NULL) {
2650                 BT_ERR("No matched event data");
2651                 return BLUETOOTH_ERROR_INTERNAL;
2652         }
2653
2654         connection_type = _bt_gdbus_get_system_gconn();
2655
2656         event_list = g_slist_remove(event_list, (void *)cb_data);
2657
2658         retv_if(connection_type == NULL, BLUETOOTH_ERROR_INTERNAL);
2659
2660         g_dbus_connection_signal_unsubscribe(connection_type, cb_data->id);
2661
2662         __bt_event_data_free((void *)cb_data);
2663
2664         return BLUETOOTH_ERROR_NONE;
2665 }
2666
2667 static void __bt_name_owner_changed(GDBusConnection *connection,
2668                                                  const gchar *sender_name,
2669                                                  const gchar *object_path,
2670                                                  const gchar *interface_name,
2671                                                  const gchar *signal_name,
2672                                                  GVariant *parameters,
2673                                                  gpointer user_data)
2674 {
2675         const char *name = NULL;
2676         const char *old_owner = NULL;
2677         const char *new_owner = NULL;
2678         bt_event_info_t *event_info;
2679
2680         g_variant_get(parameters, "(&s&s&s)", &name, &old_owner, &new_owner);
2681
2682         if (g_strcmp0(name, BT_DBUS_NAME) == 0 &&
2683                         (new_owner != NULL && *new_owner == '\0')) {
2684                 BT_DBG("bt-service is terminated");
2685                 event_info = _bt_event_get_cb_data(BT_ADAPTER_EVENT);
2686                 if (event_info == NULL)
2687                         return;
2688
2689                 if (disable_timer_id > 0)
2690                         g_source_remove(disable_timer_id);
2691
2692                 disable_timer_id = g_timeout_add(BT_RELIABLE_DISABLE_TIME,
2693                                 (GSourceFunc)__bt_reliable_disable_cb,
2694                                 event_info);
2695         }
2696 }
2697
2698 void _bt_register_name_owner_changed(void)
2699 {
2700         GDBusConnection *connection_type;
2701
2702         connection_type = _bt_gdbus_get_system_gconn();
2703         if (connection_type == NULL) {
2704                 BT_ERR("Unable to get the bus");
2705                 return;
2706         }
2707         owner_sig_id = g_dbus_connection_signal_subscribe(connection_type,
2708                                 NULL, DBUS_INTERFACE_DBUS,
2709                                 BT_NAME_OWNER_CHANGED, NULL, NULL, 0,
2710                                 __bt_name_owner_changed, NULL, NULL);
2711 }
2712
2713 void _bt_unregister_name_owner_changed(void)
2714 {
2715         GDBusConnection *connection_type;
2716
2717         connection_type = _bt_gdbus_get_system_gconn();
2718         if (connection_type != NULL && owner_sig_id != -1) {
2719                 g_dbus_connection_signal_unsubscribe(connection_type,
2720                                                         owner_sig_id);
2721                 owner_sig_id = -1;
2722         }
2723 }