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_pbap_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
1990         ret_if(event_info == NULL);
1991
1992         if (strcasecmp(object_path, BT_PBAP_CLIENT_PATH) != 0)
1993                 return;
1994
1995         if (strcasecmp(interface_name, BT_EVENT_SERVICE) != 0)
1996                 return;
1997
1998         ret_if(signal_name == NULL);
1999
2000         BT_DBG("Type: %s", g_variant_get_type_string(parameters));
2001
2002         if (strcasecmp(signal_name, BT_PBAP_CONNECTED) == 0) {
2003                 bt_pbap_connected_t connected = { { { 0 }, }, };
2004                 char *address = NULL;
2005
2006                 g_variant_get(parameters, "(i&s)", &result, &address);
2007                 BT_DBG("address: %s", address);
2008
2009                 _bt_convert_addr_string_to_type(connected.btaddr.addr,
2010                                                 address);
2011                 if (result == 0)
2012                         connected.connected = 1;
2013                 else
2014                         connected.connected = 0;
2015
2016                 _bt_common_event_cb(BLUETOOTH_PBAP_CONNECTED,
2017                                 result, &connected,
2018                                 event_info->cb, event_info->user_data);
2019         } else if (strcasecmp(signal_name, BT_PBAP_DISCONNECTED) == 0) {
2020                 bt_pbap_connected_t disconnected = { { { 0 }, }, };
2021                 char *address = NULL;
2022
2023                 g_variant_get(parameters, "(i&s)", &result, &address);
2024                 BT_DBG("address: %s", address);
2025
2026                 _bt_convert_addr_string_to_type(disconnected.btaddr.addr,
2027                                                 address);
2028                 disconnected.connected = 0;
2029
2030                 _bt_common_event_cb(BLUETOOTH_PBAP_DISCONNECTED,
2031                                 result, &disconnected,
2032                                 event_info->cb, event_info->user_data);
2033         } else if (strcasecmp(signal_name, BT_PBAP_PHONEBOOK_SIZE) == 0) {
2034                 bt_pbap_phonebook_size_t pb_size = { { { 0 }, }, };
2035                 char *address = NULL;
2036                 int size = 0;
2037
2038                 g_variant_get(parameters, "(i&si)", &result, &address, &size);
2039
2040                 BT_DBG("address: %s, size: %d", address, size);
2041
2042                 _bt_convert_addr_string_to_type(pb_size.btaddr.addr,
2043                                                 address);
2044                 pb_size.size = size;
2045
2046                 _bt_common_event_cb(BLUETOOTH_PBAP_PHONEBOOK_SIZE,
2047                                 result, &pb_size,
2048                                 event_info->cb, event_info->user_data);
2049         } else if (strcasecmp(signal_name, BT_PBAP_PHONEBOOK_PULL) == 0) {
2050                 bt_pbap_phonebook_pull_t pb_pull = { { { 0 } }, };
2051                 char *address = NULL;
2052                 char *vcf_file = NULL;
2053                 int success = -1;
2054
2055                 g_variant_get(parameters, "(i&s&si)", &result, &address, &vcf_file, &success);
2056
2057                 BT_DBG("address: %s, vcf_file: %s, success: %d",
2058                                                 address, vcf_file, success);
2059
2060                 _bt_convert_addr_string_to_type(pb_pull.btaddr.addr,
2061                                                 address);
2062                 pb_pull.vcf_file = vcf_file;
2063                 pb_pull.success = success;
2064                 _bt_common_event_cb(BLUETOOTH_PBAP_PHONEBOOK_PULL,
2065                                 result, &pb_pull,
2066                                 event_info->cb, event_info->user_data);
2067         } else if (strcasecmp(signal_name, BT_PBAP_VCARD_LIST) == 0) {
2068                 bt_pbap_vcard_list_t vc_list = { { { 0 } }, };
2069                 char *address = NULL;
2070                 gsize count = 0;
2071                 gchar **list = NULL;
2072                 GVariant *string_var;
2073                 int success = -1;
2074                 int i = 0;
2075
2076                 g_variant_get(parameters, "(i&sv)", &result, &address, &string_var);
2077
2078                 list = (gchar **)g_variant_get_strv(string_var, &count);
2079
2080                 success = !result;
2081
2082                 for (i = 0; i < count; i++)
2083                         BT_DBG("%s", list[i]);
2084
2085                 BT_DBG("address: %s, result: %d, count: %d, success: %d",
2086                                         address, result, count, success);
2087
2088                 _bt_convert_addr_string_to_type(vc_list.btaddr.addr,
2089                                                 address);
2090                 vc_list.vcards = list;
2091                 vc_list.length = count;
2092                 vc_list.success = success;
2093                 _bt_common_event_cb(BLUETOOTH_PBAP_VCARD_LIST,
2094                                 result, &vc_list,
2095                                 event_info->cb, event_info->user_data);
2096
2097                 g_variant_unref(string_var);
2098                 //free lists
2099         } else if (strcasecmp(signal_name, BT_PBAP_VCARD_PULL) == 0) {
2100                 bt_pbap_vcard_pull_t vc_pull = { { { 0 } }, };
2101                 char *address = NULL;
2102                 char *vcf_file = NULL;
2103                 int success = -1;
2104
2105                 g_variant_get(parameters, "(i&s&si)",
2106                                         &result, &address, &vcf_file, &success);
2107
2108                 BT_DBG("address: %s, vcf_file: %s, success: %d",
2109                                                 address, vcf_file, success);
2110
2111                 _bt_convert_addr_string_to_type(vc_pull.btaddr.addr, address);
2112                 vc_pull.vcf_file = vcf_file;
2113                 vc_pull.success = success;
2114                 _bt_common_event_cb(BLUETOOTH_PBAP_VCARD_PULL,
2115                                 result, &vc_pull,
2116                                 event_info->cb, event_info->user_data);
2117         } else if (strcasecmp(signal_name, BT_PBAP_SEARCH_PHONEBOOK) == 0) {
2118                 bt_pbap_phonebook_search_list_t vc_list = { { { 0 } }, };
2119                 char *address = NULL;
2120                 gsize count = 0;
2121                 gchar **list = NULL;
2122                 GVariant *string_var;
2123                 int success = -1;
2124                 int i = 0;
2125
2126                 g_variant_get(parameters, "(i&s@as)", &result, &address, &string_var);
2127
2128                 list = (gchar **)g_variant_get_strv(string_var, &count);
2129                 success = !result;
2130                 for (i = 0; i < count; i++)
2131                         BT_DBG("%s", list[i]);
2132
2133                 BT_DBG("address: %s success: %d", address, success);
2134
2135                 _bt_convert_addr_string_to_type(vc_list.btaddr.addr, address);
2136                 vc_list.vcards = list;
2137                 vc_list.length = count;
2138                 vc_list.success = success;
2139                 _bt_common_event_cb(BLUETOOTH_PBAP_PHONEBOOK_SEARCH,
2140                                 result, &vc_list,
2141                                 event_info->cb, event_info->user_data);
2142
2143                 g_variant_unref(string_var);
2144                 //free lists
2145         }
2146 }
2147
2148 void __bt_rfcomm_client_event_filter(GDBusConnection *connection,
2149                                                  const gchar *sender_name,
2150                                                  const gchar *object_path,
2151                                                  const gchar *interface_name,
2152                                                  const gchar *signal_name,
2153                                                  GVariant *parameters,
2154                                                  gpointer user_data)
2155 {
2156         bt_event_info_t *event_info;
2157         int result = BLUETOOTH_ERROR_NONE;
2158         event_info = (bt_event_info_t *)user_data;
2159         ret_if(event_info == NULL);
2160
2161         if (strcasecmp(object_path, BT_RFCOMM_CLIENT_PATH) != 0)
2162                 return;
2163         if (strcasecmp(interface_name, BT_EVENT_SERVICE) != 0)
2164                 return;
2165
2166         ret_if(signal_name == NULL);
2167
2168         if (strcasecmp(signal_name, BT_RFCOMM_CONNECTED) == 0) {
2169                 const char *address = NULL;
2170                 const char *uuid = NULL;
2171                 int socket_fd = 0;
2172                 bluetooth_rfcomm_connection_t conn_info;
2173
2174                 g_variant_get(parameters, "(i&s&sn)", &result, &address,
2175                                                         &uuid, &socket_fd);
2176
2177                 memset(&conn_info, 0x00, sizeof(bluetooth_rfcomm_connection_t));
2178                 conn_info.device_role = RFCOMM_ROLE_CLIENT;
2179                 g_strlcpy(conn_info.uuid, uuid, BLUETOOTH_UUID_STRING_MAX);
2180                 conn_info.socket_fd = socket_fd;
2181                 _bt_convert_addr_string_to_type(conn_info.device_addr.addr,
2182                                                 address);
2183
2184                 _bt_common_event_cb(BLUETOOTH_EVENT_RFCOMM_CONNECTED,
2185                                 result, &conn_info,
2186                                 event_info->cb, event_info->user_data);
2187         } else if (strcasecmp(signal_name, BT_RFCOMM_DISCONNECTED) == 0) {
2188                 const char *address = NULL;
2189                 const char *uuid = NULL;
2190                 int socket_fd = 0;
2191                 bluetooth_rfcomm_disconnection_t disconn_info;
2192
2193                 g_variant_get(parameters, "(i&s&sn)", &result, &address,
2194                                                                 &uuid, &socket_fd);
2195
2196                 memset(&disconn_info, 0x00, sizeof(bluetooth_rfcomm_disconnection_t));
2197                 disconn_info.device_role = RFCOMM_ROLE_CLIENT;
2198                 g_strlcpy(disconn_info.uuid, uuid, BLUETOOTH_UUID_STRING_MAX);
2199                 disconn_info.socket_fd = socket_fd;
2200                 _bt_convert_addr_string_to_type(disconn_info.device_addr.addr,
2201                                                 address);
2202
2203                 _bt_common_event_cb(BLUETOOTH_EVENT_RFCOMM_DISCONNECTED,
2204                                 result, &disconn_info,
2205                                 event_info->cb, event_info->user_data);
2206         } else if (strcasecmp(signal_name, BT_RFCOMM_DATA_RECEIVED) == 0) {
2207                 char *buffer;
2208                 int buffer_len = 0;
2209                 int socket_fd = 0;
2210                 bluetooth_rfcomm_received_data_t data_r;
2211                 GVariant *byte_var;
2212
2213                 g_variant_get(parameters, "(in@ay)", &result, &socket_fd,
2214                                                                 &byte_var);
2215
2216                 buffer_len = g_variant_get_size(byte_var);
2217                 buffer = (char *) g_variant_get_data(byte_var);
2218
2219                 data_r.socket_fd = socket_fd;
2220                 data_r.buffer_size = buffer_len;
2221                 data_r.buffer = buffer;
2222
2223                 _bt_common_event_cb(BLUETOOTH_EVENT_RFCOMM_DATA_RECEIVED,
2224                                 result, &data_r,
2225                                 event_info->cb, event_info->user_data);
2226                 g_variant_unref(byte_var);
2227         }
2228 }
2229
2230 void __bt_rfcomm_server_event_filter(GDBusConnection *connection,
2231                                                  const gchar *sender_name,
2232                                                  const gchar *object_path,
2233                                                  const gchar *interface_name,
2234                                                  const gchar *signal_name,
2235                                                  GVariant *parameters,
2236                                                  gpointer user_data)
2237 {
2238         bt_event_info_t *event_info;
2239         int result = BLUETOOTH_ERROR_NONE;
2240         event_info = (bt_event_info_t *)user_data;
2241         ret_if(event_info == NULL);
2242
2243         if (strcasecmp(object_path, BT_RFCOMM_SERVER_PATH) != 0)
2244                 return;
2245         if (strcasecmp(interface_name, BT_EVENT_SERVICE) != 0)
2246                 return;
2247
2248         ret_if(signal_name == NULL);
2249
2250         if (strcasecmp(signal_name, BT_RFCOMM_CONNECTED) == 0) {
2251                 const char *address = NULL;
2252                 const char *uuid = NULL;
2253                 int socket_fd = 0;
2254                 bluetooth_rfcomm_connection_t conn_info;
2255
2256                 g_variant_get(parameters, "(i&s&sn)", &result, &address,
2257                                                         &uuid, &socket_fd);
2258
2259                 memset(&conn_info, 0x00, sizeof(bluetooth_rfcomm_connection_t));
2260                 conn_info.device_role = RFCOMM_ROLE_SERVER;
2261                 g_strlcpy(conn_info.uuid, uuid, BLUETOOTH_UUID_STRING_MAX);
2262                 conn_info.socket_fd = socket_fd;
2263                 _bt_convert_addr_string_to_type(conn_info.device_addr.addr,
2264                                                 address);
2265
2266                 _bt_common_event_cb(BLUETOOTH_EVENT_RFCOMM_CONNECTED,
2267                                 result, &conn_info,
2268                                 event_info->cb, event_info->user_data);
2269         } else if (strcasecmp(signal_name, BT_RFCOMM_DISCONNECTED) == 0) {
2270                 const char *address = NULL;
2271                 const char *uuid = NULL;
2272                 int socket_fd = 0;
2273                 bluetooth_rfcomm_disconnection_t disconn_info;
2274
2275                 g_variant_get(parameters, "(i&s&sn)", &result, &address,
2276                                                                 &uuid, &socket_fd);
2277
2278                 memset(&disconn_info, 0x00, sizeof(bluetooth_rfcomm_disconnection_t));
2279                 disconn_info.device_role = RFCOMM_ROLE_SERVER;
2280                 g_strlcpy(disconn_info.uuid, uuid, BLUETOOTH_UUID_STRING_MAX);
2281                 disconn_info.socket_fd = socket_fd;
2282                 _bt_convert_addr_string_to_type(disconn_info.device_addr.addr,
2283                                                 address);
2284
2285                 _bt_common_event_cb(BLUETOOTH_EVENT_RFCOMM_DISCONNECTED,
2286                                 result, &disconn_info,
2287                                 event_info->cb, event_info->user_data);
2288         } else if (strcasecmp(signal_name, BT_CONNECTION_AUTHORIZED) == 0) {
2289                 /* OSP only event */
2290                 bluetooth_rfcomm_connection_request_t req_ind;
2291                 char *address = NULL;
2292                 char *uuid = NULL;
2293                 char *name = NULL;
2294                 char *path = NULL;
2295                 int socket_fd = 0;
2296
2297                 g_variant_get(parameters, "(i&s&s&s&sn)", &result, &address,
2298                                                 &uuid, &name, &path, &socket_fd);
2299
2300                 if (_check_uuid_path(path, uuid) == FALSE)
2301                         return;
2302
2303                 memset(&req_ind, 0x00, sizeof(bluetooth_rfcomm_connection_request_t));
2304                 _bt_convert_addr_string_to_type(req_ind.device_addr.addr,
2305                                                 address);
2306
2307                 req_ind.socket_fd = socket_fd;
2308
2309                 _bt_common_event_cb(BLUETOOTH_EVENT_RFCOMM_AUTHORIZE,
2310                                 result, &req_ind,
2311                                 event_info->cb, event_info->user_data);
2312         } else if (strcasecmp(signal_name, BT_RFCOMM_SERVER_REMOVED) == 0) {
2313                 /* OSP only event */
2314                 int socket_fd = 0;
2315
2316                 g_variant_get(parameters, "(in)", &result, &socket_fd);
2317
2318                 ret_if(__bt_is_server_exist(socket_fd) == FALSE);
2319
2320                 _bt_remove_server(socket_fd);
2321         } else if (strcasecmp(signal_name, BT_RFCOMM_DATA_RECEIVED) == 0) {
2322                 char *buffer = NULL;
2323                 int buffer_len = 0;
2324                 int socket_fd = 0;
2325                 bluetooth_rfcomm_received_data_t data_r;
2326                 GVariant *byte_var;
2327
2328                 g_variant_get(parameters, "(in@ay)", &result,
2329                                                 &socket_fd, &byte_var);
2330
2331                 buffer_len = g_variant_get_size(byte_var);
2332                 buffer = (char *) g_variant_get_data(byte_var);
2333
2334                 data_r.socket_fd = socket_fd;
2335                 data_r.buffer_size = buffer_len;
2336                 data_r.buffer = buffer;
2337
2338                 _bt_common_event_cb(BLUETOOTH_EVENT_RFCOMM_DATA_RECEIVED,
2339                                 result, &data_r,
2340                                 event_info->cb, event_info->user_data);
2341                 g_variant_unref(byte_var);
2342         }
2343 }
2344
2345 void __bt_hf_agent_event_filter(GDBusConnection *connection,
2346                                                  const gchar *sender_name,
2347                                                  const gchar *object_path,
2348                                                  const gchar *interface_name,
2349                                                  const gchar *signal_name,
2350                                                  GVariant *parameters,
2351                                                  gpointer user_data)
2352 {
2353         BT_DBG("+\n");
2354
2355         bt_event_info_t *event_info;
2356         int result = BLUETOOTH_ERROR_NONE;
2357         event_info = (bt_event_info_t *)user_data;
2358         ret_if(event_info == NULL);
2359
2360         BT_DBG("+\n");
2361         if (strcasecmp(object_path, BT_HF_AGENT_PATH) != 0)
2362                 return;
2363         if (strcasecmp(interface_name, BT_HF_SERVICE_INTERFACE) != 0)
2364                 return;
2365
2366         ret_if(signal_name == NULL);
2367
2368         BT_DBG("%s", signal_name);
2369         if (strcasecmp(signal_name, "Connected") == 0) {
2370                 char *address = NULL;
2371
2372                 g_variant_get(parameters, "(s)", &address);
2373                 _bt_hf_event_cb(BLUETOOTH_EVENT_HF_CONNECTED,
2374                                 result, address,
2375                                 event_info->cb, event_info->user_data);
2376         } else if (strcasecmp(signal_name, "Disconnected") == 0) {
2377                 char *address = NULL;
2378
2379                 g_variant_get(parameters, "(s)", &address);
2380                 _bt_hf_event_cb(BLUETOOTH_EVENT_HF_DISCONNECTED,
2381                                 result, address,
2382                                 event_info->cb, event_info->user_data);
2383         } else if (strcasecmp(signal_name, "AudioConnected") == 0) {
2384                 _bt_hf_event_cb(BLUETOOTH_EVENT_HF_AUDIO_CONNECTED,
2385                                 result, NULL,
2386                                 event_info->cb, event_info->user_data);
2387         } else if (strcasecmp(signal_name, "AudioDisconnected") == 0) {
2388                 _bt_hf_event_cb(BLUETOOTH_EVENT_HF_AUDIO_DISCONNECTED,
2389                                 result, NULL,
2390                                 event_info->cb, event_info->user_data);
2391         } else if (strcasecmp(signal_name, "Ring") == 0) {
2392                 char *phoneno = NULL;
2393
2394                 g_variant_get(parameters, "(&s)", &phoneno);
2395
2396                 _bt_hf_event_cb(BLUETOOTH_EVENT_HF_RING_INDICATOR,
2397                                 result, phoneno,
2398                                 event_info->cb, event_info->user_data);
2399         } else if (strcasecmp(signal_name, "CallWaiting") == 0) {
2400                 char *phoneno = NULL;
2401
2402                 g_variant_get(parameters, "(&s)", &phoneno);
2403
2404                 _bt_hf_event_cb(BLUETOOTH_EVENT_HF_CALL_WAITING,
2405                                 result, phoneno,
2406                                 event_info->cb, event_info->user_data);
2407         }  else if (strcasecmp(signal_name, "CallTerminated") == 0) {
2408                 _bt_hf_event_cb(BLUETOOTH_EVENT_HF_CALL_TERMINATED,
2409                                 result, NULL,
2410                                 event_info->cb, event_info->user_data);
2411         }  else if (strcasecmp(signal_name, "FailedToDial") == 0) {
2412                 _bt_hf_event_cb(BLUETOOTH_EVENT_HF_CALL_FAILED_TO_DIAL,
2413                                 result, NULL,
2414                                 event_info->cb, event_info->user_data);
2415         } else if (strcasecmp(signal_name, "CallIdle") == 0) {
2416                 _bt_hf_event_cb(BLUETOOTH_EVENT_HF_CALL_IDLE,
2417                                 result, NULL,
2418                                 event_info->cb, event_info->user_data);
2419         } else if (strcasecmp(signal_name, "CallSetupIncoming") == 0) {
2420                 _bt_hf_event_cb(BLUETOOTH_EVENT_HF_CALLSETUP_INCOMING,
2421                                 result, NULL,
2422                                 event_info->cb, event_info->user_data);
2423         } else if (strcasecmp(signal_name, "CallSetupDialing") == 0) {
2424                 _bt_hf_event_cb(BLUETOOTH_EVENT_HF_CALLSETUP_DIALING,
2425                                 result, NULL,
2426                                 event_info->cb, event_info->user_data);
2427         } else if (strcasecmp(signal_name, "CallSetupAlerting") == 0) {
2428                 _bt_hf_event_cb(BLUETOOTH_EVENT_HF_CALLSETUP_ALERTING,
2429                                 result, NULL,
2430                                 event_info->cb, event_info->user_data);
2431         } else if (strcasecmp(signal_name, "CallStarted") == 0) {
2432                 _bt_hf_event_cb(BLUETOOTH_EVENT_HF_CALL_STARTED,
2433                                 result, NULL,
2434                                 event_info->cb, event_info->user_data);
2435         } else if (strcasecmp(signal_name, "CallEnded") == 0) {
2436                 _bt_hf_event_cb(BLUETOOTH_EVENT_HF_CALL_ENDED,
2437                                 result, NULL,
2438                                 event_info->cb, event_info->user_data);
2439         }  else if (strcasecmp(signal_name, "NoCallsHeld") == 0) {
2440                 _bt_hf_event_cb(BLUETOOTH_EVENT_HF_CALL_UNHOLD,
2441                                 result, NULL,
2442                                 event_info->cb, event_info->user_data);
2443         } else if (strcasecmp(signal_name, "CallsSwapped") == 0) {
2444                 _bt_hf_event_cb(BLUETOOTH_EVENT_HF_CALL_SWAPPED,
2445                                 result, NULL,
2446                                 event_info->cb, event_info->user_data);
2447         } else if (strcasecmp(signal_name, "CallOnHold") == 0) {
2448                 _bt_hf_event_cb(BLUETOOTH_EVENT_HF_CALL_ON_HOLD,
2449                                 result, NULL,
2450                                 event_info->cb, event_info->user_data);
2451         } else if (strcasecmp(signal_name, "CallStatusUpdate") == 0) {
2452                 int call_count;
2453                 GVariant *var_data = NULL;
2454                 char *number = NULL;
2455                 int idx, dir, status, mpart;
2456                 bt_hf_call_list_s *handle = NULL;
2457
2458                 g_variant_get(parameters, "(i@a(siiii))", &call_count,
2459                                                                 &var_data);
2460                 BT_DBG("call count : %d", call_count);
2461
2462                 if (var_data) {
2463                         GVariantIter *iter = NULL;
2464                         __bt_call_list_create(&handle);
2465
2466                         g_variant_get(var_data, "a(siiii)", &iter);
2467                         while (g_variant_iter_loop(iter, "(siiii)", &number,
2468                                                 &dir, &status, &mpart, &idx)) {
2469                                 BT_DBG("call number:%s, dir:%d, status : %d",
2470                                                         number, dir, status);
2471                                 BT_DBG("call mpart : %d, idx : %d", mpart, idx);
2472                                 __bt_call_list_add(handle, number, dir,
2473                                                         status, mpart, idx);
2474                         }
2475                         g_variant_iter_free(iter);
2476                         g_variant_unref(var_data);
2477                 }
2478
2479                 if (handle && (call_count == g_list_length(handle->list))) {
2480                         handle->count = call_count;
2481                         _bt_hf_event_cb(BLUETOOTH_EVENT_HF_CALL_STATUS,
2482                                         result, handle,
2483                                         event_info->cb, event_info->user_data);
2484                 } else {
2485                         BT_ERR(" Mismatch in call count : %d", call_count);
2486                 }
2487
2488                 __bt_call_list_destroy(handle);
2489         } else if (strcasecmp(signal_name, "VoiceRecognition") == 0) {
2490                 int status;
2491                 g_variant_get(parameters, "(i)", &status);
2492                 BT_DBG("status = [%d]\n", status);
2493                 if (status)
2494                         _bt_hf_event_cb(BLUETOOTH_EVENT_HF_VOICE_RECOGNITION_ENABLED,
2495                                         result, NULL,
2496                                         event_info->cb, event_info->user_data);
2497                 else
2498                         _bt_hf_event_cb(BLUETOOTH_EVENT_HF_VOICE_RECOGNITION_DISABLED,
2499                                         result, NULL,
2500                                         event_info->cb, event_info->user_data);
2501         } else if (strcasecmp(signal_name, "VolumeSpeaker") == 0) {
2502                 int value;
2503                 g_variant_get(parameters, "(i)", &value);
2504                 BT_DBG("Value = [%d]\n", value);
2505                         _bt_hf_event_cb(BLUETOOTH_EVENT_HF_VOLUME_SPEAKER,
2506                                         result, &value,
2507                                         event_info->cb, event_info->user_data);
2508         } else if (strcasecmp(signal_name, "SamsungXSAT") == 0) {
2509                 int value = 0;
2510                 char *msg = NULL;
2511                 bluetooth_vendor_dep_at_cmd_t cmd;
2512                 g_variant_get(parameters, "(i&s)", &value, &msg);
2513                 BT_DBG("Value = [%d], message = %s\n", value, msg);
2514                 cmd.app_id =  value;
2515                 cmd.message = msg;
2516                 _bt_hf_event_cb(BLUETOOTH_EVENT_HF_VENDOR_DEP_CMD,
2517                                 result, &cmd,
2518                                 event_info->cb, event_info->user_data);
2519         } else if (strcasecmp(signal_name, "PropertyChanged") == 0) {
2520                 GVariant *value;
2521                 gchar *property;
2522                 bluetooth_hf_ciev_device_event_t dev_event;
2523
2524                 g_variant_get(parameters, "(&sv)", &property, &value);
2525                 dev_event.value  = g_variant_get_uint16(value);
2526
2527                 BT_DBG("Property: %s , value: %d", property, dev_event.value);
2528                 g_variant_unref(value);
2529
2530                 if (strcasecmp(property, "BatteryCharge") == 0) {
2531                         dev_event.event = BLUETOOTH_HF_CIEV_BATTCHG;
2532                         _bt_hf_event_cb(BLUETOOTH_EVENT_HF_CIEV_DEVICE_STATUS_CHANGED,
2533                                         result, &dev_event,
2534                                         event_info->cb, event_info->user_data);
2535                 } else if (strcasecmp(property, "SignalStrength") == 0) {
2536                         dev_event.event = BLUETOOTH_HF_CIEV_SIGNAL;
2537                         _bt_hf_event_cb(BLUETOOTH_EVENT_HF_CIEV_DEVICE_STATUS_CHANGED,
2538                                         result, &dev_event,
2539                                         event_info->cb, event_info->user_data);
2540                 } else if (strcasecmp(property, "RegistrationStatus") == 0) {
2541                         dev_event.event = BLUETOOTH_HF_CIEV_SERVICE;
2542                         _bt_hf_event_cb(BLUETOOTH_EVENT_HF_CIEV_DEVICE_STATUS_CHANGED,
2543                                         result, &dev_event,
2544                                         event_info->cb, event_info->user_data);
2545                 }
2546         }
2547         BT_DBG("-\n");
2548 }
2549
2550 static void __bt_remove_all_events(void)
2551 {
2552         bt_event_info_t *info;
2553
2554         while ((info = g_slist_nth_data(event_list, 0)) != NULL)
2555                 _bt_unregister_event(info->event_type);
2556
2557         if (event_list) {
2558                 g_slist_free(event_list);
2559                 event_list = NULL;
2560         }
2561 }
2562
2563 static gboolean __bt_event_is_registered(int event_type)
2564 {
2565         GSList *l;
2566         bt_event_info_t *info;
2567
2568         for (l = event_list; l != NULL; l = g_slist_next(l)) {
2569                 info = l->data;
2570                 if (info == NULL)
2571                         continue;
2572
2573                 if (info->event_type == event_type)
2574                         return TRUE;
2575         }
2576
2577         return FALSE;
2578 }
2579
2580 bt_event_info_t *_bt_event_get_cb_data(int event_type)
2581 {
2582         GSList *l;
2583         bt_event_info_t *info;
2584
2585         for (l = event_list; l != NULL; l = g_slist_next(l)) {
2586                 info = l->data;
2587                 if (info == NULL)
2588                         continue;
2589
2590                 if (info->event_type == event_type)
2591                         return info;
2592         }
2593
2594         return NULL;
2595 }
2596
2597 void _bt_add_server(int server_fd)
2598 {
2599         bt_server_info_t *info;
2600
2601         info = g_new0(bt_server_info_t, 1);
2602         info->server_fd = server_fd;
2603
2604         server_list = g_slist_append(server_list, info);
2605 }
2606
2607 void _bt_remove_server(int server_fd)
2608 {
2609         GSList *l;
2610         bt_server_info_t *info;
2611
2612         for (l = server_list; l != NULL; l = g_slist_next(l)) {
2613                 info = l->data;
2614                 if (info == NULL)
2615                         continue;
2616
2617                 if (info->server_fd == server_fd)
2618                         server_list = g_slist_remove(server_list, (void *)info);
2619
2620                 g_free(info);
2621         }
2622 }
2623
2624 void _bt_set_obex_server_id(int server_type)
2625 {
2626         obex_server_id = server_type;
2627 }
2628
2629 int _bt_get_obex_server_id(void)
2630 {
2631         return obex_server_id;
2632 }
2633
2634 int _bt_init_event_handler(void)
2635 {
2636         if (is_initialized == TRUE) {
2637                 BT_ERR("Connection already exist");
2638                 return BLUETOOTH_ERROR_ALREADY_INITIALIZED;
2639         }
2640
2641         __bt_remove_all_events();
2642
2643         is_initialized = TRUE;
2644
2645         return BLUETOOTH_ERROR_NONE;
2646 }
2647
2648 int _bt_deinit_event_handler(void)
2649 {
2650         if (is_initialized == FALSE) {
2651                 BT_ERR("Connection dose not exist");
2652                 return BLUETOOTH_ERROR_INTERNAL;
2653         }
2654
2655         __bt_remove_all_events();
2656
2657         if (disable_timer_id > 0) {
2658                 g_source_remove(disable_timer_id);
2659                 disable_timer_id = 0;
2660         }
2661
2662         is_initialized = FALSE;
2663
2664         return BLUETOOTH_ERROR_NONE;
2665 }
2666
2667 static void __bt_event_data_free(void *data)
2668 {
2669         bt_event_info_t *cb_data = data;
2670
2671         ret_if(cb_data == NULL);
2672
2673         g_free(cb_data);
2674 }
2675
2676 int _bt_register_event(int event_type, void *event_cb, void *user_data)
2677 {
2678         GDBusConnection *connection_type;
2679         GDBusSignalCallback event_func;
2680         bt_event_info_t *cb_data;
2681         const char *path;
2682         const char *interface = BT_EVENT_SERVICE;
2683
2684         if (is_initialized == FALSE)
2685                 _bt_init_event_handler();
2686
2687         if (__bt_event_is_registered(event_type) == TRUE) {
2688                 BT_ERR("The event is already registed");
2689                 return BLUETOOTH_ERROR_ALREADY_INITIALIZED;
2690         }
2691
2692         switch (event_type) {
2693         case BT_ADAPTER_EVENT:
2694                 event_func = __bt_adapter_event_filter;
2695                 path = BT_ADAPTER_PATH;
2696                 break;
2697         case BT_LE_ADAPTER_EVENT:
2698                 event_func = __bt_adapter_le_event_filter;
2699                 path = BT_LE_ADAPTER_PATH;
2700                 break;
2701         case BT_DEVICE_EVENT:
2702                 event_func = __bt_device_event_filter;
2703                 path = BT_DEVICE_PATH;
2704                 break;
2705         case BT_HID_EVENT:
2706                 event_func = __bt_hid_event_filter;
2707                 path = BT_HID_PATH;
2708                 break;
2709         case BT_HEADSET_EVENT:
2710                 event_func = __bt_headset_event_filter;
2711                 path = BT_HEADSET_PATH;
2712                 break;
2713         case BT_NETWORK_EVENT:
2714                 event_func = __bt_network_event_filter;
2715                 path = BT_NETWORK_PATH;
2716                 break;
2717         case BT_AVRCP_EVENT:
2718                 event_func = __bt_avrcp_event_filter;
2719                 path = BT_AVRCP_PATH;
2720                 break;
2721         case BT_AVRCP_CONTROL_EVENT:
2722                 event_func = __bt_avrcp_control_event_filter;
2723                 path = BT_AVRCP_CONTROL_PATH;
2724                 break;
2725         case BT_OPP_CLIENT_EVENT:
2726                 event_func = __bt_opp_client_event_filter;
2727                 path = BT_OPP_CLIENT_PATH;
2728                 break;
2729         case BT_OPP_SERVER_EVENT:
2730                 event_func = __bt_opp_server_event_filter;
2731                 path = BT_OPP_SERVER_PATH;
2732                 break;
2733         case BT_PBAP_CLIENT_EVENT:
2734                 event_func = __bt_pbap_client_event_filter;
2735                 path = BT_PBAP_CLIENT_PATH;
2736                 break;
2737         case BT_RFCOMM_CLIENT_EVENT:
2738                 event_func = __bt_rfcomm_client_event_filter;
2739                 path = BT_RFCOMM_CLIENT_PATH;
2740                 break;
2741         case BT_RFCOMM_SERVER_EVENT:
2742                 event_func = __bt_rfcomm_server_event_filter;
2743                 path = BT_RFCOMM_SERVER_PATH;
2744                 break;
2745         case BT_HF_AGENT_EVENT:
2746                 BT_DBG("BT_HF_AGENT_EVENT\n");
2747                 event_func = __bt_hf_agent_event_filter;
2748                 path = BT_HF_AGENT_PATH;
2749                 interface = BT_HF_SERVICE_INTERFACE;
2750                 break;
2751         case BT_A2DP_SOURCE_EVENT:
2752                 BT_DBG("BT_A2DP_SOURCE_EVENT");
2753                 event_func = __bt_a2dp_source_event_filter;
2754                 path = BT_A2DP_SOURCE_PATH;
2755                 break;
2756         case BT_HID_DEVICE_EVENT:
2757                 BT_DBG("BT_HID_DEVICE_EVENT");
2758                 event_func = __bt_hid_device_event_filter;
2759                 path = BT_HID_DEVICE_PATH;
2760                 break;
2761 #ifdef GATT_NO_RELAY
2762         case BT_GATT_BLUEZ_EVENT:
2763                 BT_DBG("BT_GATT_BLUEZ_EVENT");
2764                 event_func = __bt_device_event_filter;
2765                 interface = BT_GATT_CHARACTERISTIC_INTERFACE;
2766                 path = NULL;
2767                 break;
2768 #endif
2769         default:
2770                 BT_ERR("Unknown event");
2771                 return BLUETOOTH_ERROR_INTERNAL;
2772         }
2773
2774         connection_type = _bt_gdbus_get_system_gconn();
2775         if (connection_type == NULL)
2776                 return BLUETOOTH_ERROR_INTERNAL;
2777
2778         cb_data = g_new0(bt_event_info_t, 1);
2779
2780         cb_data->event_type = event_type;
2781         cb_data->cb = event_cb;
2782         cb_data->user_data = user_data;
2783
2784         cb_data->id = g_dbus_connection_signal_subscribe(connection_type,
2785                                 NULL, interface, NULL, path, NULL, 0,
2786                                 event_func, cb_data, NULL);
2787
2788         event_list = g_slist_append(event_list, cb_data);
2789
2790         return BLUETOOTH_ERROR_NONE;
2791 }
2792
2793 int _bt_unregister_event(int event_type)
2794 {
2795         GDBusConnection *connection_type;
2796         bt_event_info_t *cb_data;
2797
2798         if (is_initialized == FALSE) {
2799                 BT_ERR("Event is not registered");
2800                 return BLUETOOTH_ERROR_NOT_INITIALIZED;
2801         }
2802
2803         if (__bt_event_is_registered(event_type) == FALSE) {
2804                 BT_ERR("Not registered event");
2805                 return BLUETOOTH_ERROR_INTERNAL;
2806         }
2807
2808         cb_data = _bt_event_get_cb_data(event_type);
2809
2810         if (cb_data == NULL) {
2811                 BT_ERR("No matched event data");
2812                 return BLUETOOTH_ERROR_INTERNAL;
2813         }
2814
2815         connection_type = _bt_gdbus_get_system_gconn();
2816
2817         event_list = g_slist_remove(event_list, (void *)cb_data);
2818
2819         retv_if(connection_type == NULL, BLUETOOTH_ERROR_INTERNAL);
2820
2821         g_dbus_connection_signal_unsubscribe(connection_type, cb_data->id);
2822
2823         __bt_event_data_free((void *)cb_data);
2824
2825         return BLUETOOTH_ERROR_NONE;
2826 }
2827
2828 static void __bt_name_owner_changed(GDBusConnection *connection,
2829                                                  const gchar *sender_name,
2830                                                  const gchar *object_path,
2831                                                  const gchar *interface_name,
2832                                                  const gchar *signal_name,
2833                                                  GVariant *parameters,
2834                                                  gpointer user_data)
2835 {
2836         const char *name = NULL;
2837         const char *old_owner = NULL;
2838         const char *new_owner = NULL;
2839         bt_event_info_t *event_info;
2840
2841         g_variant_get(parameters, "(&s&s&s)", &name, &old_owner, &new_owner);
2842
2843         if (g_strcmp0(name, BT_DBUS_NAME) == 0 &&
2844                         (new_owner != NULL && *new_owner == '\0')) {
2845                 BT_DBG("bt-service is terminated");
2846                 event_info = _bt_event_get_cb_data(BT_ADAPTER_EVENT);
2847                 if (event_info == NULL)
2848                         return;
2849
2850                 if (disable_timer_id > 0)
2851                         g_source_remove(disable_timer_id);
2852
2853                 disable_timer_id = g_timeout_add(BT_RELIABLE_DISABLE_TIME,
2854                                 (GSourceFunc)__bt_reliable_disable_cb,
2855                                 event_info);
2856         }
2857 }
2858
2859 void _bt_register_name_owner_changed(void)
2860 {
2861         GDBusConnection *connection_type;
2862
2863         connection_type = _bt_gdbus_get_system_gconn();
2864         if (connection_type == NULL) {
2865                 BT_ERR("Unable to get the bus");
2866                 return;
2867         }
2868         owner_sig_id = g_dbus_connection_signal_subscribe(connection_type,
2869                                 NULL, BT_EVENT_FREEDESKTOP,
2870                                 BT_NAME_OWNER_CHANGED, NULL, NULL, 0,
2871                                 __bt_name_owner_changed, NULL, NULL);
2872 }
2873
2874 void _bt_unregister_name_owner_changed(void)
2875 {
2876         GDBusConnection *connection_type;
2877
2878         connection_type = _bt_gdbus_get_system_gconn();
2879         if (connection_type != NULL && owner_sig_id != -1) {
2880                 g_dbus_connection_signal_unsubscribe(connection_type,
2881                                                         owner_sig_id);
2882                 owner_sig_id = -1;
2883         }
2884 }
2885
2886 static void __bt_manager_event_filter(GDBusConnection *connection,
2887                                         const gchar *sender_name,
2888                                         const gchar *object_path,
2889                                         const gchar *interface_name,
2890                                         const gchar *signal_name,
2891                                         GVariant *parameters,
2892                                         gpointer user_data)
2893 {
2894         char *path = NULL;
2895         GVariantIter *interface_iter = NULL;
2896         char *interface_str = NULL;
2897         bt_gatt_service_change_t change;
2898         char address[BT_ADDRESS_STRING_SIZE] = { 0 };
2899         char secure_address[BT_ADDRESS_STRING_SIZE] = { 0 };
2900         bt_user_info_t *user_info = NULL;
2901
2902         if (strcasecmp(signal_name, "GattServiceAdded") == 0) {
2903                 g_variant_get(parameters, "(&s)", &path);
2904
2905                 _bt_convert_device_path_to_address(path, address);
2906                 _bt_convert_addr_string_to_type(change.device_addr.addr, address);
2907                 _bt_convert_addr_string_to_secure_string(secure_address, address);
2908
2909                 if (_bluetooth_gatt_check_service_change_watcher_address(&change.device_addr)
2910                         == FALSE) {
2911                         BT_INFO("GATT Service [%s] added, but no watcher for %s",
2912                                         path, secure_address);
2913                         return;
2914                 } else
2915                         BT_INFO(" ### GATT Service added [%s] [%s]",
2916                                         path, secure_address);
2917
2918                 change.svc_path = g_strdup(path);
2919                 change.change_type = BLUETOOTH_GATT_SERVICE_CHANGE_TYPE_ADD;
2920
2921                 user_info = _bt_get_user_data(BT_COMMON);
2922                 if (user_info != NULL) {
2923                         _bt_common_event_cb(
2924                                 BLUETOOTH_EVENT_GATT_CLIENT_SERVICE_CHANGED,
2925                                 BLUETOOTH_ERROR_NONE, &change,
2926                                 user_info->cb, user_info->user_data);
2927                 }
2928
2929                 g_free(change.svc_path);
2930         } else if (strcasecmp(signal_name, "InterfacesRemoved") == 0) {
2931                 g_variant_get(parameters, "(&oas)",
2932                                                         &path, &interface_iter);
2933
2934                 if (!path) {
2935                         BT_ERR("Invalid adapter path");
2936                         return;
2937                 }
2938
2939                 _bt_convert_device_path_to_address(path, address);
2940                 _bt_convert_addr_string_to_type(change.device_addr.addr, address);
2941                 _bt_convert_addr_string_to_secure_string(secure_address, address);
2942
2943                 if (_bluetooth_gatt_check_service_change_watcher_address(&change.device_addr)
2944                         == FALSE) {
2945                         BT_INFO("GATT Service [%s] removed, but no watcher for %s",
2946                                         path, secure_address);
2947                         return;
2948                 }
2949
2950                 while (g_variant_iter_loop(interface_iter, "s", &interface_str)) {
2951                         if (g_strcmp0(interface_str, GATT_SERV_INTERFACE) == 0) {
2952                                 change.svc_path = g_strdup(path);
2953                                 change.change_type = BLUETOOTH_GATT_SERVICE_CHANGE_TYPE_REMOVE;
2954
2955                                 BT_INFO(" ### GATT Service removed [%s] [%s]",
2956                                                 path, secure_address);
2957
2958                                 user_info = _bt_get_user_data(BT_COMMON);
2959                                 if (user_info != NULL) {
2960                                         _bt_common_event_cb(
2961                                                 BLUETOOTH_EVENT_GATT_CLIENT_SERVICE_CHANGED,
2962                                                 BLUETOOTH_ERROR_NONE, &change,
2963                                                 user_info->cb, user_info->user_data);
2964                                 }
2965
2966                                 g_free(change.svc_path);
2967                                 break;
2968                         }
2969                 }
2970                 g_variant_iter_free(interface_iter);
2971         }
2972 }
2973
2974 int _bt_register_manager_subscribe_signal(gboolean subscribe)
2975 {
2976         GDBusConnection *g_conn;
2977         static int service_added_id = -1;
2978         static int interface_removed_id = -1;
2979
2980         g_conn = _bt_gdbus_get_system_gconn();
2981         if (g_conn == NULL)
2982                 return BLUETOOTH_ERROR_INTERNAL;
2983
2984         if (subscribe == TRUE) {
2985                 if (service_added_id == -1) {
2986                         service_added_id = g_dbus_connection_signal_subscribe(g_conn,
2987                                         NULL, GATT_SERV_INTERFACE,
2988                                         "GattServiceAdded", NULL, NULL, 0,
2989                                         __bt_manager_event_filter,
2990                                         NULL, NULL);
2991                 }
2992                 if (interface_removed_id == -1) {
2993                         interface_removed_id = g_dbus_connection_signal_subscribe(g_conn,
2994                                         NULL, BT_MANAGER_INTERFACE,
2995                                         "InterfacesRemoved", NULL, NULL, 0,
2996                                         __bt_manager_event_filter,
2997                                         NULL, NULL);
2998                 }
2999         } else {
3000                 if (service_added_id != -1) {
3001                         g_dbus_connection_signal_unsubscribe(g_conn,
3002                                         service_added_id);
3003                         service_added_id = -1;
3004                 }
3005                 if (interface_removed_id != -1) {
3006                         g_dbus_connection_signal_unsubscribe(g_conn,
3007                                         interface_removed_id);
3008                         interface_removed_id = -1;
3009                 }
3010         }
3011
3012         return BLUETOOTH_ERROR_NONE;
3013 }
3014