bt-api/bt-event-handler.c

   1 /*
   2  * Bluetooth-frwk
   3  *
   4  * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
   5  *
   6  * Contact:  Hocheol Seo <hocheol.seo@samsung.com>
   7  *               Girishashok Joshi <girish.joshi@samsung.com>
   8  *               Chanyeol Park <chanyeol.park@samsung.com>
   9  *
  10  * Licensed under the Apache License, Version 2.0 (the "License");
  11  * you may not use this file except in compliance with the License.
  12  * You may obtain a copy of the License at
  13  *
  14  *              http://www.apache.org/licenses/LICENSE-2.0
  15  *
  16  * Unless required by applicable law or agreed to in writing, software
  17  * distributed under the License is distributed on an "AS IS" BASIS,
  18  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  19  * See the License for the specific language governing permissions and
  20  * limitations under the License.
  21  *
  22  */
  23
  24 #include <string.h>
  25 #include <dbus/dbus.h>
  26 #include <glib.h>
  27 #include <dlog.h>
  28 #include <vconf.h>
  29
  30 #include "bluetooth-api.h"
  31 #include "bluetooth-audio-api.h"
  32 #include "bt-internal-types.h"
  33 #include "bluetooth-media-control.h"
  34
  35 #include "bt-common.h"
  36 #include "bt-event-handler.h"
  37 #include "bt-request-sender.h"
  38
  39 #define BT_RELIABLE_DISABLE_TIME 300 /* 300 ms */
  40
  41 typedef struct {
  42         int server_fd;
  43 } bt_server_info_t;
  44
  45 typedef struct {
  46         int request_id;
  47 } bt_sending_info_t;
  48
  49 static int obex_server_id;
  50 static guint disable_timer_id;
  51 static gboolean is_initialized;
  52 static GSList *sending_list = NULL;
  53 static GSList *server_list = NULL;
  54 static GSList *event_list = NULL;
  55 static int owner_sig_id = -1;
  56 static gboolean is_adapter_enabled = TRUE;
  57
  58 void _bt_add_push_request_id(int request_id)
  59 {
  60         bt_sending_info_t *info;
  61
  62         info = g_new0(bt_sending_info_t, 1);
  63         info->request_id = request_id;
  64
  65         sending_list = g_slist_append(sending_list, info);
  66 }
  67
  68 static gboolean __bt_is_request_id_exist(int request_id)
  69 {
  70         GSList *l;
  71         bt_sending_info_t *info;
  72
  73         for (l = sending_list; l != NULL; l = g_slist_next(l)) {
  74                 info = l->data;
  75                 if (info == NULL)
  76                         continue;
  77
  78                 if (info->request_id == request_id)
  79                         return TRUE;
  80         }
  81
  82         return FALSE;
  83 }
  84
  85 static void __bt_remove_push_request_id(int request_id)
  86 {
  87         GSList *l;
  88         bt_sending_info_t *info;
  89
  90         for (l = sending_list; l != NULL; l = g_slist_next(l)) {
  91                 info = l->data;
  92                 if (info == NULL)
  93                         continue;
  94
  95                 BT_DBG("info->request_id = %d\n", info->request_id);
  96                 BT_DBG("request_id = %d\n", request_id);
  97                 if (info->request_id == request_id) {
  98                         sending_list = g_slist_remove(sending_list, (void *)info);
  99                         g_free(info);
 100                         break;
 101                 }
 102         }
 103 }
 104
 105 static void __bt_remove_all_push_request_id(void)
 106 {
 107         GSList *l;
 108         bt_sending_info_t *info;
 109
 110         for (l = sending_list; l != NULL; l = g_slist_next(l)) {
 111                 info = l->data;
 112                 g_free(info);
 113         }
 114
 115         g_slist_free(sending_list);
 116         sending_list = NULL;
 117 }
 118
 119 static void __bt_remove_all_server(void)
 120 {
 121         GSList *l;
 122         bt_server_info_t *info;
 123
 124         for (l = server_list; l != NULL; l = g_slist_next(l)) {
 125                 info = l->data;
 126                 g_free(info);
 127         }
 128
 129         g_slist_free(server_list);
 130         server_list = NULL;
 131 }
 132
 133 static gboolean __bt_is_server_exist(int server_fd)
 134 {
 135         GSList *l;
 136         bt_server_info_t *info;
 137
 138         for (l = server_list; l != NULL; l = g_slist_next(l)) {
 139                 info = l->data;
 140                 if (info == NULL)
 141                         continue;
 142
 143                 retv_if(info->server_fd == server_fd, TRUE);
 144         }
 145
 146         return FALSE;
 147 }
 148
 149 static void __bt_get_uuid_info(bluetooth_device_info_t *dev_info,
 150                                 char **uuids,
 151                                 int uuid_count)
 152 {
 153         int i;
 154         char **parts;
 155
 156         ret_if(dev_info == NULL);
 157         ret_if(uuids == NULL);
 158         ret_if(uuid_count <= 0);
 159
 160         dev_info->service_index = uuid_count;
 161
 162         for (i = 0; i < uuid_count && uuids[i] != NULL; i++) {
 163                 g_strlcpy(dev_info->uuids[i], uuids[i], BLUETOOTH_UUID_STRING_MAX);
 164
 165                 parts = g_strsplit(uuids[i], "-", -1);
 166
 167                 if (parts == NULL || parts[0] == NULL) {
 168                         g_strfreev(parts);
 169                         continue;
 170                 }
 171
 172                 dev_info->service_list_array[i] = g_ascii_strtoull(parts[0], NULL, 16);
 173                 g_strfreev(parts);
 174         }
 175 }
 176 static int __bt_call_list_create(bt_hf_call_list_s **list)
 177 {
 178         bt_hf_call_list_s *handle;
 179
 180         if (*list != NULL) {
 181                 BT_DBG("Already Initialized");
 182                 return BLUETOOTH_ERROR_NONE;
 183         }
 184         handle = g_malloc0(sizeof(bt_hf_call_list_s));
 185         *list = handle;
 186         return BLUETOOTH_ERROR_NONE;
 187 }
 188
 189 static int __bt_call_list_reset(bt_hf_call_list_s *list)
 190 {
 191         bt_hf_call_list_s *handle;
 192         bt_hf_call_status_info_t *call_status;
 193
 194         if (list == NULL) {
 195                 BT_ERR("invalid parameter");
 196                 return BLUETOOTH_ERROR_INVALID_PARAM;
 197         }
 198         handle = (bt_hf_call_list_s *)list;
 199         do  {
 200                 call_status = (bt_hf_call_status_info_t *)g_list_nth_data(handle->list, 0);
 201                 if (call_status == NULL)
 202                         break;
 203                 handle->list = g_list_remove(handle->list, call_status);
 204                 g_free(call_status->number);
 205                 g_free(call_status);
 206         } while (1);
 207         return BLUETOOTH_ERROR_NONE;
 208 }
 209
 210 static int __bt_call_list_destroy(bt_hf_call_list_s *list)
 211 {
 212         int result;
 213         bt_hf_call_list_s *handle;
 214
 215         if (list == NULL) {
 216                 BT_ERR("invalid parameter");
 217                 return BLUETOOTH_ERROR_INVALID_PARAM;
 218         }
 219         handle = (bt_hf_call_list_s *)list;
 220         result = __bt_call_list_reset(list);
 221         g_free(handle);
 222         return result;
 223 }
 224 static int __bt_call_list_add(bt_hf_call_list_s *list, char * number,
 225                                                                 int dir, int status, int mpart, int idx)
 226 {
 227         bt_hf_call_list_s *handle;
 228         bt_hf_call_status_info_t *call_status;
 229
 230         if (list == NULL) {
 231                 BT_ERR("invalid parameter");
 232                 return BLUETOOTH_ERROR_INVALID_PARAM;
 233         }
 234         handle = (bt_hf_call_list_s *)list;
 235         call_status = g_malloc0(sizeof(bt_hf_call_status_info_t));
 236         /* Fix : NULL_RETURNS */
 237         retv_if(call_status == NULL, BLUETOOTH_ERROR_MEMORY_ALLOCATION);
 238
 239         call_status->number = g_strdup(number);
 240         call_status->direction= dir;
 241         call_status->status = status;
 242         call_status->mpart = mpart;
 243         call_status->idx = idx;
 244         handle->list = g_list_append(handle->list, (gpointer)call_status);
 245         return BLUETOOTH_ERROR_NONE;
 246 }
 247
 248 static bluetooth_device_info_t *__bt_get_device_info_in_message(GVariant *parameters, int *ret)
 249 {
 250         bluetooth_device_info_t *dev_info;
 251         const char *address = NULL;
 252         const char *name = NULL;
 253         gchar **uuids = NULL;
 254         unsigned int dev_class = 0;
 255         short rssi = 0;
 256         gboolean paired = FALSE;
 257         guint connected = 0;
 258         gboolean trust = FALSE;
 259         gsize uuid_count;
 260         int result = BLUETOOTH_ERROR_NONE;
 261         GVariant *string_var;
 262         int i = 0, len = 0;
 263         int manufacturer_data_len = 0;
 264         GVariant *manufacturer_var = NULL;
 265         const char *manufacturer_data = NULL;
 266
 267         g_variant_get(parameters, "(isunsbub@asn@ay)", &result, &address,
 268                         &dev_class, &rssi, &name, &paired,
 269                         &connected, &trust,  &string_var, &manufacturer_data_len, &manufacturer_var);
 270
 271         if (string_var == NULL) {
 272                 BT_ERR("invalid parameters in signal");
 273                 return NULL;
 274         }
 275
 276         uuids = (gchar **)g_variant_get_strv(string_var, &uuid_count);
 277
 278         len = g_variant_get_size(manufacturer_var);
 279         if (len > 0)
 280                 manufacturer_data = (char *)g_variant_get_data(manufacturer_var);
 281
 282         dev_info = g_malloc0(sizeof(bluetooth_device_info_t));
 283         /* Fix : NULL_RETURNS */
 284         if (dev_info == NULL) {
 285                 result = BLUETOOTH_ERROR_MEMORY_ALLOCATION;
 286                 goto done;
 287         }
 288
 289         dev_info->rssi = rssi;
 290         dev_info->paired = paired;
 291         dev_info->connected = connected;
 292         dev_info->trust = trust;
 293
 294         g_strlcpy(dev_info->device_name.name, name,
 295                 BLUETOOTH_DEVICE_NAME_LENGTH_MAX + 1);
 296
 297         _bt_divide_device_class(&dev_info->device_class, dev_class);
 298
 299         _bt_convert_addr_string_to_type(dev_info->device_address.addr,
 300                                         address);
 301
 302         if (uuid_count > 0)
 303                 __bt_get_uuid_info(dev_info, uuids, uuid_count);
 304
 305         if (manufacturer_data_len > BLUETOOTH_MANUFACTURER_DATA_LENGTH_MAX) {
 306                 BT_ERR("manufacturer_data_len is too long(len = %d)", manufacturer_data_len);
 307                 manufacturer_data_len = BLUETOOTH_MANUFACTURER_DATA_LENGTH_MAX;
 308         }
 309         dev_info->manufacturer_data.data_len = manufacturer_data_len;
 310         if (manufacturer_data)
 311                 for (i = 0; i < manufacturer_data_len; i++)
 312                         dev_info->manufacturer_data.data[i] = manufacturer_data[i];
 313 done:
 314         *ret = result;
 315         g_free(uuids);
 316         g_variant_unref(string_var);
 317         g_variant_unref(manufacturer_var);
 318         return dev_info;
 319 }
 320
 321 static bluetooth_le_device_info_t *__bt_get_le_device_info_in_message(GVariant *parameters, int *ret)
 322 {
 323         bluetooth_le_device_info_t *le_dev_info;
 324         const char *address = NULL;
 325         int i;
 326         short addr_type = 0;
 327         short rssi = 0;
 328         int len = 0;
 329         int adv_data_len = 0;
 330         GVariant *adv_var = NULL;
 331         const char *adv_data = NULL;
 332         int scan_data_len = 0;
 333         GVariant *scan_var = NULL;
 334         const char *scan_data = NULL;
 335         int result = BLUETOOTH_ERROR_NONE;
 336
 337         g_variant_get(parameters, "(i&snnn@ayn@ay)", &result, &address,
 338                         &addr_type, &rssi, &adv_data_len, &adv_var, &scan_data_len, &scan_var);
 339
 340         len = g_variant_get_size(adv_var);
 341         if (len > 0)
 342                 adv_data = (char *)g_variant_get_data(adv_var);
 343
 344         len = g_variant_get_size(scan_var);
 345         if (len > 0)
 346                 scan_data = (char *)g_variant_get_data(scan_var);
 347
 348         le_dev_info = g_malloc0(sizeof(bluetooth_le_device_info_t));
 349         /* Fix : NULL_RETURNS */
 350         if (le_dev_info == NULL) {
 351                 result = BLUETOOTH_ERROR_MEMORY_ALLOCATION;
 352                 goto done;
 353         }
 354         _bt_convert_addr_string_to_type(le_dev_info->device_address.addr, address);
 355         le_dev_info->addr_type = addr_type;
 356         le_dev_info->rssi = rssi;
 357         le_dev_info->adv_ind_data.data_len = adv_data_len;
 358
 359         for (i = 0; i < adv_data_len; i++)
 360                 if (adv_data)
 361                         le_dev_info->adv_ind_data.data.data[i] = adv_data[i];
 362
 363         le_dev_info->scan_resp_data.data_len = scan_data_len;
 364
 365         for (i = 0; i < scan_data_len; i++)
 366                 if (scan_data)
 367                         le_dev_info->scan_resp_data.data.data[i] = scan_data[i];
 368
 369 done:
 370         *ret = result;
 371
 372         g_variant_unref(adv_var);
 373         g_variant_unref(scan_var);
 374         return le_dev_info;
 375 }
 376
 377 gboolean __bt_reliable_disable_cb(gpointer user_data)
 378 {
 379         BT_DBG("+");
 380         bt_event_info_t *event_info = user_data;
 381
 382         _bt_set_le_scan_status(FALSE);
 383
 384         if (is_initialized != FALSE) {
 385                 if (is_adapter_enabled == TRUE) {
 386                         is_adapter_enabled = FALSE;
 387                         _bt_common_event_cb(BLUETOOTH_EVENT_DISABLED,
 388                                         BLUETOOTH_ERROR_NONE, NULL,
 389                                         event_info->cb, event_info->user_data);
 390                         _bt_common_event_cb(BLUETOOTH_EVENT_LE_DISABLED,
 391                                         BLUETOOTH_ERROR_NONE, NULL,
 392                                         event_info->cb, event_info->user_data);
 393                 }
 394         }
 395
 396         obex_server_id = BT_NO_SERVER;
 397         __bt_remove_all_server();
 398         __bt_remove_all_push_request_id();
 399 #ifdef RFCOMM_DIRECT
 400          _bt_rfcomm_server_free_all();
 401 #endif
 402         BT_DBG("-");
 403         return FALSE;
 404 }
 405
 406 void __bt_adapter_event_filter(GDBusConnection *connection,
 407                                                  const gchar *sender_name,
 408                                                  const gchar *object_path,
 409                                                  const gchar *interface_name,
 410                                                  const gchar *signal_name,
 411                                                  GVariant *parameters,
 412                                                  gpointer user_data)
 413 {
 414         bt_event_info_t *event_info;
 415         int result = BLUETOOTH_ERROR_NONE;
 416
 417         event_info = (bt_event_info_t *)user_data;
 418         ret_if(event_info == NULL);
 419
 420         if (strcasecmp(object_path, BT_ADAPTER_PATH) != 0)
 421                 return;
 422         if (strcasecmp(interface_name, BT_EVENT_SERVICE) != 0)
 423                 return;
 424
 425         if (strcasecmp(signal_name, BT_ENABLED) == 0) {
 426                 BT_INFO("BT_ENABLED");
 427                 g_variant_get(parameters, "(i)", &result);
 428                 if (result == BLUETOOTH_ERROR_NONE) {
 429                         if (vconf_set_int(BT_OFF_DUE_TO_FLIGHT_MODE, 0) != 0)
 430                                 BT_ERR("Set vconf failed");
 431
 432                         if (vconf_set_int(BT_OFF_DUE_TO_POWER_SAVING_MODE, 0) != 0)
 433                                 BT_ERR("Set vconf failed");
 434
 435                         if (vconf_set_int(BT_OFF_DUE_TO_TIMEOUT, 0) != 0)
 436                                 BT_ERR("Set vconf failed");
 437                 }
 438
 439                 is_adapter_enabled = TRUE;
 440
 441                 _bt_common_event_cb(BLUETOOTH_EVENT_ENABLED,
 442                                 result, NULL,
 443                                 event_info->cb, event_info->user_data);
 444         } else if (strcasecmp(signal_name, BT_DISABLED) == 0) {
 445                 BT_INFO("BT_DISABLED");
 446                 int flight_mode_value = 0;
 447                 int ps_mode_value = 0;
 448
 449                 if (vconf_get_int(BT_OFF_DUE_TO_FLIGHT_MODE,
 450                                                 &flight_mode_value) != 0)
 451                         BT_ERR("Fail to get the flight_mode_deactivated value");
 452
 453                 if (vconf_get_int(BT_OFF_DUE_TO_POWER_SAVING_MODE,
 454                                                         &ps_mode_value) != 0)
 455                         BT_ERR("Fail to get the ps_mode_deactivated value");
 456
 457                 if (flight_mode_value == 1 || ps_mode_value > 0) {
 458                         BT_INFO("Flight mode deactivation");
 459                         if (disable_timer_id > 0)
 460                                 g_source_remove(disable_timer_id);
 461
 462                         disable_timer_id = g_timeout_add(BT_RELIABLE_DISABLE_TIME,
 463                                         (GSourceFunc)__bt_reliable_disable_cb,
 464                                         event_info);
 465                 } else {
 466                         is_adapter_enabled = FALSE;
 467
 468                         _bt_common_event_cb(BLUETOOTH_EVENT_DISABLED,
 469                                         result, NULL,
 470                                         event_info->cb, event_info->user_data);
 471                 }
 472
 473                 _bt_common_event_cb(BLUETOOTH_EVENT_DISABLED,
 474                                 result, NULL,
 475                                 event_info->cb, event_info->user_data);
 476         } else if (strcasecmp(signal_name, BT_DISCOVERABLE_MODE_CHANGED) == 0) {
 477                 int mode = 0;
 478
 479                 g_variant_get(parameters, "(in)", &result, &mode);
 480                 _bt_common_event_cb(BLUETOOTH_EVENT_DISCOVERABLE_MODE_CHANGED,
 481                                 result, &mode,
 482                                 event_info->cb, event_info->user_data);
 483         } else if (strcasecmp(signal_name, BT_DISCOVERABLE_TIMEOUT_CHANGED) == 0) {
 484                 int timeout = 0;
 485
 486                 g_variant_get(parameters, "(in)", &result, &timeout);
 487                 _bt_common_event_cb(BLUETOOTH_EVENT_DISCOVERABLE_TIMEOUT_CHANGED,
 488                                 result, &timeout,
 489                                 event_info->cb, event_info->user_data);
 490         } else if (strcasecmp(signal_name, BT_CONNECTABLE_CHANGED) == 0) {
 491                 gboolean connectable = FALSE;
 492
 493                 g_variant_get(parameters, "(b)", &connectable);
 494                 BT_DBG("Connectable is changed : %d", connectable);
 495
 496                 _bt_common_event_cb(BLUETOOTH_EVENT_CONNECTABLE_CHANGED,
 497                                 result, &connectable,
 498                                 event_info->cb, event_info->user_data);
 499         } else if (strcasecmp(signal_name, BT_ADAPTER_NAME_CHANGED) == 0) {
 500                 char *adapter_name = NULL;
 501
 502                 g_variant_get(parameters, "(i&s)", &result, &adapter_name);
 503                 _bt_common_event_cb(BLUETOOTH_EVENT_LOCAL_NAME_CHANGED,
 504                                 result, adapter_name,
 505                                 event_info->cb, event_info->user_data);
 506         } else if (strcasecmp(signal_name, BT_DISCOVERY_STARTED) == 0) {
 507                 _bt_common_event_cb(BLUETOOTH_EVENT_DISCOVERY_STARTED,
 508                                 BLUETOOTH_ERROR_NONE, NULL,
 509                                 event_info->cb, event_info->user_data);
 510         } else if (strcasecmp(signal_name, BT_DISCOVERY_FINISHED) == 0) {
 511                 g_variant_get(parameters, "(i)", &result);
 512                 _bt_common_event_cb(BLUETOOTH_EVENT_DISCOVERY_FINISHED,
 513                                 result, NULL,
 514                                 event_info->cb, event_info->user_data);
 515         } else if (strcasecmp(signal_name, BT_ADVERTISING_STARTED) == 0) {
 516                 int adv_handle;
 517
 518                 g_variant_get(parameters, "(ii)", &result, &adv_handle);
 519                 _bt_common_event_cb(BLUETOOTH_EVENT_ADVERTISING_STARTED,
 520                                 result, &adv_handle,
 521                                 event_info->cb, event_info->user_data);
 522         } else if (strcasecmp(signal_name, BT_ADVERTISING_STOPPED) == 0) {
 523                 int adv_handle;
 524
 525                 g_variant_get(parameters, "(ii)", &result, &adv_handle);
 526                 _bt_common_event_cb(BLUETOOTH_EVENT_ADVERTISING_STOPPED,
 527                                 result, &adv_handle,
 528                                 event_info->cb, event_info->user_data);
 529         } else if (strcasecmp(signal_name, BT_ADVERTISING_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_ADVERTISING_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_SCAN_RESPONSE_MANUFACTURER_DATA_CHANGED) == 0) {
 544                 GVariant *var = NULL;
 545                 char *data;
 546                 int len;
 547
 548                 g_variant_get(parameters, "(@ay)", &var);
 549                 len = g_variant_get_size(var);
 550                 data = (char *)g_variant_get_data(var);
 551
 552                 _bt_common_event_cb(BLUETOOTH_EVENT_SCAN_RESPONSE_MANUFACTURER_DATA_CHANGED,
 553                                 len, data,
 554                                 event_info->cb, event_info->user_data);
 555
 556                 g_variant_unref(var);
 557         } else if (strcasecmp(signal_name, BT_MANUFACTURER_DATA_CHANGED) == 0) {
 558                 GVariant *var = NULL;
 559                 char *data;
 560                 int len;
 561
 562                 g_variant_get(parameters, "(@ay)", &var);
 563                 len = g_variant_get_size(var);
 564                 data = (char *)g_variant_get_data(var);
 565
 566                 _bt_common_event_cb(BLUETOOTH_EVENT_MANUFACTURER_DATA_CHANGED,
 567                                 len, data,
 568                                 event_info->cb, event_info->user_data);
 569
 570                 g_variant_unref(var);
 571         } else if (strcasecmp(signal_name, BT_DEVICE_FOUND) == 0) {
 572                 int event;
 573                 bluetooth_device_info_t *device_info;
 574
 575                 device_info = __bt_get_device_info_in_message(parameters,
 576                                                                 &result);
 577                 ret_if(device_info == NULL);
 578
 579                 if (strlen(device_info->device_name.name) > 0)
 580                         event = BLUETOOTH_EVENT_REMOTE_DEVICE_NAME_UPDATED;
 581                 else
 582                         event = BLUETOOTH_EVENT_REMOTE_DEVICE_FOUND;
 583
 584                 _bt_common_event_cb(event,
 585                                 result, device_info,
 586                                 event_info->cb, event_info->user_data);
 587
 588                 g_free(device_info);
 589         } else if (strcasecmp(signal_name, BT_BOND_CREATED) == 0) {
 590                 bluetooth_device_info_t *device_info;
 591
 592                 device_info = __bt_get_device_info_in_message(parameters,
 593                                                                 &result);
 594                 ret_if(device_info == NULL);
 595
 596                 _bt_common_event_cb(BLUETOOTH_EVENT_BONDING_FINISHED,
 597                                 result, device_info,
 598                                 event_info->cb, event_info->user_data);
 599
 600                 g_free(device_info);
 601         } else if (strcasecmp(signal_name, BT_BOND_DESTROYED) == 0) {
 602                 const char *address = NULL;
 603                 bluetooth_device_address_t dev_address = { {0} };
 604
 605                 g_variant_get(parameters, "(i&s)", &result, &address);
 606
 607                 _bt_convert_addr_string_to_type(dev_address.addr,
 608                                                 address);
 609
 610                 _bt_common_event_cb(BLUETOOTH_EVENT_BONDED_DEVICE_REMOVED,
 611                                 result, &dev_address,
 612                                 event_info->cb, event_info->user_data);
 613         } else if (strcasecmp(signal_name, BT_SERVICE_SEARCHED) == 0) {
 614                 bluetooth_device_info_t *device_info;
 615                 bt_sdp_info_t sdp_info;
 616
 617                 device_info = __bt_get_device_info_in_message(parameters,
 618                                                                 &result);
 619                 ret_if(device_info == NULL);
 620
 621                 memset(&sdp_info, 0x00, sizeof(bt_sdp_info_t));
 622
 623                 sdp_info.service_index = device_info->service_index;
 624
 625                 memcpy(&sdp_info.device_addr,
 626                         &device_info->device_address,
 627                         BLUETOOTH_ADDRESS_LENGTH);
 628
 629                 memcpy(sdp_info.service_list_array,
 630                         device_info->service_list_array,
 631                         BLUETOOTH_MAX_SERVICES_FOR_DEVICE);
 632
 633                 memcpy(sdp_info.uuids,
 634                         device_info->uuids,
 635                         BLUETOOTH_MAX_SERVICES_FOR_DEVICE * BLUETOOTH_UUID_STRING_MAX);
 636
 637                 _bt_common_event_cb(BLUETOOTH_EVENT_SERVICE_SEARCHED,
 638                                 result, &sdp_info,
 639                                 event_info->cb, event_info->user_data);
 640
 641                 g_free(device_info);
 642         } else if (strcasecmp(signal_name, BT_IPSP_INITIALIZED) == 0) {
 643                 gboolean ipsp_intialized = FALSE;
 644                 g_variant_get(parameters, "(b)", &ipsp_intialized);
 645
 646                 BT_DBG("IPSP init state changed to : %d", ipsp_intialized);
 647
 648                 _bt_common_event_cb(BLUETOOTH_EVENT_IPSP_INIT_STATE_CHANGED,
 649                                 BLUETOOTH_ERROR_NONE, &ipsp_intialized,
 650                                 event_info->cb, event_info->user_data);
 651         } else if (strcasecmp(signal_name, BT_KBD_PASSKEY_DISPLAY_REQ_RECEIVED) == 0) {
 652                 const char *address =  NULL;
 653                 const char *name =  NULL;
 654                 const char *str_passkey = NULL;
 655
 656                 bluetooth_authentication_request_info_t auth_info;
 657                 memset(&auth_info, 0x00, sizeof(bluetooth_authentication_request_info_t));
 658
 659                 g_variant_get(parameters, "(i&s&s&s)", &result, &address, &name, &str_passkey);
 660
 661                 g_strlcpy(auth_info.device_name.name, name,
 662                         BLUETOOTH_DEVICE_NAME_LENGTH_MAX + 1);
 663                 _bt_convert_addr_string_to_type(auth_info.device_address.addr,
 664                         address);
 665                 g_strlcpy(auth_info.str_passkey, str_passkey, strlen(str_passkey)+1);
 666
 667                 _bt_common_event_cb(BLUETOOTH_EVENT_KEYBOARD_PASSKEY_DISPLAY,
 668                         result, &auth_info,
 669                         event_info->cb, event_info->user_data);
 670         } else if (strcasecmp(signal_name, BT_PIN_REQ_RECEIVED) == 0) {
 671                 const char *address =  NULL;
 672                 const char *name =  NULL;
 673
 674                 bluetooth_authentication_request_info_t auth_info;
 675                 memset(&auth_info, 0x00, sizeof(bluetooth_authentication_request_info_t));
 676
 677                 g_variant_get(parameters, "(i&s&s)", &result, &address, &name);
 678
 679                 g_strlcpy(auth_info.device_name.name, name,
 680                         BLUETOOTH_DEVICE_NAME_LENGTH_MAX + 1);
 681                 _bt_convert_addr_string_to_type(auth_info.device_address.addr,
 682                         address);
 683
 684                 _bt_common_event_cb(BLUETOOTH_EVENT_PIN_REQUEST,
 685                         result, &auth_info,
 686                         event_info->cb, event_info->user_data);
 687         } else if (strcasecmp(signal_name, BT_PASSKEY_REQ_RECEIVED) == 0) {
 688                 const char *address = NULL;
 689                 const char *name =  NULL;
 690
 691                 bluetooth_authentication_request_info_t auth_info;
 692                 memset(&auth_info, 0x00, sizeof(bluetooth_authentication_request_info_t));
 693
 694                 g_variant_get(parameters, "(i&s&s)", &result, &address, &name);
 695
 696                 g_strlcpy(auth_info.device_name.name, name,
 697                         BLUETOOTH_DEVICE_NAME_LENGTH_MAX + 1);
 698                 _bt_convert_addr_string_to_type(auth_info.device_address.addr,
 699                         address);
 700
 701                 _bt_common_event_cb(BLUETOOTH_EVENT_PASSKEY_REQUEST,
 702                         result, &auth_info,
 703                         event_info->cb, event_info->user_data);
 704         } else if (strcasecmp(signal_name, BT_PASSKEY_CFM_REQ_RECEIVED) == 0) {
 705                 const char *address =  NULL;
 706                 const char *name =  NULL;
 707                 const char *str_passkey = NULL;
 708
 709                 bluetooth_authentication_request_info_t auth_info;
 710                 memset(&auth_info, 0x00, sizeof(bluetooth_authentication_request_info_t));
 711
 712                 g_variant_get(parameters, "(i&s&s&s)", &result, &address, &name, &str_passkey);
 713
 714                 g_strlcpy(auth_info.device_name.name, name,
 715                         BLUETOOTH_DEVICE_NAME_LENGTH_MAX + 1);
 716                 _bt_convert_addr_string_to_type(auth_info.device_address.addr,
 717                         address);
 718                 g_strlcpy(auth_info.str_passkey, str_passkey, strlen(str_passkey)+1);
 719
 720                 _bt_common_event_cb(BLUETOOTH_EVENT_PASSKEY_CONFIRM_REQUEST,
 721                         result, &auth_info,
 722                         event_info->cb, event_info->user_data);
 723         }
 724 }
 725
 726 void __bt_adapter_le_event_filter(GDBusConnection *connection,
 727                                                  const gchar *sender_name,
 728                                                  const gchar *object_path,
 729                                                  const gchar *interface_name,
 730                                                  const gchar *signal_name,
 731                                                  GVariant *parameters,
 732                                                  gpointer user_data)
 733 {
 734         bt_event_info_t *event_info;
 735         int result = BLUETOOTH_ERROR_NONE;
 736
 737         event_info = (bt_event_info_t *)user_data;
 738         ret_if(event_info == NULL);
 739
 740         if (strcasecmp(object_path, BT_LE_ADAPTER_PATH) != 0)
 741                 return;
 742         if (strcasecmp(interface_name, BT_EVENT_SERVICE) != 0)
 743                 return;
 744
 745         if (strcasecmp(signal_name, BT_LE_ENABLED) == 0) {
 746                 BT_INFO("BT_LE_ENABLED");
 747                 g_variant_get(parameters, "(i)", &result);
 748                 _bt_common_event_cb(BLUETOOTH_EVENT_LE_ENABLED,
 749                                 result, NULL,
 750                                 event_info->cb, event_info->user_data);
 751         } else if (strcasecmp(signal_name, BT_LE_DISABLED) == 0) {
 752                 BT_INFO("BT_LE_DISABLED");
 753                 _bt_common_event_cb(BLUETOOTH_EVENT_LE_DISABLED,
 754                                 result, NULL,
 755                                 event_info->cb, event_info->user_data);
 756         } else if (strcasecmp(signal_name, BT_LE_DISCOVERY_STARTED) == 0) {
 757                 _bt_common_event_cb(BLUETOOTH_EVENT_LE_DISCOVERY_STARTED,
 758                                 BLUETOOTH_ERROR_NONE, NULL,
 759                                 event_info->cb, event_info->user_data);
 760         } else if (strcasecmp(signal_name, BT_LE_DISCOVERY_FINISHED) == 0) {
 761                 g_variant_get(parameters, "(i)", &result);
 762                 _bt_common_event_cb(BLUETOOTH_EVENT_LE_DISCOVERY_FINISHED,
 763                                 result, NULL,
 764                                 event_info->cb, event_info->user_data);
 765         } else if (strcasecmp(signal_name, BT_LE_DEVICE_FOUND) == 0) {
 766                 bluetooth_le_device_info_t *le_device_info;
 767
 768                 le_device_info = __bt_get_le_device_info_in_message(parameters,
 769                                                                 &result);
 770                 ret_if(le_device_info == NULL);
 771
 772                 _bt_common_event_cb(BLUETOOTH_EVENT_REMOTE_LE_DEVICE_FOUND,
 773                                 result, le_device_info,
 774                                 event_info->cb, event_info->user_data);
 775
 776                 g_free(le_device_info);
 777         }
 778 }
 779
 780 void __bt_device_event_filter(GDBusConnection *connection,
 781                                                  const gchar *sender_name,
 782                                                  const gchar *object_path,
 783                                                  const gchar *interface_name,
 784                                                  const gchar *signal_name,
 785                                                  GVariant *parameters,
 786                                                  gpointer user_data)
 787 {
 788         bt_event_info_t *event_info;
 789         int result = BLUETOOTH_ERROR_NONE;
 790
 791         event_info = (bt_event_info_t *)user_data;
 792         ret_if(event_info == NULL);
 793
 794 #ifdef GATT_NO_RELAY
 795         gboolean gatt_interface = FALSE;
 796
 797         if (strcasecmp(interface_name, BT_GATT_CHARACTERISTIC_INTERFACE) == 0)
 798                 gatt_interface = TRUE;
 799
 800         if (strcasecmp(object_path, BT_DEVICE_PATH) != 0 &&
 801                  gatt_interface == FALSE)
 802                 return;
 803         if (strcasecmp(interface_name, BT_EVENT_SERVICE) != 0 &&
 804                  gatt_interface == FALSE)
 805                 return;
 806 #else
 807         if (strcasecmp(object_path, BT_DEVICE_PATH) != 0)
 808                 return;
 809         if (strcasecmp(interface_name, BT_EVENT_SERVICE) != 0)
 810                 return;
 811 #endif
 812
 813         ret_if(signal_name == NULL);
 814
 815         if (strcasecmp(signal_name, BT_GATT_CONNECTED) == 0) {
 816                 const char *address = NULL;
 817                 bluetooth_device_address_t dev_address = { {0} };
 818                 BT_DBG("BT_GATT_CONNECTED");
 819                 g_variant_get(parameters, "(i&s)", &result, &address);
 820
 821                 _bt_convert_addr_string_to_type(dev_address.addr, address);
 822                 BT_DBG("Sending Event to Framework");
 823                 _bt_common_event_cb(BLUETOOTH_EVENT_GATT_CONNECTED,
 824                                 result, &dev_address,
 825                                 event_info->cb, event_info->user_data);
 826         } else if (strcasecmp(signal_name, BT_GATT_DISCONNECTED) == 0) {
 827                 const char *address = NULL;
 828                 bluetooth_device_address_t dev_address = { {0} };
 829                 BT_DBG("BT_GATT_DISCONNECTED");
 830                 g_variant_get(parameters, "(i&s)", &result, &address);
 831
 832                 _bt_convert_addr_string_to_type(dev_address.addr, address);
 833                 BT_DBG("Sending Event to Framework");
 834                 _bt_common_event_cb(BLUETOOTH_EVENT_GATT_DISCONNECTED,
 835                                 result, &dev_address,
 836                                 event_info->cb, event_info->user_data);
 837 #ifdef GATT_NO_RELAY
 838         } else if (strcasecmp(signal_name, BT_GATT_BLUEZ_CHAR_VAL_CHANGED) == 0) {
 839 #else
 840         } else if (strcasecmp(signal_name, BT_GATT_CHAR_VAL_CHANGED) == 0) {
 841 #endif
 842                 const char *char_handle = NULL;
 843                 int len = 0;
 844                 const char * value = NULL;
 845                 GVariant *char_value_var = NULL;
 846                 bt_gatt_char_value_t char_val = { 0, };
 847                 BT_DBG("BT_GATT_CHAR_VAL_CHANGED");
 848
 849                 g_variant_get(parameters, "(i&s@ay)", &result, &char_handle, &char_value_var);
 850
 851                 len = g_variant_get_size(char_value_var);
 852                 if (len > 0)
 853                         value = (char *)g_variant_get_data(char_value_var);
 854
 855                 char_val.char_handle = g_strdup(char_handle);
 856                 char_val.val_len = len;
 857                 /* Fix : FORWARD_NULL : g_variant_get_data can return NULL */
 858                 if (char_val.val_len > 0 && value != NULL) {
 859                         char_val.char_value = (unsigned char*) g_malloc0(char_val.val_len);
 860                         /* Fix : NULL_RETURNS */
 861                         if (char_val.char_value == NULL) {
 862                                 BT_ERR("BLUETOOTH_ERROR_OUT_OF_MEMORY");
 863                                 g_free(char_val.char_handle);
 864                                 if (char_value_var)
 865                                         g_variant_unref(char_value_var);
 866                                 return;
 867                         }
 868                         memcpy(char_val.char_value, value, len);
 869                         _bt_common_event_cb(BLUETOOTH_EVENT_GATT_CHAR_VAL_CHANGED,
 870                                         result, &char_val,
 871                                         event_info->cb, event_info->user_data);
 872                         g_free(char_val.char_value);
 873                         if (char_value_var)
 874                                 g_variant_unref(char_value_var);
 875                 }
 876                 g_free(char_val.char_handle);
 877         } else if (strcasecmp(signal_name, BT_DEVICE_CONNECTED) == 0) {
 878                 const char *address = NULL;
 879                 unsigned char addr_type;
 880                 bt_connection_info_t conn_info;
 881                 bluetooth_device_address_t dev_address = { {0} };
 882                 BT_DBG("BT_DEVICE_CONNECTED");
 883                 g_variant_get(parameters, "(i&sy)", &result, &address, &addr_type);
 884
 885                 _bt_convert_addr_string_to_type(dev_address.addr,
 886                                                 address);
 887
 888                 memset(&conn_info, 0x00, sizeof(bt_connection_info_t));
 889
 890                 memcpy(conn_info.device_addr.addr,
 891                                         dev_address.addr,
 892                                         BLUETOOTH_ADDRESS_LENGTH);
 893
 894                 conn_info.addr_type = addr_type;
 895                 conn_info.disc_reason = 0;
 896                 BT_DBG("Sending Event to Framework");
 897                 _bt_common_event_cb(BLUETOOTH_EVENT_DEVICE_CONNECTED,
 898                                 result, &conn_info,
 899                                 event_info->cb, event_info->user_data);
 900
 901         } else if (strcasecmp(signal_name, BT_DEVICE_DISCONNECTED) == 0) {
 902                 const char *address = NULL;
 903                 unsigned char addr_type;
 904                 bt_connection_info_t conn_info;
 905                 bluetooth_device_address_t dev_address = { {0} };
 906                 BT_DBG("BT_DEVICE_DISCONNECTED");
 907                 g_variant_get(parameters, "(i&sy)", &result, &address, &addr_type);
 908
 909                 _bt_convert_addr_string_to_type(dev_address.addr,
 910                                                 address);
 911
 912                 memset(&conn_info, 0x00, sizeof(bt_connection_info_t));
 913
 914                 memcpy(conn_info.device_addr.addr,
 915                                         dev_address.addr,
 916                                         BLUETOOTH_ADDRESS_LENGTH);
 917
 918                 conn_info.addr_type = addr_type;
 919                 conn_info.disc_reason = result;
 920                 BT_DBG("Sending Event to Framework");
 921                 _bt_common_event_cb(BLUETOOTH_EVENT_DEVICE_DISCONNECTED,
 922                                 result, &conn_info,
 923                                 event_info->cb, event_info->user_data);
 924
 925         } else if (strcasecmp(signal_name, BT_RSSI_MONITORING_ENABLED) == 0) {
 926                 bt_rssi_enabled_t enabled = { 0, };
 927                 char *address;
 928                 int link_type;
 929                 gboolean rssi_enabled = FALSE;
 930
 931                 g_variant_get(parameters, "(isib)", &result, &address,
 932                                         &link_type, &rssi_enabled);
 933
 934                 BT_DBG("RSSI Enabled[Address:%s LinkType:%d RSSI_dbm:%d]",
 935                                 address, link_type, rssi_enabled);
 936                 enabled.address = address;
 937                 enabled.link_type = link_type;
 938                 enabled.rssi_enabled = rssi_enabled;
 939
 940                 _bt_common_event_cb(BLUETOOTH_EVENT_RSSI_ENABLED,
 941                                 result, &enabled,
 942                                 event_info->cb, event_info->user_data);
 943         } else if (strcasecmp(signal_name, BT_RSSI_ALERT) == 0) {
 944                 int alert_type;
 945                 int rssi_dbm;
 946                 char *address;
 947                 int link_type;
 948                 bt_rssi_alert_t alert = { 0, };
 949
 950                 g_variant_get(parameters, "(isiii)", &result, &address,
 951                                         &link_type, &alert_type, &rssi_dbm);
 952
 953                 alert.alert_type = alert_type;
 954                 alert.rssi_dbm = rssi_dbm;
 955                 alert.address = address;
 956                 alert.link_type = link_type;
 957                 BT_DBG("Address [%s] LinkType[%d] AlertType[%d] RSSI dBm[%d]",
 958                                 address, link_type, alert_type, rssi_dbm);
 959                 _bt_common_event_cb(BLUETOOTH_EVENT_RSSI_ALERT,
 960                                 result, &alert,
 961                                 event_info->cb, event_info->user_data);
 962         } else if (strcasecmp(signal_name, BT_RAW_RSSI_EVENT) == 0) {
 963                 int rssi_dbm;
 964                 int link_type;
 965                 char *address;
 966                 bt_raw_rssi_t raw_rssi = { 0, };
 967
 968                 g_variant_get(parameters, "(isii)", &result,
 969                                         &address, &link_type, &rssi_dbm);
 970
 971                 BT_DBG("Address [%s] Link Type[%d] dBm[%d]",
 972                                 address, link_type, rssi_dbm);
 973
 974                 raw_rssi.rssi_dbm = rssi_dbm;
 975                 raw_rssi.address = address;
 976                 raw_rssi.link_type = link_type;
 977
 978                 _bt_common_event_cb(BLUETOOTH_EVENT_RAW_RSSI,
 979                                 result, &raw_rssi,
 980                                 event_info->cb, event_info->user_data);
 981         } else if (strcasecmp(signal_name, BT_DEVICE_AUTHORIZED) == 0) {
 982                 const char *address = NULL;
 983                 bluetooth_device_address_t dev_address = { {0} };
 984
 985                 g_variant_get(parameters, "(i&s)", &result, &address);
 986
 987                 _bt_convert_addr_string_to_type(dev_address.addr,
 988                                                 address);
 989
 990                 _bt_common_event_cb(BLUETOOTH_EVENT_DEVICE_AUTHORIZED,
 991                                 result, &dev_address,
 992                                 event_info->cb, event_info->user_data);
 993         } else if (strcasecmp(signal_name, BT_DEVICE_UNAUTHORIZED) == 0) {
 994                 const char *address = NULL;
 995                 bluetooth_device_address_t dev_address = { {0} };
 996
 997                 g_variant_get(parameters, "(i&s)", &result, &address);
 998
 999                 _bt_convert_addr_string_to_type(dev_address.addr,
1000                                                 address);
1001
1002                 _bt_common_event_cb(BLUETOOTH_EVENT_DEVICE_UNAUTHORIZED,
1003                                 result, &dev_address,
1004                                 event_info->cb, event_info->user_data);
1005         } else if (strcasecmp(signal_name, BT_IPSP_CONNECTED) == 0) {
1006                 const char *address = NULL;
1007                 bluetooth_device_address_t dev_address = { {0} };
1008
1009                 BT_DBG("BT_IPSP_CONNECTED");
1010                 g_variant_get(parameters, "(i&s)", &result, &address);
1011
1012                 _bt_convert_addr_string_to_type(dev_address.addr, address);
1013
1014                 _bt_common_event_cb(BLUETOOTH_EVENT_IPSP_CONNECTED,
1015                                 result, &dev_address,
1016                                 event_info->cb, event_info->user_data);
1017         } else if (strcasecmp(signal_name, BT_IPSP_DISCONNECTED) == 0) {
1018                 const char *address = NULL;
1019                 bluetooth_device_address_t dev_address = { {0} };
1020                 BT_DBG("BT_IPSP_DISCONNECTED");
1021
1022                 g_variant_get(parameters, "(i&s)", &result, &address);
1023
1024                 _bt_convert_addr_string_to_type(dev_address.addr, address);
1025
1026                 _bt_common_event_cb(BLUETOOTH_EVENT_IPSP_DISCONNECTED,
1027                                 result, &dev_address,
1028                                 event_info->cb, event_info->user_data);
1029         } else if (strcasecmp(signal_name, BT_LE_DATA_LENGTH_CHANGED) == 0) {
1030                 const char *address = NULL;
1031                 bluetooth_device_address_t dev_address = { {0} };
1032                 uint tx_octets = 0;
1033                 uint tx_time = 0;
1034                 uint rx_octets = 0;
1035                 uint rx_time = 0;
1036                 bt_le_data_length_params_t params;
1037
1038                 BT_DBG("BT_LE_DATA_LENGTH_CHANGED");
1039
1040                 g_variant_get(parameters, "(i&sqqqq)", &result, &address,
1041                                 tx_octets, tx_time, rx_octets, rx_time);
1042
1043                 params.max_tx_octets = tx_octets;
1044                 params.max_tx_time = tx_time;
1045                 params.max_rx_octets = rx_octets;
1046                 params.max_rx_time = rx_time;
1047
1048                 _bt_convert_addr_string_to_type(dev_address.addr, address);
1049
1050                 memcpy(&params.device_address,
1051                         &dev_address, BLUETOOTH_ADDRESS_LENGTH);
1052
1053                 _bt_common_event_cb(BLUETOOTH_EVENT_LE_DATA_LENGTH_CHANGED,
1054                                 result, &params, event_info->cb, event_info->user_data);
1055         }
1056 }
1057
1058 void __bt_hid_event_filter(GDBusConnection *connection,
1059                                                  const gchar *sender_name,
1060                                                  const gchar *object_path,
1061                                                  const gchar *interface_name,
1062                                                  const gchar *signal_name,
1063                                                  GVariant *parameters,
1064                                                  gpointer user_data)
1065 {
1066         bt_event_info_t *event_info;
1067         int result = BLUETOOTH_ERROR_NONE;
1068
1069         event_info = (bt_event_info_t *)user_data;
1070         ret_if(event_info == NULL);
1071
1072         if (strcasecmp(object_path, BT_HID_PATH) != 0)
1073                 return;
1074         if (strcasecmp(interface_name, BT_EVENT_SERVICE) != 0)
1075                 return;
1076
1077         ret_if(signal_name == NULL);
1078
1079         if (strcasecmp(signal_name, BT_INPUT_CONNECTED) == 0) {
1080                 const char *address = NULL;
1081                 bluetooth_device_address_t dev_address = { {0} };
1082
1083                 g_variant_get(parameters, "(i&s)", &result, &address);
1084
1085                 _bt_convert_addr_string_to_type(dev_address.addr,
1086                                                 address);
1087
1088                 _bt_input_event_cb(BLUETOOTH_HID_CONNECTED,
1089                                 result, &dev_address,
1090                                 event_info->cb, event_info->user_data);
1091         } else if (strcasecmp(signal_name, BT_INPUT_DISCONNECTED) == 0) {
1092                 const char *address = NULL;
1093                 bluetooth_device_address_t dev_address = { {0} };
1094
1095                 g_variant_get(parameters, "(i&s)", &result, &address);
1096
1097                 BT_DBG("address: %s", address);
1098
1099                 _bt_convert_addr_string_to_type(dev_address.addr,
1100                                                 address);
1101
1102                 _bt_input_event_cb(BLUETOOTH_HID_DISCONNECTED,
1103                                 result, &dev_address,
1104                                 event_info->cb, event_info->user_data);
1105         }
1106 }
1107
1108 void __bt_headset_event_filter(GDBusConnection *connection,
1109                                                  const gchar *sender_name,
1110                                                  const gchar *object_path,
1111                                                  const gchar *interface_name,
1112                                                  const gchar *signal_name,
1113                                                  GVariant *parameters,
1114                                                  gpointer user_data)
1115 {
1116         bt_event_info_t *event_info;
1117         int result = BLUETOOTH_ERROR_NONE;
1118         event_info = (bt_event_info_t *)user_data;
1119         ret_if(event_info == NULL);
1120
1121         if (strcasecmp(object_path, BT_HEADSET_PATH) != 0)
1122                 return;
1123         if (strcasecmp(interface_name, BT_EVENT_SERVICE) != 0)
1124                 return;
1125
1126         ret_if(signal_name == NULL);
1127
1128         if (strcasecmp(signal_name, BT_HEADSET_CONNECTED) == 0) {
1129                 char *address = NULL;
1130
1131                 g_variant_get(parameters, "(i&s)", &result, &address);
1132
1133                 _bt_headset_event_cb(BLUETOOTH_EVENT_AG_CONNECTED,
1134                                 result, address,
1135                                 event_info->cb, event_info->user_data);
1136         } else if (strcasecmp(signal_name, BT_HEADSET_DISCONNECTED) == 0) {
1137                 char *address = NULL;
1138
1139                 g_variant_get(parameters, "(i&s)", &result, &address);
1140
1141                 _bt_headset_event_cb(BLUETOOTH_EVENT_AG_DISCONNECTED,
1142                                 result, address,
1143                                 event_info->cb, event_info->user_data);
1144         } else if (strcasecmp(signal_name, BT_STEREO_HEADSET_CONNECTED) == 0) {
1145                 char *address = NULL;
1146
1147                 g_variant_get(parameters, "(i&s)", &result, &address);
1148
1149                 _bt_headset_event_cb(BLUETOOTH_EVENT_AV_CONNECTED,
1150                                 result, address,
1151                                 event_info->cb, event_info->user_data);
1152         } else if (strcasecmp(signal_name, BT_STEREO_HEADSET_DISCONNECTED) == 0) {
1153                 char *address = NULL;
1154
1155                 g_variant_get(parameters, "(i&s)", &result, &address);
1156
1157                 _bt_headset_event_cb(BLUETOOTH_EVENT_AV_DISCONNECTED,
1158                                 result, address,
1159                                 event_info->cb, event_info->user_data);
1160         } else if (strcasecmp(signal_name, BT_A2DP_SOURCE_CONNECTED) == 0) {
1161                 char *address = NULL;
1162
1163                 g_variant_get(parameters, "(i&s)", &result, &address);
1164                 _bt_a2dp_source_event_cb(BLUETOOTH_EVENT_AV_SOURCE_CONNECTED,
1165                                                 result, address,
1166                                                 event_info->cb, event_info->user_data);
1167         } else if (strcasecmp(signal_name, BT_A2DP_SOURCE_DISCONNECTED) == 0) {
1168                 char *address = NULL;
1169
1170                 g_variant_get(parameters, "(i&s)", &result, &address);
1171
1172                 _bt_a2dp_source_event_cb(BLUETOOTH_EVENT_AV_SOURCE_DISCONNECTED,
1173                                                 result, address,
1174                                                 event_info->cb, event_info->user_data);
1175         } else if (strcasecmp(signal_name, BT_SPEAKER_GAIN) == 0) {
1176                 unsigned int gain;
1177                 guint16 spkr_gain;
1178                 char *address = NULL;
1179
1180                 g_variant_get(parameters, "(i&sq)", &result, &address,
1181                                                                 &spkr_gain);
1182                 gain = (unsigned int)spkr_gain;
1183
1184                 _bt_headset_event_cb(BLUETOOTH_EVENT_AG_SPEAKER_GAIN,
1185                                 result, &gain,
1186                                 event_info->cb, event_info->user_data);
1187         } else if (strcasecmp(signal_name, BT_MICROPHONE_GAIN) == 0) {
1188                 unsigned int gain;
1189                 guint16 mic_gain;
1190                 char *address = NULL;
1191
1192                 g_variant_get(parameters, "(i&sq)", &result,
1193                                                 &address, &mic_gain);
1194                 gain = (unsigned int)mic_gain;
1195
1196                 _bt_headset_event_cb(BLUETOOTH_EVENT_AG_MIC_GAIN,
1197                                 result, &gain,
1198                                 event_info->cb, event_info->user_data);
1199         }
1200 }
1201
1202 void __bt_hid_device_event_filter(GDBusConnection *connection,
1203                                                  const gchar *sender_name,
1204                                                  const gchar *object_path,
1205                                                  const gchar *interface_name,
1206                                                  const gchar *signal_name,
1207                                                  GVariant *parameters,
1208                                                  gpointer user_data)
1209 {
1210         bt_event_info_t *event_info;
1211         int result = BLUETOOTH_ERROR_NONE;
1212
1213         event_info = (bt_event_info_t *)user_data;
1214         ret_if(event_info == NULL);
1215
1216         if (strcasecmp(object_path, BT_HID_DEVICE_PATH) != 0)
1217                 return;
1218         if (strcasecmp(interface_name, BT_EVENT_SERVICE) != 0)
1219                 return;
1220
1221         ret_if(signal_name == NULL);
1222
1223         if (strcasecmp(signal_name, BT_HID_DEVICE_CONNECTED) == 0) {
1224                 const char *address = NULL;
1225                 bluetooth_device_address_t dev_address = { {0} };
1226
1227                 g_variant_get(parameters, "(i&s)", &result, &address);
1228
1229                 _bt_convert_addr_string_to_type(dev_address.addr,
1230                                                 address);
1231
1232                 _bt_input_event_cb(BLUETOOTH_HID_DEVICE_CONNECTED,
1233                                 result, &dev_address,
1234                                 event_info->cb, event_info->user_data);
1235         } else if (strcasecmp(signal_name, BT_HID_DEVICE_DISCONNECTED) == 0) {
1236                 const char *address = NULL;
1237                 bluetooth_device_address_t dev_address = { {0} };
1238
1239                 g_variant_get(parameters, "(i&s)", &result, &address);
1240
1241                 BT_DBG("address: %s", address);
1242
1243                 _bt_convert_addr_string_to_type(dev_address.addr,
1244                                                 address);
1245
1246                 _bt_input_event_cb(BLUETOOTH_HID_DEVICE_DISCONNECTED,
1247                                 result, &dev_address,
1248                                 event_info->cb, event_info->user_data);
1249         }
1250 }
1251 void __bt_a2dp_source_event_filter(GDBusConnection *connection,
1252                                                  const gchar *sender_name,
1253                                                  const gchar *object_path,
1254                                                  const gchar *interface_name,
1255                                                  const gchar *signal_name,
1256                                                  GVariant *parameters,
1257                                                  gpointer user_data)
1258 {
1259         bt_event_info_t *event_info;
1260         int result = BLUETOOTH_ERROR_NONE;
1261         event_info = (bt_event_info_t *)user_data;
1262         ret_if(event_info == NULL);
1263
1264         if (strcasecmp(object_path, BT_A2DP_SOURCE_PATH) != 0)
1265                 return;
1266         if (strcasecmp(interface_name, BT_EVENT_SERVICE) != 0)
1267                 return;
1268
1269         ret_if(signal_name == NULL);
1270
1271         if (strcasecmp(signal_name, BT_A2DP_SOURCE_CONNECTED) == 0) {
1272                 char *address = NULL;
1273
1274                 g_variant_get(parameters, "(i&s)", &result, &address);
1275                 _bt_a2dp_source_event_cb(BLUETOOTH_EVENT_AV_SOURCE_CONNECTED,
1276                                                 result, address,
1277                                                 event_info->cb, event_info->user_data);
1278         } else if (strcasecmp(signal_name, BT_A2DP_SOURCE_DISCONNECTED) == 0) {
1279                 char *address = NULL;
1280
1281                 g_variant_get(parameters, "(i&s)", &result, &address);
1282
1283                 _bt_a2dp_source_event_cb(BLUETOOTH_EVENT_AV_SOURCE_DISCONNECTED,
1284                                                 result, address,
1285                                                 event_info->cb, event_info->user_data);
1286         }
1287 }
1288
1289 void __bt_network_event_filter(GDBusConnection *connection,
1290                                                  const gchar *sender_name,
1291                                                  const gchar *object_path,
1292                                                  const gchar *interface_name,
1293                                                  const gchar *signal_name,
1294                                                  GVariant *parameters,
1295                                                  gpointer user_data)
1296 {
1297         bt_event_info_t *event_info;
1298         int result = BLUETOOTH_ERROR_NONE;
1299         event_info = (bt_event_info_t *)user_data;
1300         ret_if(event_info == NULL);
1301
1302         if (strcasecmp(object_path, BT_NETWORK_PATH) != 0)
1303                 return;
1304         if (strcasecmp(interface_name, BT_EVENT_SERVICE) != 0)
1305                 return;
1306
1307         ret_if(signal_name == NULL);
1308
1309         if (strcasecmp(signal_name, BT_NETWORK_CONNECTED) == 0) {
1310                 const char *address = NULL;
1311                 bluetooth_device_address_t dev_address = { {0} };
1312
1313                 g_variant_get(parameters, "(i&s)", &result, &address);
1314
1315                 _bt_convert_addr_string_to_type(dev_address.addr,
1316                                                 address);
1317
1318                 _bt_common_event_cb(BLUETOOTH_EVENT_NETWORK_CONNECTED,
1319                                 result, &dev_address,
1320                                 event_info->cb, event_info->user_data);
1321         } else if (strcasecmp(signal_name, BT_NETWORK_DISCONNECTED) == 0) {
1322                 const char *address = NULL;
1323                 bluetooth_device_address_t dev_address = { {0} };
1324
1325                 g_variant_get(parameters, "(i&s)", &result, &address);
1326
1327                 _bt_convert_addr_string_to_type(dev_address.addr,
1328                                                 address);
1329
1330                 _bt_common_event_cb(BLUETOOTH_EVENT_NETWORK_DISCONNECTED,
1331                                 result, &dev_address,
1332                                 event_info->cb, event_info->user_data);
1333         } else if (strcasecmp(signal_name, BT_NETWORK_SERVER_CONNECTED) == 0) {
1334                 const char *device = NULL;
1335                 const char *address = NULL;
1336                 bluetooth_network_device_info_t network_info;
1337
1338                 g_variant_get(parameters, "(i&s&s)", &result,
1339                                                         &device, &address);
1340
1341                 memset(&network_info, 0x00, sizeof(bluetooth_network_device_info_t));
1342
1343                 _bt_convert_addr_string_to_type(network_info.device_address.addr,
1344                                                 address);
1345
1346                 _bt_print_device_address_t(&network_info.device_address);
1347                 g_strlcpy(network_info.interface_name, device,
1348                                         sizeof(network_info.interface_name));
1349
1350                 DBG_SECURE("Interface: %s", network_info.interface_name);
1351
1352                 _bt_common_event_cb(BLUETOOTH_EVENT_NETWORK_SERVER_CONNECTED,
1353                                 result, &network_info,
1354                                 event_info->cb, event_info->user_data);
1355         } else if (strcasecmp(signal_name, BT_NETWORK_SERVER_DISCONNECTED) == 0) {
1356                 const char *device = NULL;
1357                 const char *address = NULL;
1358                 bluetooth_network_device_info_t network_info;
1359
1360                 g_variant_get(parameters, "(i&s&s)", &result, &device, &address);
1361
1362                 memset(&network_info, 0x00, sizeof(bluetooth_network_device_info_t));
1363
1364                 _bt_convert_addr_string_to_type(network_info.device_address.addr,
1365                                                 address);
1366
1367                 _bt_print_device_address_t(&network_info.device_address);
1368
1369                 _bt_common_event_cb(BLUETOOTH_EVENT_NETWORK_SERVER_DISCONNECTED,
1370                                 result, &network_info,
1371                                 event_info->cb, event_info->user_data);
1372         }
1373 }
1374
1375 void __bt_avrcp_event_filter(GDBusConnection *connection,
1376                                                  const gchar *sender_name,
1377                                                  const gchar *object_path,
1378                                                  const gchar *interface_name,
1379                                                  const gchar *signal_name,
1380                                                  GVariant *parameters,
1381                                                  gpointer user_data)
1382 {
1383         bt_event_info_t *event_info;
1384         int result = BLUETOOTH_ERROR_NONE;
1385         event_info = (bt_event_info_t *)user_data;
1386         ret_if(event_info == NULL);
1387
1388         if (strcasecmp(object_path, BT_AVRCP_PATH) != 0)
1389                 return;
1390         if (strcasecmp(interface_name, BT_EVENT_SERVICE) != 0)
1391                 return;
1392
1393         ret_if(signal_name == NULL);
1394
1395         if (strcasecmp(signal_name, BT_AVRCP_CONNECTED) == 0) {
1396                 char *address = NULL;
1397
1398                 g_variant_get(parameters, "(i&s)", &result, &address);
1399
1400                 _bt_avrcp_event_cb(BLUETOOTH_EVENT_AVRCP_CONNECTED,
1401                                 result, address,
1402                                 event_info->cb, event_info->user_data);
1403         } else if (strcasecmp(signal_name, BT_AVRCP_DISCONNECTED) == 0) {
1404                 char *address = NULL;
1405
1406                 g_variant_get(parameters, "(i&s)", &result, &address);
1407
1408                 _bt_avrcp_event_cb(BLUETOOTH_EVENT_AVRCP_DISCONNECTED,
1409                                 result, address,
1410                                 event_info->cb, event_info->user_data);
1411         } else if (strcasecmp(signal_name, BT_MEDIA_SHUFFLE_STATUS) == 0) {
1412                 unsigned int status;
1413
1414                 g_variant_get(parameters, "(u)", &status);
1415                 _bt_avrcp_event_cb(BLUETOOTH_EVENT_AVRCP_SETTING_SHUFFLE_STATUS,
1416                                 result, &status,
1417                                 event_info->cb, event_info->user_data);
1418         } else if (strcasecmp(signal_name, BT_MEDIA_EQUALIZER_STATUS) == 0) {
1419                 unsigned int status;
1420
1421                 g_variant_get(parameters, "(u)", &status);
1422                 _bt_avrcp_event_cb(BLUETOOTH_EVENT_AVRCP_SETTING_EQUALIZER_STATUS,
1423                                 result, &status,
1424                                 event_info->cb, event_info->user_data);
1425         } else if (strcasecmp(signal_name, BT_MEDIA_REPEAT_STATUS) == 0) {
1426                 unsigned int status;
1427
1428                 g_variant_get(parameters, "(u)", &status);
1429                 _bt_avrcp_event_cb(BLUETOOTH_EVENT_AVRCP_SETTING_REPEAT_STATUS,
1430                                 result, &status,
1431                                 event_info->cb, event_info->user_data);
1432         }  else if (strcasecmp(signal_name, BT_MEDIA_SCAN_STATUS) == 0) {
1433                 unsigned int status;
1434
1435                 g_variant_get(parameters, "(u)", &status);
1436                 _bt_avrcp_event_cb(BLUETOOTH_EVENT_AVRCP_SETTING_SCAN_STATUS,
1437                                 result, &status,
1438                                 event_info->cb, event_info->user_data);
1439         }
1440 }
1441
1442 void __bt_avrcp_control_event_filter(GDBusConnection *connection,
1443                                                 const gchar *sender_name,
1444                                                 const gchar *object_path,
1445                                                 const gchar *interface_name,
1446                                                 const gchar *signal_name,
1447                                                 GVariant *parameters,
1448                                                 gpointer user_data)
1449 {
1450         bt_event_info_t *event_info;
1451         int result = BLUETOOTH_ERROR_NONE;
1452         event_info = (bt_event_info_t *)user_data;
1453         ret_if(event_info == NULL);
1454
1455         if (strcasecmp(object_path, BT_AVRCP_CONTROL_PATH) != 0)
1456                 return;
1457         if (strcasecmp(interface_name, BT_EVENT_SERVICE) != 0)
1458                 return;
1459
1460         ret_if(signal_name == NULL);
1461
1462         if (strcasecmp(signal_name, BT_AVRCP_CONNECTED) == 0) {
1463                 char *address = NULL;
1464
1465                 g_variant_get(parameters, "(i&s)", &result, &address);
1466
1467                 _bt_avrcp_event_cb(BLUETOOTH_EVENT_AVRCP_CONTROL_CONNECTED,
1468                                 result, address,
1469                                 event_info->cb, event_info->user_data);
1470         } else if (strcasecmp(signal_name, BT_AVRCP_DISCONNECTED) == 0) {
1471                 char *address = NULL;
1472
1473                 g_variant_get(parameters, "(i&s)", &result, &address);
1474
1475                 _bt_avrcp_event_cb(BLUETOOTH_EVENT_AVRCP_CONTROL_DISCONNECTED,
1476                                 result, address,
1477                                 event_info->cb, event_info->user_data);
1478         } else if (strcasecmp(signal_name, BT_MEDIA_SHUFFLE_STATUS) == 0) {
1479                 unsigned int status;
1480
1481                 g_variant_get(parameters, "(u)", &status);
1482                 _bt_avrcp_event_cb(BLUETOOTH_EVENT_AVRCP_CONTROL_SHUFFLE_STATUS,
1483                                 result, &status,
1484                                 event_info->cb, event_info->user_data);
1485         } else if (strcasecmp(signal_name, BT_MEDIA_EQUALIZER_STATUS) == 0) {
1486                 unsigned int status;
1487
1488                 g_variant_get(parameters, "(u)", &status);
1489                 _bt_avrcp_event_cb(BLUETOOTH_EVENT_AVRCP_CONTROL_EQUALIZER_STATUS,
1490                                 result, &status,
1491                                 event_info->cb, event_info->user_data);
1492         } else if (strcasecmp(signal_name, BT_MEDIA_REPEAT_STATUS) == 0) {
1493                 unsigned int status;
1494
1495                 g_variant_get(parameters, "(u)", &status);
1496                 _bt_avrcp_event_cb(BLUETOOTH_EVENT_AVRCP_CONTROL_REPEAT_STATUS,
1497                                 result, &status,
1498                                 event_info->cb, event_info->user_data);
1499         }  else if (strcasecmp(signal_name, BT_MEDIA_SCAN_STATUS) == 0) {
1500                 unsigned int status;
1501
1502                 g_variant_get(parameters, "(u)", &status);
1503                 _bt_avrcp_event_cb(BLUETOOTH_EVENT_AVRCP_CONTROL_SCAN_STATUS,
1504                                 result, &status,
1505                                 event_info->cb, event_info->user_data);
1506         } else if (strcasecmp(signal_name, BT_MEDIA_PLAY_STATUS) == 0) {
1507                 unsigned int status;
1508
1509                 g_variant_get(parameters, "(u)", &status);
1510                 _bt_avrcp_event_cb(BLUETOOTH_EVENT_AVRCP_PLAY_STATUS_CHANGED,
1511                                 result, &status,
1512                                 event_info->cb, event_info->user_data);
1513         } else if (strcasecmp(signal_name, BT_MEDIA_POSITION_STATUS) == 0) {
1514                 unsigned int status;
1515
1516                 g_variant_get(parameters, "(u)", &status);
1517                 _bt_avrcp_event_cb(BLUETOOTH_EVENT_AVRCP_SONG_POSITION_STATUS,
1518                                 result, &status,
1519                                 event_info->cb, event_info->user_data);
1520         } else if (strcasecmp(signal_name, BT_MEDIA_TRACK_CHANGE) == 0) {
1521                 media_metadata_attributes_t metadata;
1522                 const char *title;
1523                 const char *artist;
1524                 const char *album;
1525                 const char *genre;
1526                 unsigned int total_tracks;
1527                 unsigned int number;
1528                 unsigned int duration;
1529
1530                 g_variant_get(parameters, "(&s&s&s&suuu)", &title,
1531                                                 &artist, &album, &genre,
1532                                                 &total_tracks, &number,
1533                                                 &duration);
1534                 memset(&metadata, 0x00, sizeof(media_metadata_attributes_t));
1535
1536                 metadata.title = title;
1537                 metadata.artist = artist;
1538                 metadata.album = album;
1539                 metadata.genre = genre;
1540                 metadata.total_tracks = total_tracks;
1541                 metadata.number = number;
1542                 metadata.duration = (int64_t)duration;
1543
1544                 _bt_avrcp_event_cb(BLUETOOTH_EVENT_AVRCP_TRACK_CHANGED,
1545                                 result, &metadata,
1546                                 event_info->cb, event_info->user_data);
1547         }
1548 }
1549
1550 void __bt_opp_client_event_filter(GDBusConnection *connection,
1551                                                  const gchar *sender_name,
1552                                                  const gchar *object_path,
1553                                                  const gchar *interface_name,
1554                                                  const gchar *signal_name,
1555                                                  GVariant *parameters,
1556                                                  gpointer user_data)
1557 {
1558         bt_event_info_t *event_info;
1559         int result = BLUETOOTH_ERROR_NONE;
1560         event_info = (bt_event_info_t *)user_data;
1561         ret_if(event_info == NULL);
1562
1563         if (strcasecmp(object_path, BT_OPP_CLIENT_PATH) != 0)
1564                 return;
1565         if (strcasecmp(interface_name, BT_EVENT_SERVICE) != 0)
1566                 return;
1567
1568         ret_if(signal_name == NULL);
1569
1570         if (strcasecmp(signal_name, BT_OPP_CONNECTED) == 0) {
1571                 const char *address = NULL;
1572                 int request_id = 0;
1573                 bluetooth_device_address_t dev_address = { {0} };
1574
1575                 g_variant_get(parameters, "(i&si)", &result,
1576                                                 &address, &request_id);
1577
1578                 if (__bt_is_request_id_exist(request_id) == FALSE) {
1579                         BT_ERR("Different request id!");
1580                         return;
1581                 }
1582
1583                 _bt_convert_addr_string_to_type(dev_address.addr,
1584                                                 address);
1585
1586                 _bt_common_event_cb(BLUETOOTH_EVENT_OPC_CONNECTED,
1587                                 result, &dev_address,
1588                                 event_info->cb, event_info->user_data);
1589
1590                 if (result != BLUETOOTH_ERROR_NONE) {
1591                         __bt_remove_push_request_id(request_id);
1592                 }
1593         } else if (strcasecmp(signal_name, BT_OPP_DISCONNECTED) == 0) {
1594                 const char *address = NULL;
1595                 int request_id = 0;
1596                 bluetooth_device_address_t dev_address = { {0} };
1597
1598                 g_variant_get(parameters, "(i&si)", &result, &address,
1599                                                         &request_id);
1600
1601                 if (__bt_is_request_id_exist(request_id) == FALSE) {
1602                         BT_ERR("Different request id!");
1603                         return;
1604                 }
1605
1606                 _bt_convert_addr_string_to_type(dev_address.addr,
1607                                                 address);
1608
1609                 _bt_common_event_cb(BLUETOOTH_EVENT_OPC_DISCONNECTED,
1610                                 result, &dev_address,
1611                                 event_info->cb, event_info->user_data);
1612
1613                 __bt_remove_push_request_id(request_id);
1614         } else if (strcasecmp(signal_name, BT_TRANSFER_STARTED) == 0) {
1615                 const char *file_name = NULL;
1616                 int request_id = 0;
1617                 guint64 size = 0;
1618                 bt_opc_transfer_info_t transfer_info;
1619
1620                 g_variant_get(parameters, "(i&sti)", &result, &file_name,
1621                                                 &size, &request_id);
1622
1623                 if (__bt_is_request_id_exist(request_id) == FALSE) {
1624                         BT_ERR("Different request id!");
1625                         return;
1626                 }
1627
1628                 memset(&transfer_info, 0x00, sizeof(bt_opc_transfer_info_t));
1629
1630                 transfer_info.filename = g_strdup(file_name);
1631                 transfer_info.size = size;
1632
1633                 _bt_common_event_cb(BLUETOOTH_EVENT_OPC_TRANSFER_STARTED,
1634                                 result, &transfer_info,
1635                                 event_info->cb, event_info->user_data);
1636
1637                 g_free(transfer_info.filename);
1638         } else if (strcasecmp(signal_name, BT_TRANSFER_PROGRESS) == 0) {
1639                 const char *file_name = NULL;
1640                 int request_id = 0;
1641                 guint64 size = 0;
1642                 int progress = 0;
1643                 bt_opc_transfer_info_t transfer_info;
1644
1645                 g_variant_get(parameters, "(i&stii)", &result,
1646                         &file_name, &size, &progress, &request_id);
1647
1648                 if (__bt_is_request_id_exist(request_id) == FALSE) {
1649                         BT_ERR("Different request id!");
1650                         return;
1651                 }
1652
1653                 memset(&transfer_info, 0x00, sizeof(bt_opc_transfer_info_t));
1654
1655                 transfer_info.filename = g_strdup(file_name);
1656                 transfer_info.size = size;
1657                 transfer_info.percentage = progress;
1658
1659                 _bt_common_event_cb(BLUETOOTH_EVENT_OPC_TRANSFER_PROGRESS,
1660                                 result, &transfer_info,
1661                                 event_info->cb, event_info->user_data);
1662
1663                 g_free(transfer_info.filename);
1664         } else if (strcasecmp(signal_name, BT_TRANSFER_COMPLETED) == 0) {
1665                 const char *file_name = NULL;
1666                 int request_id = 0;
1667                 guint64 size = 0;
1668                 bt_opc_transfer_info_t transfer_info;
1669
1670                 g_variant_get(parameters, "(i&sti)", &result,
1671                                         &file_name, &size, &request_id);
1672
1673                 if (__bt_is_request_id_exist(request_id) == FALSE) {
1674                         BT_ERR("Different request id!");
1675                         return;
1676                 }
1677
1678                 memset(&transfer_info, 0x00, sizeof(bt_opc_transfer_info_t));
1679
1680                 transfer_info.filename = g_strdup(file_name);
1681                 transfer_info.size = size;
1682
1683                 _bt_common_event_cb(BLUETOOTH_EVENT_OPC_TRANSFER_COMPLETE,
1684                                 result, &transfer_info,
1685                                 event_info->cb, event_info->user_data);
1686
1687                 g_free(transfer_info.filename);
1688         }
1689 }
1690
1691 void __bt_opp_server_event_filter(GDBusConnection *connection,
1692                                                  const gchar *sender_name,
1693                                                  const gchar *object_path,
1694                                                  const gchar *interface_name,
1695                                                  const gchar *signal_name,
1696                                                  GVariant *parameters,
1697                                                  gpointer user_data)
1698 {
1699         bt_event_info_t *event_info;
1700         int result = BLUETOOTH_ERROR_NONE;
1701         event_info = (bt_event_info_t *)user_data;
1702         ret_if(event_info == NULL);
1703
1704         if (strcasecmp(object_path, BT_OPP_SERVER_PATH) != 0)
1705                 return;
1706         if (strcasecmp(interface_name, BT_EVENT_SERVICE) != 0)
1707                 return;
1708
1709         ret_if(signal_name == NULL);
1710
1711         if (strcasecmp(signal_name, BT_TRANSFER_AUTHORIZED) == 0) {
1712                 /* Native only event */
1713                 const char *file_name = NULL;
1714                 guint64 size = 0;
1715                 bt_obex_server_authorize_into_t auth_info;
1716
1717                 g_variant_get(parameters, "(i&st)", &result, &file_name, &size);
1718
1719                 /* OSP server: Don't get this event */
1720                 ret_if(obex_server_id == BT_CUSTOM_SERVER);
1721
1722                 memset(&auth_info, 0x00, sizeof(bt_obex_server_authorize_into_t));
1723
1724                 auth_info.filename = g_strdup(file_name);
1725                 auth_info.length = size;
1726
1727                 _bt_common_event_cb(BLUETOOTH_EVENT_OBEX_SERVER_TRANSFER_AUTHORIZE,
1728                                 result, &auth_info,
1729                                 event_info->cb, event_info->user_data);
1730
1731                 g_free(auth_info.filename);
1732         } else if (strcasecmp(signal_name, BT_CONNECTION_AUTHORIZED) == 0) {
1733                 /* OSP only event */
1734                 const char *address = NULL;
1735                 const char *name = NULL;
1736                 bluetooth_device_address_t dev_address = { {0} };
1737
1738                 g_variant_get(parameters, "(i&s&s)", &result, &address, &name);
1739
1740                 /* Native server: Don't get this event */
1741                 ret_if(obex_server_id == BT_NATIVE_SERVER);
1742
1743                 _bt_convert_addr_string_to_type(dev_address.addr,
1744                                                 address);
1745
1746                 _bt_common_event_cb(BLUETOOTH_EVENT_OBEX_SERVER_CONNECTION_AUTHORIZE,
1747                                 result, &dev_address,
1748                                 event_info->cb, event_info->user_data);
1749         } else if (strcasecmp(signal_name, BT_TRANSFER_CONNECTED) == 0) {
1750
1751                 g_variant_get(parameters, "(i)", &result);
1752
1753                 _bt_common_event_cb(BLUETOOTH_EVENT_OBEX_SERVER_TRANSFER_CONNECTED,
1754                                         result, NULL, event_info->cb,
1755                                         event_info->user_data);
1756         } else if (strcasecmp(signal_name, BT_TRANSFER_DISCONNECTED) == 0) {
1757
1758                 g_variant_get(parameters, "(i)", &result);
1759
1760                 _bt_common_event_cb(BLUETOOTH_EVENT_OBEX_SERVER_TRANSFER_DISCONNECTED,
1761                                         result, NULL, event_info->cb,
1762                                         event_info->user_data);
1763         } else if (strcasecmp(signal_name, BT_TRANSFER_STARTED) == 0) {
1764                 const char *file_name = NULL;
1765                 const char *type = NULL;
1766                 int transfer_id = 0;
1767                 int server_type = 0; /* bt_server_type_t */
1768                 guint64 size = 0;
1769                 bt_obex_server_transfer_info_t transfer_info;
1770
1771                 g_variant_get(parameters, "(i&s&stii)", &result, &file_name,
1772                                 &type, &size, &transfer_id, &server_type);
1773
1774                 /* Other server's event */
1775                 ret_if(obex_server_id != server_type &&
1776                         server_type != BT_FTP_SERVER);
1777
1778                 memset(&transfer_info, 0x00, sizeof(bt_obex_server_transfer_info_t));
1779
1780                 transfer_info.filename = g_strdup(file_name);
1781                 transfer_info.type = g_strdup(type);
1782                 transfer_info.file_size = size;
1783                 transfer_info.transfer_id = transfer_id;
1784                 transfer_info.server_type = (server_type == BT_FTP_SERVER) ?
1785                                                 FTP_SERVER : OPP_SERVER;
1786
1787                 _bt_common_event_cb(BLUETOOTH_EVENT_OBEX_SERVER_TRANSFER_STARTED,
1788                                 result, &transfer_info,
1789                                 event_info->cb, event_info->user_data);
1790
1791                 g_free(transfer_info.filename);
1792                 g_free(transfer_info.type);
1793         } else if (strcasecmp(signal_name, BT_TRANSFER_PROGRESS) == 0) {
1794                 const char *file_name = NULL;
1795                 const char *type = NULL;
1796                 int transfer_id = 0;
1797                 int progress = 0;
1798                 int server_type = 0; /* bt_server_type_t */
1799                 guint64 size = 0;
1800                 bt_obex_server_transfer_info_t transfer_info;
1801
1802                 g_variant_get(parameters, "(i&s&stiii)", &result, &file_name,
1803                                                 &type, &size, &transfer_id,
1804                                                 &progress, &server_type);
1805
1806                 /* Other server's event */
1807                 ret_if(obex_server_id != server_type &&
1808                         server_type != BT_FTP_SERVER);
1809
1810                 memset(&transfer_info, 0x00, sizeof(bt_obex_server_transfer_info_t));
1811
1812                 transfer_info.filename = g_strdup(file_name);
1813                 transfer_info.type = g_strdup(type);
1814                 transfer_info.file_size = size;
1815                 transfer_info.transfer_id = transfer_id;
1816                 transfer_info.percentage = progress;
1817                 transfer_info.server_type = (server_type == BT_FTP_SERVER) ?
1818                                                 FTP_SERVER : OPP_SERVER;
1819
1820                 _bt_common_event_cb(BLUETOOTH_EVENT_OBEX_SERVER_TRANSFER_PROGRESS,
1821                                 result, &transfer_info,
1822                                 event_info->cb, event_info->user_data);
1823
1824                 g_free(transfer_info.filename);
1825                 g_free(transfer_info.type);
1826         } else if (strcasecmp(signal_name, BT_TRANSFER_COMPLETED) == 0) {
1827                 const char *file_name = NULL;
1828                 const char *device_name = NULL;
1829                 const char *type = NULL;
1830                 const char *file_path;
1831                 int transfer_id = 0;
1832                 int server_type = 0; /* bt_server_type_t */
1833                 guint64 size = 0;
1834                 bt_obex_server_transfer_info_t transfer_info;
1835
1836                 g_variant_get(parameters, "(i&s&s&s&stii)", &result, &file_name,
1837                                         &type, &device_name, &file_path, &size,
1838                                         &transfer_id, &server_type);
1839
1840                 /* Other server's event */
1841                 ret_if(obex_server_id != server_type &&
1842                         server_type != BT_FTP_SERVER);
1843
1844                 memset(&transfer_info, 0x00, sizeof(bt_obex_server_transfer_info_t));
1845
1846                 transfer_info.filename = g_strdup(file_name);
1847                 transfer_info.type = g_strdup(type);
1848                 transfer_info.device_name = g_strdup(device_name);
1849                 transfer_info.file_path = g_strdup(file_path);
1850                 transfer_info.file_size = size;
1851                 transfer_info.transfer_id = transfer_id;
1852                 transfer_info.server_type = (server_type == BT_FTP_SERVER) ?
1853                                                 FTP_SERVER : OPP_SERVER;
1854
1855                 _bt_common_event_cb(BLUETOOTH_EVENT_OBEX_SERVER_TRANSFER_COMPLETED,
1856                                 result, &transfer_info,
1857                                 event_info->cb, event_info->user_data);
1858
1859                 g_free(transfer_info.filename);
1860                 g_free(transfer_info.type);
1861                 g_free(transfer_info.device_name);
1862                 g_free(transfer_info.file_path);
1863         }
1864 }
1865
1866 void __bt_pbap_client_event_filter(GDBusConnection *connection,
1867                                                  const gchar *sender_name,
1868                                                  const gchar *object_path,
1869                                                  const gchar *interface_name,
1870                                                  const gchar *signal_name,
1871                                                  GVariant *parameters,
1872                                                  gpointer user_data)
1873 {
1874         bt_event_info_t *event_info;
1875         int result = BLUETOOTH_ERROR_NONE;
1876         event_info = (bt_event_info_t *)user_data;
1877         ret_if(event_info == NULL);
1878
1879         if (strcasecmp(object_path, BT_PBAP_CLIENT_PATH) != 0)
1880                 return;
1881         if (strcasecmp(interface_name, BT_EVENT_SERVICE) != 0)
1882                 return;
1883
1884         ret_if(signal_name == NULL);
1885         BT_DBG("Type: %s", g_variant_get_type_string(parameters));
1886         if (strcasecmp(signal_name, BT_PBAP_CONNECTED) == 0) {
1887                 bt_pbap_connected_t connected = { { { 0 }, }, };
1888                 char *address = NULL;
1889
1890                 g_variant_get(parameters, "(is)", &result, &address);
1891                 BT_DBG("address: %s", address);
1892
1893                 _bt_convert_addr_string_to_type(connected.btaddr.addr,
1894                                                 address);
1895                 if (result == 0)
1896                         connected.connected = 1;
1897                 else
1898                         connected.connected = 0;
1899
1900                 _bt_common_event_cb(BLUETOOTH_PBAP_CONNECTED,
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                 unsigned int 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                 unsigned int 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         GError *error = NULL;
2524         GDBusConnection *connection_type;
2525         GDBusSignalCallback event_func;
2526         bt_event_info_t *cb_data;
2527         const char *path;
2528         const char *interface = BT_EVENT_SERVICE;
2529
2530         if (is_initialized == FALSE)
2531                 _bt_init_event_handler();
2532
2533         if (__bt_event_is_registered(event_type) == TRUE) {
2534                 BT_ERR("The event is already registed");
2535                 return BLUETOOTH_ERROR_ALREADY_INITIALIZED;
2536         }
2537
2538         switch (event_type) {
2539         case BT_ADAPTER_EVENT:
2540                 event_func = __bt_adapter_event_filter;
2541                 path = BT_ADAPTER_PATH;
2542                 break;
2543         case BT_LE_ADAPTER_EVENT:
2544                 event_func = __bt_adapter_le_event_filter;
2545                 path = BT_LE_ADAPTER_PATH;
2546                 break;
2547         case BT_DEVICE_EVENT:
2548                 event_func = __bt_device_event_filter;
2549                 path = BT_DEVICE_PATH;
2550                 break;
2551         case BT_HID_EVENT:
2552                 event_func = __bt_hid_event_filter;
2553                 path = BT_HID_PATH;
2554                 break;
2555         case BT_HEADSET_EVENT:
2556                 event_func = __bt_headset_event_filter;
2557                 path = BT_HEADSET_PATH;
2558                 break;
2559         case BT_NETWORK_EVENT:
2560                 event_func = __bt_network_event_filter;
2561                 path = BT_NETWORK_PATH;
2562                 break;
2563         case BT_AVRCP_EVENT:
2564                 event_func = __bt_avrcp_event_filter;
2565                 path = BT_AVRCP_PATH;
2566                 break;
2567         case BT_AVRCP_CONTROL_EVENT:
2568                 event_func = __bt_avrcp_control_event_filter;
2569                 path = BT_AVRCP_CONTROL_PATH;
2570                 break;
2571         case BT_OPP_CLIENT_EVENT:
2572                 event_func = __bt_opp_client_event_filter;
2573                 path = BT_OPP_CLIENT_PATH;
2574                 break;
2575         case BT_OPP_SERVER_EVENT:
2576                 event_func = __bt_opp_server_event_filter;
2577                 path = BT_OPP_SERVER_PATH;
2578                 break;
2579         case BT_PBAP_CLIENT_EVENT:
2580                 event_func = __bt_pbap_client_event_filter;
2581                 path = BT_PBAP_CLIENT_PATH;
2582                 break;
2583         case BT_RFCOMM_CLIENT_EVENT:
2584                 event_func = __bt_rfcomm_client_event_filter;
2585                 path = BT_RFCOMM_CLIENT_PATH;
2586                 break;
2587         case BT_RFCOMM_SERVER_EVENT:
2588                 event_func = __bt_rfcomm_server_event_filter;
2589                 path = BT_RFCOMM_SERVER_PATH;
2590                 break;
2591         case BT_HF_AGENT_EVENT:
2592                 BT_DBG("BT_HF_AGENT_EVENT\n");
2593                 event_func = __bt_hf_agent_event_filter;
2594                 path = BT_HF_AGENT_PATH;
2595                 interface = BT_HF_SERVICE_INTERFACE;
2596                 break;
2597         case BT_A2DP_SOURCE_EVENT:
2598                 BT_DBG("BT_A2DP_SOURCE_EVENT");
2599                 event_func = __bt_a2dp_source_event_filter;
2600                 path = BT_A2DP_SOURCE_PATH;
2601                 break;
2602         case BT_HID_DEVICE_EVENT:
2603                 BT_DBG("BT_HID_DEVICE_EVENT");
2604                 event_func = __bt_hid_device_event_filter;
2605                 path = BT_HID_DEVICE_PATH;
2606                 break;
2607 #ifdef GATT_NO_RELAY
2608         case BT_GATT_BLUEZ_EVENT:
2609                 BT_DBG("BT_GATT_BLUEZ_EVENT");
2610                 event_func = __bt_device_event_filter;
2611                 interface = BT_GATT_CHARACTERISTIC_INTERFACE;
2612                 path = NULL;
2613                 break;
2614 #endif
2615         default:
2616                 BT_ERR("Unknown event");
2617                 return BLUETOOTH_ERROR_INTERNAL;
2618         }
2619
2620         connection_type = _bt_gdbus_get_system_gconn();
2621         if (connection_type == NULL)
2622                 return BLUETOOTH_ERROR_INTERNAL;
2623
2624         cb_data = g_new0(bt_event_info_t, 1);
2625
2626         cb_data->event_type = event_type;
2627         cb_data->cb = event_cb;
2628         cb_data->user_data = user_data;
2629
2630         cb_data->id = g_dbus_connection_signal_subscribe(connection_type,
2631                                 NULL, interface, NULL, path, NULL, 0,
2632                                 event_func, cb_data, NULL);
2633
2634         event_list = g_slist_append(event_list, cb_data);
2635
2636         return BLUETOOTH_ERROR_NONE;
2637 }
2638
2639 int _bt_unregister_event(int event_type)
2640 {
2641         GDBusConnection *connection_type;
2642         bt_event_info_t *cb_data;
2643
2644         if (is_initialized == FALSE) {
2645                 BT_ERR("Event is not registered");
2646                 return BLUETOOTH_ERROR_NOT_INITIALIZED;
2647         }
2648
2649         if (__bt_event_is_registered(event_type) == FALSE) {
2650                 BT_ERR("Not registered event");
2651                 return BLUETOOTH_ERROR_INTERNAL;
2652         }
2653
2654         cb_data = _bt_event_get_cb_data(event_type);
2655
2656         if (cb_data == NULL) {
2657                 BT_ERR("No matched event data");
2658                 return BLUETOOTH_ERROR_INTERNAL;
2659         }
2660
2661         connection_type = _bt_gdbus_get_system_gconn();
2662
2663         event_list = g_slist_remove(event_list, (void *)cb_data);
2664
2665         retv_if(connection_type == NULL, BLUETOOTH_ERROR_INTERNAL);
2666
2667         g_dbus_connection_signal_unsubscribe(connection_type, cb_data->id);
2668
2669         __bt_event_data_free((void *)cb_data);
2670
2671         return BLUETOOTH_ERROR_NONE;
2672 }
2673
2674 static void __bt_name_owner_changed(GDBusConnection *connection,
2675                                                  const gchar *sender_name,
2676                                                  const gchar *object_path,
2677                                                  const gchar *interface_name,
2678                                                  const gchar *signal_name,
2679                                                  GVariant *parameters,
2680                                                  gpointer user_data)
2681 {
2682         const char *name = NULL;
2683         const char *old_owner = NULL;
2684         const char *new_owner = NULL;
2685         bt_event_info_t *event_info;
2686
2687         g_variant_get(parameters, "(&s&s&s)", &name, &old_owner, &new_owner);
2688
2689         if (g_strcmp0(name, BT_DBUS_NAME) == 0 &&
2690                         (new_owner != NULL && *new_owner == '\0')) {
2691                 BT_DBG("bt-service is terminated");
2692                 event_info = _bt_event_get_cb_data(BT_ADAPTER_EVENT);
2693                 if (event_info == NULL)
2694                         return;
2695
2696                 if (disable_timer_id > 0)
2697                         g_source_remove(disable_timer_id);
2698
2699                 disable_timer_id = g_timeout_add(BT_RELIABLE_DISABLE_TIME,
2700                                 (GSourceFunc)__bt_reliable_disable_cb,
2701                                 event_info);
2702         }
2703 }
2704
2705 void _bt_register_name_owner_changed(void)
2706 {
2707         GDBusConnection *connection_type;
2708
2709         connection_type = _bt_gdbus_get_system_gconn();
2710         if (connection_type == NULL) {
2711                 BT_ERR("Unable to get the bus");
2712                 return;
2713         }
2714         owner_sig_id = g_dbus_connection_signal_subscribe(connection_type,
2715                                 NULL, DBUS_INTERFACE_DBUS,
2716                                 BT_NAME_OWNER_CHANGED, NULL, NULL, 0,
2717                                 __bt_name_owner_changed, NULL, NULL);
2718 }
2719
2720 void _bt_unregister_name_owner_changed(void)
2721 {
2722         GDBusConnection *connection_type;
2723
2724         connection_type = _bt_gdbus_get_system_gconn();
2725         if (connection_type != NULL && owner_sig_id != -1) {
2726                 g_dbus_connection_signal_unsubscribe(connection_type,
2727                                                         owner_sig_id);
2728                 owner_sig_id = -1;
2729         }
2730 }