bt-api/bt-event-handler.c

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