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