bt-api/bt-event-handler.c

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