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