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