bt-service/bt-service-event-receiver.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 <glib.h>
  19 #include <string.h>
  20 #include <dlog.h>
  21 #include <vconf.h>
  22 #include <vconf-internal-bt-keys.h>
  23
  24 #include "bluetooth-api.h"
  25 #include "bt-internal-types.h"
  26
  27 #include "bt-service-common.h"
  28 #include "bt-service-event.h"
  29 #include "bt-service-main.h"
  30 #include "bt-service-adapter.h"
  31 #include "bt-service-adapter-le.h"
  32 #include "bt-service-device.h"
  33 #include "bt-service-avrcp.h"
  34 #include "bt-service-obex-server.h"
  35 #include "bt-service-rfcomm-server.h"
  36 #include "bt-service-audio.h"
  37 #include "bt-service-agent.h"
  38 #include "bt-service-pbap.h"
  39 #include "bt-service-headset-connection.h"
  40 #include "bt-service-avrcp-controller.h"
  41 #include "bt-service-hid.h"
  42 #include "bt-service-proximity.h"
  43
  44 #include "bt-service-opp-client.h"
  45 #include "bt-service-map-client.h"
  46 #include "bt-service-tds.h"
  47
  48 #ifdef TIZEN_FEATURE_BT_DPM
  49 #include "bt-service-dpm.h"
  50 #endif
  51
  52 #define DBUS_TIMEOUT 20 * 1000 /* 20 Sec */
  53 static GDBusConnection *manager_conn;
  54 static GDBusConnection *obexd_conn;
  55 static GDBusConnection *opc_obexd_conn;
  56 static GDBusConnection *map_obexd_conn;
  57
  58 static GList *p_cache_list = NULL;
  59
  60 static guint event_id;
  61 static guint le_scan_event_id = 0;
  62 static guint session_reinit_timer;
  63 guint nap_connected_device_count = 0;
  64 static guint hid_connected_device_count = 0;
  65 static GList *p_adv_ind_list = NULL;
  66
  67 typedef struct {
  68         bt_remote_dev_info_t *dev_info;
  69 } bt_cache_info_t;
  70
  71 /**
  72  * obexd connection type
  73  */
  74 typedef enum {
  75         OBEX_OPP = (1 << 1),
  76         OBEX_FTP = (1 << 2),
  77         OBEX_BIP = (1 << 3),
  78         OBEX_PBAP = (1 << 4),
  79         OBEX_IRMC = (1 << 5),
  80         OBEX_PCSUITE = (1 << 6),
  81         OBEX_SYNCEVOLUTION = (1 << 7),
  82         OBEX_MAS = (1 << 8),
  83         OBEX_MAP = (1 << 9),
  84 } bluetooth_obex_connection_type_t;
  85
  86 void _bt_handle_property_changed_event(GVariant *msg, const char *object_path);
  87 void _bt_opc_property_changed_event(GVariant *msg, char *path);
  88 void _bt_map_property_changed_event(GVariant *msg, const char *path);
  89 int _bt_register_service_event(GDBusConnection *g_conn, int event_type);
  90 void _bt_unregister_service_event(GDBusConnection *g_conn, int event_type);
  91 void _bt_opp_client_event_deinit(void);
  92 void _bt_map_client_event_deinit(void);
  93 void _bt_handle_network_client_event(GVariant *msg_iter,
  94                                 const char *path);
  95 void __bt_gatt_char_property_changed_event(GVariant *msg_iter,
  96                                 const char *path);
  97 void _bt_map_on_transfer_finished(const char *transfer_object_path, const int error);
  98
  99 static void __bt_free_bt_le_adv_info_t(gpointer data)
 100 {
 101         bt_le_adv_info_t *adv_info = data;
 102
 103         if (adv_info->timer_id)
 104                 g_source_remove(adv_info->timer_id);
 105         adv_info->timer_id = 0;
 106
 107         g_free(adv_info->addr);
 108         g_free(adv_info->data);
 109         g_free(adv_info);
 110 }
 111
 112 static bt_le_adv_info_t *__bt_get_adv_ind_info(char *addr)
 113 {
 114         retv_if(!addr, NULL);
 115         bt_le_adv_info_t *adv_info = NULL;
 116         GList *current = g_list_first((GList *)p_adv_ind_list);
 117         while (current && current->data) {
 118                 adv_info = (bt_le_adv_info_t *)current->data;
 119                 if (adv_info && !g_strcmp0(adv_info->addr, addr))
 120                         return adv_info;
 121                 current = g_list_next(current);
 122         }
 123         return NULL;
 124 }
 125
 126 static int __bt_add_adv_ind_info(bt_le_adv_info_t *adv_info)
 127 {
 128         retv_if(!adv_info, -1);
 129         if (__bt_get_adv_ind_info(adv_info->addr) != NULL) {
 130                 __bt_free_bt_le_adv_info_t(adv_info);
 131                 return -1;
 132         }
 133         p_adv_ind_list = g_list_append(p_adv_ind_list, adv_info);
 134
 135         return 0;
 136 }
 137
 138 static void __bt_del_adv_ind_info(char *addr)
 139 {
 140         ret_if(!addr);
 141         ret_if(!p_adv_ind_list);
 142         bt_le_adv_info_t *adv_info = NULL;
 143         GList *current = g_list_first((GList *)p_adv_ind_list);
 144         while (current && current->data) {
 145                 adv_info = (bt_le_adv_info_t *)current->data;
 146                 if (adv_info && !g_strcmp0(adv_info->addr, addr)) {
 147                         p_adv_ind_list = g_list_remove(p_adv_ind_list, adv_info);
 148                         __bt_free_bt_le_adv_info_t(adv_info);
 149                         return;
 150                 }
 151                 current = g_list_next(current);
 152         }
 153 }
 154
 155 static gboolean __bt_adv_scan_req_timeout_cb(gpointer user_data)
 156 {
 157         bt_remote_le_dev_info_t le_dev_info;
 158         bt_le_adv_info_t *adv_info = (bt_le_adv_info_t*)user_data;
 159
 160         memset(&le_dev_info, 0x00, sizeof(bt_remote_le_dev_info_t));
 161
 162         le_dev_info.address = adv_info->addr;
 163         le_dev_info.addr_type = adv_info->addr_type;
 164         le_dev_info.rssi = adv_info->rssi;
 165         le_dev_info.adv_data = adv_info->data;
 166         le_dev_info.adv_data_len = 0;
 167         adv_info->timer_id = 0;
 168
 169         _bt_send_scan_result_event(&le_dev_info, adv_info);
 170         __bt_del_adv_ind_info(adv_info->addr);
 171
 172         return FALSE;
 173 }
 174
 175 static void __bt_free_cache_info(bt_cache_info_t *cache_info)
 176 {
 177         ret_if(cache_info == NULL);
 178         _bt_free_device_info(cache_info->dev_info);
 179         g_free(cache_info);
 180 }
 181
 182 static gboolean __bt_parse_device_properties(GVariant *item,
 183                                                 bt_remote_dev_info_t *dev_info)
 184 {
 185         GVariantIter iter;
 186         gchar *key;
 187         GVariant *val;
 188         gsize len = 0;
 189         if (item == NULL)
 190                 return FALSE;
 191
 192         g_variant_iter_init(&iter, item);
 193         while (g_variant_iter_loop(&iter, "{sv}", &key, &val)) {
 194                 if (strcasecmp(key, "Address") == 0)  {
 195                         dev_info->address = g_variant_dup_string(val, &len);
 196                 } else if (strcasecmp(key, "Class") == 0) {
 197                         dev_info->class = g_variant_get_uint32(val);
 198                 } else if (strcasecmp(key, "name") == 0) {
 199                         if (dev_info->name == NULL)
 200                                 dev_info->name = g_variant_dup_string(val, &len);
 201                 } else if (strcasecmp(key, "Connected") == 0) {
 202                         dev_info->connected = g_variant_get_byte(val);
 203                 } else if (strcasecmp(key, "paired") == 0) {
 204                         dev_info->paired = g_variant_get_boolean(val);
 205                 } else if (strcasecmp(key, "Trusted") == 0) {
 206                         dev_info->trust = g_variant_get_boolean(val);
 207                 } else if (strcasecmp(key, "RSSI") == 0) {
 208                         dev_info->rssi = g_variant_get_int16(val);
 209                 } else if (strcasecmp(key, "LastAddrType") == 0) {
 210                         dev_info->addr_type = g_variant_get_byte(val);
 211                 } else if (strcasecmp(key, "UUIDs") == 0) {
 212                         char **uuid_value;
 213                         gsize size = 0;
 214                         int i = 0;
 215                         size = g_variant_get_size(val);
 216
 217                         if (size > 0) {
 218                                 uuid_value = (char **)g_variant_get_strv(val, &size);
 219                                 if (dev_info->uuids == NULL)
 220                                         dev_info->uuids = g_malloc0(sizeof(char *) * size);
 221
 222                                 for (i = 0; uuid_value[i] != NULL; i++) {
 223                                         dev_info->uuid_count++;
 224                                         dev_info->uuids[i] = g_strdup(uuid_value[i]);
 225                                 }
 226                                 g_free(uuid_value);
 227                         }
 228                 } else if (strcasecmp(key, "ManufacturerDataLen") == 0) {
 229                         g_variant_get(val, "q", &dev_info->manufacturer_data_len);
 230                         if (dev_info->manufacturer_data_len > BLUETOOTH_MANUFACTURER_DATA_LENGTH_MAX) {
 231                                 BT_ERR("manufacturer_data_len is too long(len = %d)", dev_info->manufacturer_data_len);
 232                                 dev_info->manufacturer_data_len = BLUETOOTH_MANUFACTURER_DATA_LENGTH_MAX;
 233                         }
 234
 235                         if (dev_info->manufacturer_data_len == 0)
 236                                 dev_info->manufacturer_data = g_strdup("");
 237                 } else if (strcasecmp(key, "ManufacturerData") == 0) {
 238                         int i = 0;
 239                         int len = 0;
 240                         GVariantIter *value_iter;
 241                         guint8 m_value;
 242
 243                         len = g_variant_get_size(val);
 244                         if (len <= 0)
 245                                 continue;
 246
 247                         dev_info->manufacturer_data = g_malloc0(len);
 248
 249                         g_variant_get(val, "ay", &value_iter);
 250                         while (g_variant_iter_loop(value_iter, "y", &m_value))
 251                                 dev_info->manufacturer_data[i++] = m_value;
 252                         g_variant_iter_free(value_iter);
 253                 }
 254         }
 255
 256         BT_DBG("-");
 257         return TRUE;
 258 }
 259
 260 static gboolean __bt_parse_interface(GVariant *msg,
 261                                         bt_remote_dev_info_t *dev_info)
 262 {
 263         char *path = NULL;
 264         GVariant *optional_param = NULL;
 265         GVariantIter iter;
 266         GVariant *child;
 267         char *interface_name = NULL;
 268         GVariant *inner_iter = NULL;
 269         g_variant_get(msg, "(&o@a{sa{sv}})",
 270                                         &path, &optional_param);
 271         g_variant_iter_init(&iter, optional_param);
 272
 273         retv_if(optional_param == NULL, FALSE);
 274
 275         while ((child = g_variant_iter_next_value(&iter))) {
 276                 g_variant_get(child, "{&s@a{sv}}", &interface_name, &inner_iter);
 277                 if (g_strcmp0(interface_name, BT_DEVICE_INTERFACE) == 0) {
 278                         BT_DBG("Found a device: %s", path);
 279                         if (__bt_parse_device_properties(inner_iter,
 280                                 dev_info) == FALSE) {
 281                                 g_variant_unref(inner_iter);
 282                                 g_variant_unref(child);
 283                                 g_variant_unref(optional_param);
 284                                 BT_ERR("Fail to parse the properies");
 285                                 return FALSE;
 286                         } else {
 287                                 g_variant_unref(inner_iter);
 288                                 g_variant_unref(child);
 289                                 g_variant_unref(optional_param);
 290                                 return TRUE;
 291                         }
 292                 }
 293                 g_variant_unref(inner_iter);
 294                 g_variant_unref(child);
 295         }
 296
 297         g_variant_unref(optional_param);
 298
 299         return FALSE;
 300 }
 301
 302 static int __bt_get_owner_info(GVariant *msg, char **name,
 303                                 char **previous, char **current)
 304 {
 305         g_variant_get(msg, "(sss)", name, previous, current);
 306         return BLUETOOTH_ERROR_NONE;
 307 }
 308
 309 static int __bt_get_agent_signal_info(GVariant *msg, char **address,
 310                                 char **name, char **uuid)
 311 {
 312         g_variant_get(msg, "(sss)", address, name, uuid);
 313         return BLUETOOTH_ERROR_NONE;
 314 }
 315
 316 void __bt_set_device_values(gboolean connected, int state)
 317 {
 318         int bt_device_state = VCONFKEY_BT_DEVICE_NONE;
 319
 320         if (vconf_get_int(VCONFKEY_BT_DEVICE, &bt_device_state) != 0)
 321                 BT_ERR("vconf_get_int failed");
 322
 323         if (connected == TRUE)
 324                 bt_device_state |= state;
 325         else if (bt_device_state & state)
 326                 bt_device_state ^= state;
 327
 328         if (vconf_set_int(VCONFKEY_BT_DEVICE, bt_device_state) != 0)
 329                 BT_ERR("vconf_set_int failed");
 330 }
 331
 332 gboolean _bt_discovery_finished_cb(gpointer user_data)
 333 {
 334         int result = BLUETOOTH_ERROR_NONE;
 335         event_id = 0;
 336         GVariant *param = NULL;
 337         if (_bt_get_discovering_property(DISCOVERY_ROLE_BREDR) == FALSE) {
 338                 if (_bt_get_cancel_by_user() == TRUE)
 339                         result = BLUETOOTH_ERROR_CANCEL_BY_USER;
 340
 341                 _bt_set_cancel_by_user(FALSE);
 342                 _bt_set_discovery_status(FALSE);
 343                 param = g_variant_new("(i)", result);
 344                 _bt_send_event(BT_ADAPTER_EVENT,
 345                         BLUETOOTH_EVENT_DISCOVERY_FINISHED,
 346                         param);
 347         }
 348
 349         return FALSE;
 350 }
 351
 352 static gboolean __bt_le_discovery_finished_cb(gpointer user_data)
 353 {
 354         int result = BLUETOOTH_ERROR_NONE;
 355         le_scan_event_id = 0;
 356         GVariant *param = NULL;
 357         if (_bt_get_discovering_property(DISCOVERY_ROLE_LE) == FALSE) {
 358                 if (_bt_get_cancel_by_user() == TRUE)
 359                         result = BLUETOOTH_ERROR_CANCEL_BY_USER;
 360
 361                 g_list_free_full(p_adv_ind_list, __bt_free_bt_le_adv_info_t);
 362                 p_adv_ind_list = NULL;
 363
 364                 _bt_set_cancel_by_user(FALSE);
 365                 _bt_disable_all_scanner_status();
 366                 _bt_set_le_scan_status(FALSE);
 367                 param = g_variant_new("(i)", result);
 368                 _bt_send_event(BT_LE_ADAPTER_EVENT,
 369                         BLUETOOTH_EVENT_LE_DISCOVERY_FINISHED,
 370                         param);
 371         }
 372
 373         return FALSE;
 374 }
 375
 376 void __bt_update_remote_cache_devinfo(const char *address, gboolean paired_status)
 377 {
 378         BT_DBG("+");
 379
 380         ret_if(address == NULL);
 381
 382         GList * node;
 383         bt_cache_info_t *cache_info;
 384         bt_remote_dev_info_t *dev_info;
 385
 386         node = g_list_first(p_cache_list);
 387
 388         while (node != NULL) {
 389                 cache_info = (bt_cache_info_t *)node->data;
 390
 391                 if (cache_info == NULL) {
 392                         node = g_list_next(node);
 393                         continue;
 394                 }
 395
 396                 dev_info = cache_info->dev_info;
 397                 if (strcasecmp(dev_info->address,
 398                                         address) == 0) {
 399                         BT_DBG("Device Found");
 400                         if (paired_status == TRUE)
 401                                 cache_info->dev_info->paired = TRUE;
 402                         else
 403                                 cache_info->dev_info->paired = FALSE;
 404                         break;
 405                 }
 406                 node = g_list_next(node);
 407         }
 408         BT_DBG("-");
 409 }
 410
 411 static void __bt_device_remote_connected_properties(
 412                                 bt_remote_dev_info_t *remote_dev_info,
 413                                 char *address, gboolean connected)
 414 {
 415         int result = BLUETOOTH_ERROR_NONE;
 416         int i;
 417         GVariant *param = NULL;
 418         BT_DBG("+");
 419
 420         if (remote_dev_info->uuid_count > 0) {
 421                 for (i = 0; i < remote_dev_info->uuid_count; i++) {
 422                         char *uuid = remote_dev_info->uuids[i];
 423                         if (strcasecmp(uuid, HID_UUID) == 0) {
 424                                 int event = BLUETOOTH_EVENT_NONE;
 425
 426                                 event = (connected == TRUE) ?
 427                                         BLUETOOTH_HID_CONNECTED :
 428                                         BLUETOOTH_HID_DISCONNECTED;
 429                                 param = g_variant_new("(is)", result,
 430                                                         address);
 431                                 _bt_send_event(BT_HID_EVENT, event,
 432                                         param);
 433                                 break;
 434                         }
 435                 }
 436         }
 437
 438         BT_DBG("-");
 439 }
 440
 441 gboolean __bt_handle_is_flight_mode_enabled(void)
 442 {
 443 #ifdef TIZEN_FEATURE_FLIGHTMODE_ENABLED
 444         int is_flight_mode = 0;
 445         int ret = -1;
 446
 447         ret = vconf_get_bool(VCONFKEY_TELEPHONY_FLIGHT_MODE, &is_flight_mode);
 448         if (ret != 0)
 449                 BT_ERR("vconf_get_bool failed");
 450
 451         return (is_flight_mode == 0) ? FALSE : TRUE;
 452 #else
 453         return FALSE;
 454 #endif
 455 }
 456
 457 void _bt_handle_adapter_event(GVariant *msg, const char *member)
 458 {
 459         BT_DBG("+");
 460
 461         int result = BLUETOOTH_ERROR_NONE;
 462         GVariant *param = NULL;
 463         ret_if(member == NULL);
 464
 465         if (strcasecmp(member, "DeviceCreated") == 0) {
 466                 char *object_path = NULL;
 467                 char *address;
 468                 bt_remote_dev_info_t *remote_dev_info;
 469
 470                 ret_if(_bt_is_device_creating() == FALSE);
 471
 472                 /* Bonding from remote device */
 473                 address = g_malloc0(BT_ADDRESS_STRING_SIZE);
 474
 475                 g_variant_get(msg, "(&o)", &object_path);
 476                 _bt_convert_device_path_to_address((const char*)object_path, address);
 477
 478                 remote_dev_info = _bt_get_remote_device_info_by_object_path(object_path);
 479                 if (remote_dev_info == NULL) {
 480                         g_free(address);
 481                         return;
 482                 }
 483
 484                 _bt_free_device_info(remote_dev_info);
 485                 g_free(address);
 486         } else if (strcasecmp(member, "InterfacesRemoved") == 0) {
 487                 char *object_path = NULL;
 488                 char *address;
 489                 bt_cache_info_t *cache_info;
 490                 bt_remote_dev_info_t *dev_info;
 491                 GList * node;
 492
 493                 /* Bonding from remote device */
 494                 address = g_malloc0(BT_ADDRESS_STRING_SIZE);
 495
 496                 g_variant_get(msg, "(&o)", &object_path);
 497
 498                 _bt_convert_device_path_to_address((const char *)object_path, address);
 499
 500                 node = g_list_first(p_cache_list);
 501
 502                 while (node != NULL) {
 503                         cache_info = (bt_cache_info_t *)node->data;
 504
 505                         if (cache_info == NULL) {
 506                                 node = g_list_next(node);
 507                                 continue;
 508                         }
 509
 510                         dev_info = cache_info->dev_info;
 511                         if (strcasecmp(dev_info->address,
 512                                                 address) == 0) {
 513                                 p_cache_list = g_list_remove(p_cache_list,
 514                                                 cache_info);
 515                                 __bt_free_cache_info(cache_info);
 516                                 break;
 517                         }
 518                         node = g_list_next(node);
 519                 }
 520                 g_free(address);
 521         } else if (strcasecmp(member, "AdvertisingEnabled") == 0) {
 522                 BT_DBG("Advertising Enabled");
 523                 int slot_id;
 524                 int event;
 525                 int adv_handle;
 526                 gboolean status = FALSE;
 527
 528                 g_variant_get(msg, "(ib)", &slot_id, &status);
 529
 530                 BT_DBG("Advertising Enabled : slot_id [%d]  status [%d]", slot_id, status);
 531
 532                 /* Send event to application */
 533                 _bt_set_advertising_status(slot_id, status);
 534
 535                 adv_handle = _bt_get_adv_slot_adv_handle(slot_id);
 536
 537                 if (status)
 538                         event = BLUETOOTH_EVENT_ADVERTISING_STARTED;
 539                 else
 540                         event = BLUETOOTH_EVENT_ADVERTISING_STOPPED;
 541                 param = g_variant_new("(ii)", result,
 542                                         adv_handle);
 543
 544                 const char *sender;
 545                 sender = _bt_get_adv_slot_owner(slot_id);
 546                 _bt_send_event_to_dest(sender, BT_ADAPTER_EVENT,
 547                                 event,
 548                                 param);
 549
 550                 if (event == BLUETOOTH_EVENT_ADVERTISING_STOPPED) {
 551                         char *name = g_strdup(sender);
 552
 553                         _bt_unregister_adv_slot_owner(slot_id);
 554
 555                         /* Advertising disabled, notify TDS */
 556                         _bt_tds_handle_adv_disabled(name, adv_handle);
 557                         g_free(name);
 558                 }
 559         } else if (strcasecmp(member, "RssiEnabled") == 0) {
 560                 BT_DBG("RSSI Enabled");
 561                 gboolean status = FALSE;
 562                 char *address = NULL;
 563                 int link_type;
 564                 g_variant_get(msg, "(sib)", &address, &link_type, &status);
 565
 566                 BT_DBG("RSSI Enabled [%s %d]", address, status);
 567                 param = g_variant_new("(isib)", result,
 568                                         address, link_type, status);
 569                 _bt_send_event(BT_DEVICE_EVENT,
 570                                 BLUETOOTH_EVENT_RSSI_ENABLED,
 571                                 param);
 572                 g_free(address);
 573         } else if (strcasecmp(member, "RssiAlert") == 0) {
 574                 BT_DBG("RSSI Alert");
 575                 int alert_type;
 576                 int rssi_dbm;
 577                 int link_type;
 578                 char *address = NULL;
 579                 g_variant_get(msg, "(siii)", &address, &link_type, &alert_type, &rssi_dbm);
 580
 581                 BT_DBG("RSSI Alert: [Address %s LinkType %d] [Type %d DBM %d]",
 582                                 address, alert_type, rssi_dbm);
 583                 param = g_variant_new("(isiii)", result,
 584                                         address, link_type, alert_type, rssi_dbm);
 585                 _bt_send_event(BT_DEVICE_EVENT,
 586                                 BLUETOOTH_EVENT_RSSI_ALERT,
 587                                 param);
 588                 g_free(address);
 589         } else if (strcasecmp(member, "RawRssi") == 0) {
 590                 BT_DBG("RSSI Raw");
 591                 int rssi_dbm;
 592                 int link_type;
 593                 char *address = NULL;
 594                 g_variant_get(msg, "(sii)", &address, &link_type, &rssi_dbm);
 595
 596                 BT_DBG("Raw RSSI: [Address %s] [Link Type %d][RSSI DBM %d]",
 597                                 address, link_type, rssi_dbm);
 598                 param = g_variant_new("(isii)", result,
 599                                         address, link_type, rssi_dbm);
 600                 _bt_send_event(BT_DEVICE_EVENT,
 601                                 BLUETOOTH_EVENT_RAW_RSSI,
 602                                 param);
 603                 g_free(address);
 604         } else if (strcasecmp(member, BT_HARDWARE_ERROR) == 0) {
 605                 BT_ERR_C("### Hardware error received from BLUEZ");
 606 /* Don't add the recovery logic into platform */
 607 #if 0
 608                 _bt_recover_adapter();
 609 #endif
 610         } else if (strcasecmp(member, BT_TX_TIMEOUT_ERROR) == 0) {
 611                 BT_ERR_C("### Tx timeout error received from BLUEZ");
 612 /* Don't add the recovery logic into platform */
 613 #if 0
 614                 _bt_recover_adapter();
 615 #endif
 616         }
 617         BT_DBG("-");
 618 }
 619
 620 static void __bt_adapter_property_changed_event(GVariant *msg, const char *path)
 621 {
 622         GDBusProxy *adapter_proxy;
 623         int mode = 0;
 624         int result = BLUETOOTH_ERROR_NONE;
 625         GVariantIter value_iter;
 626         GVariant *val = NULL;
 627         GVariant *ret = NULL;
 628         GError *err = NULL;
 629         char *property = NULL;
 630         GVariant *param = NULL;
 631         g_variant_iter_init(&value_iter, msg);
 632         while ((g_variant_iter_loop(&value_iter, "{sv}", &property, &val))) {
 633                 BT_INFO("Property %s", property);
 634
 635                 if (strcasecmp(property, "Discovering") == 0) {
 636                         gboolean discovering = FALSE;
 637                         g_variant_get(val, "b", &discovering);
 638                         /* Send event to application */
 639                         BT_DBG("Discovering %d", discovering);
 640                         if (_bt_adapter_get_status() != BT_ACTIVATED)
 641                                 return;
 642
 643                         if (discovering == TRUE) {
 644                                 _bt_set_discovery_status(TRUE);
 645                                 param = g_variant_new("(i)", result);
 646                                 _bt_send_event(BT_ADAPTER_EVENT,
 647                                         BLUETOOTH_EVENT_DISCOVERY_STARTED,
 648                                         param);
 649                         } else {
 650                                 ret_if(event_id > 0);
 651
 652                                 adapter_proxy = _bt_get_adapter_proxy();
 653                                 ret_if(adapter_proxy == NULL);
 654
 655                                 /* Need to stop searching */
 656                                 ret = g_dbus_proxy_call_sync(adapter_proxy, "StopDiscovery",
 657                                         NULL,
 658                                         G_DBUS_CALL_FLAGS_NONE,
 659                                         DBUS_TIMEOUT, NULL,
 660                                         &err);
 661                                 if (err) {
 662                                         BT_ERR("Dbus Error : %s", err->message);
 663                                         g_clear_error(&err);
 664                                 }
 665                                 if (ret)
 666                                         g_variant_unref(ret);
 667
 668                                 event_id = g_timeout_add(BT_DISCOVERY_FINISHED_DELAY,
 669                                   (GSourceFunc)_bt_discovery_finished_cb, NULL);
 670                         }
 671                 } else if (strcasecmp(property, "LEDiscovering") == 0) {
 672                         gboolean le_discovering = FALSE;
 673
 674                         g_variant_get(val, "b", &le_discovering);
 675                         BT_DBG("LEDiscovering %d", le_discovering);
 676                         if (_bt_adapter_get_status() != BT_ACTIVATED ||
 677                                 _bt_adapter_get_le_status() != BT_LE_ACTIVATED)
 678                                 return;
 679
 680                         /* Send event to application */
 681                         if (le_discovering == TRUE) {
 682                                 _bt_set_le_scan_status(TRUE);
 683                                 param = g_variant_new("(i)", result);
 684                                 _bt_send_event(BT_LE_ADAPTER_EVENT,
 685                                 BLUETOOTH_EVENT_LE_DISCOVERY_STARTED,
 686                                 param);
 687                         } else {
 688                                 ret_if(le_scan_event_id > 0);
 689
 690                                 adapter_proxy = _bt_get_adapter_proxy();
 691                                 ret_if(adapter_proxy == NULL);
 692
 693                                 /* Need to stop searching */
 694                                 ret = g_dbus_proxy_call_sync(adapter_proxy, "StopLEDiscovery",
 695                                         NULL,
 696                                         G_DBUS_CALL_FLAGS_NONE,
 697                                         DBUS_TIMEOUT, NULL,
 698                                         &err);
 699                                 if (err) {
 700                                         BT_ERR("Dbus Error %s", err->message);
 701                                         g_clear_error(&err);
 702                                 }
 703                                 if (ret)
 704                                         g_variant_unref(ret);
 705
 706                                 le_scan_event_id = g_timeout_add(BT_DISCOVERY_FINISHED_DELAY,
 707                                                 (GSourceFunc)__bt_le_discovery_finished_cb, NULL);
 708                                 }
 709                 } else if (strcasecmp(property, "Name") == 0) {
 710                         char *name = NULL;
 711                         g_variant_get(val, "s", &name);
 712                         param = g_variant_new("(is)", result, name);
 713                         /* Send event to application */
 714                         _bt_send_event(BT_ADAPTER_EVENT,
 715                                 BLUETOOTH_EVENT_LOCAL_NAME_CHANGED,
 716                                 param);
 717                         g_free(name);
 718                 } else if (strcasecmp(property, "Alias") == 0) {
 719                         char *alias = NULL;
 720                         g_variant_get(val, "s", &alias);
 721                         param = g_variant_new("(is)", result, alias);
 722                         /* Send event to application */
 723                         _bt_send_event(BT_ADAPTER_EVENT,
 724                                 BLUETOOTH_EVENT_LOCAL_NAME_CHANGED,
 725                                 param);
 726                         g_free(alias);
 727                 } else if (strcasecmp(property, "Discoverable") == 0) {
 728                         gboolean discoverable = FALSE;
 729
 730                         g_variant_get(val, "b", &discoverable);
 731                         BT_DBG("discoverable %d", discoverable);
 732
 733                         if (discoverable == FALSE) {
 734                                 if (_bt_get_discoverable_timeout_property() > 0) {
 735                                         int time = 0;
 736                                         adapter_proxy = _bt_get_adapter_properties_proxy();
 737                                         ret_if(adapter_proxy == NULL);
 738                                         ret = g_dbus_proxy_call_sync(adapter_proxy, "Set",
 739                                                 g_variant_new("(ssv)", BT_ADAPTER_INTERFACE,
 740                                                 "DiscoverableTimeout",
 741                                                 g_variant_new("i", time)),
 742                                                 G_DBUS_CALL_FLAGS_NONE,
 743                                                 DBUS_TIMEOUT, NULL,
 744                                                 &err);
 745
 746                                         if (err != NULL) {
 747                                                 BT_ERR("StopLEDiscovery Failed: %s", err->message);
 748                                                 g_error_free(err);
 749                                         }
 750                                         if (ret)
 751                                                 g_variant_unref(ret);
 752                                 }
 753
 754                                 mode = BLUETOOTH_DISCOVERABLE_MODE_CONNECTABLE;
 755
 756                                 /* Send event to application */
 757                                 BT_INFO("[Connectable]");
 758                                 param = g_variant_new("(in)", result, mode);
 759                                 _bt_send_event(BT_ADAPTER_EVENT,
 760                                         BLUETOOTH_EVENT_DISCOVERABLE_MODE_CHANGED,
 761                                         param);
 762                         } else {
 763                                 _bt_get_discoverable_mode(&mode);
 764
 765                                 /* Event will be sent by "DiscoverableTimeout" signal */
 766                                 if (mode != BLUETOOTH_DISCOVERABLE_MODE_GENERAL_DISCOVERABLE) {
 767                                         g_free(property);
 768                                         g_variant_unref(val);
 769                                         return;
 770                                 }
 771
 772                                 /* Send event to application */
 773                                 BT_INFO("[General Discoverable]");
 774                                 param = g_variant_new("(in)", result, mode);
 775                                 _bt_send_event(BT_ADAPTER_EVENT,
 776                                         BLUETOOTH_EVENT_DISCOVERABLE_MODE_CHANGED,
 777                                         param);
 778                         }
 779                 } else if (strcasecmp(property, "DiscoverableTimeout") == 0) {
 780                         _bt_get_discoverable_mode(&mode);
 781
 782                         /* Event was already sent by "Discoverable" signal */
 783                         if (mode == BLUETOOTH_DISCOVERABLE_MODE_CONNECTABLE ||
 784                                 mode == BLUETOOTH_DISCOVERABLE_MODE_GENERAL_DISCOVERABLE) {
 785                                 g_free(property);
 786                                 g_variant_unref(val);
 787                                 return;
 788                         }
 789
 790                         /* Send event to application */
 791                         BT_INFO("[Limited Discoverable (Timeout %u secs)]",
 792                         _bt_get_discoverable_timeout_property());
 793                         param = g_variant_new("(in)", result, mode);
 794                         _bt_send_event(BT_ADAPTER_EVENT,
 795                                 BLUETOOTH_EVENT_DISCOVERABLE_MODE_CHANGED,
 796                                 param);
 797                 } else if (strcasecmp(property, "Powered") == 0) {
 798                         /* TODO: Need to check this operation!! */
 799                         gboolean powered = FALSE;
 800                         int bt_state;
 801
 802                         g_variant_get(val, "b", &powered);
 803                         BT_DBG("Powered = %d", powered);
 804                         if (powered == FALSE) {
 805 #ifdef TIZEN_FEATURE_BT_USB_DONGLE
 806                                 _bt_handle_adapter_removed();
 807 #else
 808                                 if (vconf_get_int(VCONFKEY_BT_STATUS, &bt_state) == 0 &&
 809                                 bt_state != VCONFKEY_BT_STATUS_OFF) {
 810                                         if (__bt_handle_is_flight_mode_enabled() == FALSE)
 811                                                 _bt_disable_adapter();
 812                                         else
 813                                                 _bt_handle_adapter_removed();
 814                                 }
 815 #endif
 816                                 if (vconf_get_int(VCONFKEY_BT_LE_STATUS, &bt_state) == 0 &&
 817                                         bt_state != VCONFKEY_BT_LE_STATUS_OFF) {
 818                                         _bt_set_le_disabled(BLUETOOTH_ERROR_NONE);
 819                                 }
 820                         } else {
 821 #ifdef TIZEN_FEATURE_BT_USB_DONGLE
 822                                 _bt_handle_adapter_added();
 823 #endif
 824                         }
 825                 } else if (strcasecmp(property, "Connectable") == 0) {
 826                         gboolean connectable = FALSE;
 827
 828                         g_variant_get(val, "b", &connectable);
 829
 830                         BT_DBG("Connectable property is changed : %d", connectable);
 831                         param = g_variant_new("(b)", connectable);
 832                         _bt_send_event(BT_ADAPTER_EVENT,
 833                                 BLUETOOTH_EVENT_CONNECTABLE_CHANGED,
 834                                 param);
 835 #if 0
 836                         if (_bt_adapter_get_status() == BT_DEACTIVATING &&
 837                         _bt_adapter_get_le_status() == BT_LE_ACTIVATED &&
 838                         connectable == 0)
 839                         _bt_set_disabled(BLUETOOTH_ERROR_NONE);
 840 #endif
 841                 } else if (strcasecmp(property, "SupportedLEFeatures") == 0) {
 842                         char *name = NULL;
 843                         char *value = NULL;
 844                         GVariantIter *iter = NULL;
 845                         g_variant_get(val, "as", &iter);
 846
 847                         ret_if(iter == NULL);
 848
 849                         while (g_variant_iter_loop(iter, "s", &name)) {
 850                                 BT_DBG("name = %s", name);
 851                                 g_variant_iter_loop(iter, "s", &value);
 852                                 BT_DBG("Value = %s", value);
 853                                 if (FALSE == _bt_update_le_feature_support(name, value))
 854                                         BT_INFO("Fail to update LE feature info");
 855                         }
 856
 857                         g_variant_iter_free(iter);
 858                 } else if (strcasecmp(property, "IpspInitStateChanged") == 0) {
 859                         gboolean ipsp_initialized = FALSE;
 860
 861                         g_variant_get(val, "b", &ipsp_initialized);
 862                         BT_DBG("IPSP init state changed: %d", ipsp_initialized);
 863                         param = g_variant_new("(b)", ipsp_initialized);
 864
 865                         /* Send event to application */
 866                         _bt_send_event(BT_ADAPTER_EVENT,
 867                                         BLUETOOTH_EVENT_IPSP_INIT_STATE_CHANGED,
 868                                         param);
 869                 } else {
 870                         BT_DBG("property : [%s]", property);
 871                 }
 872         }
 873 }
 874
 875 static void __bt_obex_property_changed_event(GVariant *msg, const char *path)
 876 {
 877         BT_DBG("+");
 878
 879         GVariantIter value_iter;
 880         GVariant *child = NULL, *val = NULL;
 881         char *property = NULL;
 882         g_variant_iter_init(&value_iter, msg);
 883         while ((child = g_variant_iter_next_value(&value_iter))) {
 884                 g_variant_get(child, "{sv}", &property, &val);
 885
 886                 ret_if(property == NULL);
 887
 888                 BT_DBG("property :%s", property);
 889
 890                 if (strcasecmp(property, "Status") == 0) {
 891                         char  *status;
 892                         g_variant_get(val, "s", &status);
 893
 894                         if (strcasecmp(status, "active") == 0) {
 895                                 _bt_obex_transfer_started(path);
 896                         } else if (strcasecmp(status, "complete") == 0) {
 897                                 _bt_obex_transfer_completed(path, TRUE);
 898                                 _bt_pbap_obex_transfer_completed(path, TRUE);
 899                         } else if (strcasecmp(status, "error") == 0) {
 900                                 _bt_obex_transfer_completed(path, FALSE);
 901                                 _bt_pbap_obex_transfer_completed(path, FALSE);
 902                         }
 903                         g_free(status);
 904                 } else if (strcasecmp(property, "Transferred") == 0) {
 905                         guint64 transferred  = 0;
 906                         /* As Transferred is expected guint64 so change int to guint64 and
 907                          * eariler transferred is static because of it can overwrite data
 908                          * on present on opc_obex_conn or obexd_conn as these are
 909                          * static memory are in sequential */
 910                         g_variant_get(val, "t", &transferred);
 911
 912                         _bt_obex_transfer_progress(path, transferred);
 913                 }
 914                 /* TODO: MAP, "Complete"? see above */
 915                 g_free(property);
 916                 g_variant_unref(val);
 917                 g_variant_unref(child);
 918         }
 919         BT_DBG("-");
 920 }
 921
 922 static void __bt_device_property_changed_event(GVariant *msg, const char *path)
 923 {
 924         BT_DBG("+");
 925
 926         int event;
 927         int result = BLUETOOTH_ERROR_NONE;
 928         GVariantIter value_iter;
 929         GVariant *val;
 930         char *property = NULL;
 931         char *address;
 932         GVariant *param = NULL;
 933         bt_remote_dev_info_t *remote_dev_info;
 934         g_variant_iter_init(&value_iter, msg);
 935 #ifdef TIZEN_FEATURE_BT_DPM
 936         int desktop_state = DPM_BT_ERROR;
 937 #endif
 938         while ((g_variant_iter_loop(&value_iter, "{sv}", &property, &val))) {
 939                 BT_DBG("Property %s", property);
 940                 if (strcasecmp(property, "Connected") == 0) {
 941                         guint connected = 0;
 942
 943                         g_variant_get(val, "i", &connected);
 944
 945                         event = (connected != BLUETOOTH_CONNECTED_LINK_NONE) ?
 946                                 BLUETOOTH_EVENT_DEVICE_CONNECTED :
 947                                 BLUETOOTH_EVENT_DEVICE_DISCONNECTED;
 948
 949                         address = g_malloc0(BT_ADDRESS_STRING_SIZE);
 950
 951                         _bt_convert_device_path_to_address(path, address);
 952
 953                         BT_DBG("connected: %d", connected);
 954                         BT_DBG("address: %s", address);
 955
 956                         remote_dev_info = _bt_get_remote_device_info_by_object_path(path);
 957
 958                         if (remote_dev_info != NULL) {
 959                                 __bt_device_remote_connected_properties(
 960                                                 remote_dev_info, address,
 961                                                 connected != BLUETOOTH_CONNECTED_LINK_NONE ?
 962                                                 TRUE : FALSE);
 963                                 _bt_free_device_info(remote_dev_info);
 964                         }
 965                         param = g_variant_new("(is)", result, address);
 966                         /* Send event to application */
 967                         _bt_send_event(BT_DEVICE_EVENT,
 968                                         event,
 969                                         param);
 970                         g_free(address);
 971                 } else if (strcasecmp(property, "RSSI") == 0) {
 972                         bt_remote_dev_info_t *remote_dev_info;
 973
 974                         address = g_malloc0(BT_ADDRESS_STRING_SIZE);
 975
 976                         _bt_convert_device_path_to_address(path, address);
 977                         BT_DBG("address: %s", address);
 978
 979                         g_free(address);
 980
 981                         remote_dev_info = _bt_get_remote_device_info_by_object_path(path);
 982                         if (remote_dev_info == NULL) {
 983                                 g_free(property);
 984                                 g_variant_unref(val);
 985                                 return;
 986                         }
 987                         BT_DBG("Address type  %d", remote_dev_info->addr_type);
 988
 989                         if (remote_dev_info->addr_type == 0) {
 990                                 BT_DBG("Name %s", remote_dev_info->name);
 991
 992 #ifdef TIZEN_FEATURE_BT_DPM
 993                                 _bt_dpm_get_bluetooth_desktop_connectivity_state(&desktop_state);
 994                                 if (desktop_state == DPM_RESTRICTED) {
 995                                         bluetooth_device_class_t device_class;
 996                                         _bt_divide_device_class(&device_class, remote_dev_info->class);
 997
 998                                         if (device_class.major_class ==
 999                                                 BLUETOOTH_DEVICE_MAJOR_CLASS_COMPUTER) {
1000                                                 _bt_free_device_info(remote_dev_info);
1001                                                 g_free(property);
1002                                                 g_variant_unref(val);
1003                                                 return;
1004                                         }
1005                                 }
1006 #endif
1007
1008                                 GVariant *uuids = NULL;
1009                                 GVariantBuilder *builder = NULL;
1010                                 int i = 0;
1011                                 builder = g_variant_builder_new(G_VARIANT_TYPE("as"));
1012                                 for (i = 0; i < remote_dev_info->uuid_count; i++) {
1013                                         g_variant_builder_add(builder, "s",
1014                                                 remote_dev_info->uuids[i]);
1015                                 }
1016                                 uuids = g_variant_new("as", builder);
1017                                 g_variant_builder_unref(builder);
1018                                 GVariant *manufacturer_data =  NULL;
1019                                 manufacturer_data = g_variant_new_from_data(G_VARIANT_TYPE_BYTESTRING,
1020                                                                         remote_dev_info->manufacturer_data,
1021                                                                         remote_dev_info->manufacturer_data_len,
1022                                                                         TRUE,
1023                                                                         NULL, NULL);
1024                                 param = g_variant_new("(isunsbub@asn@ay)", result,
1025                                                         remote_dev_info->address,
1026                                                         remote_dev_info->class,
1027                                                         remote_dev_info->rssi,
1028                                                         remote_dev_info->name,
1029                                                         remote_dev_info->paired,
1030                                                         remote_dev_info->connected,
1031                                                         remote_dev_info->trust,
1032                                                         uuids,
1033                                                         remote_dev_info->manufacturer_data_len,
1034                                                         manufacturer_data);
1035
1036                                 _bt_send_event(BT_ADAPTER_EVENT,
1037                                         BLUETOOTH_EVENT_REMOTE_DEVICE_FOUND,
1038                                         param);
1039                         }
1040                         _bt_free_device_info(remote_dev_info);
1041                 } else if (strcasecmp(property, "GattConnected") == 0) {
1042                         gboolean gatt_connected = FALSE;
1043
1044                         g_variant_get(val, "b", &gatt_connected);
1045
1046                         event = gatt_connected ? BLUETOOTH_EVENT_GATT_CONNECTED :
1047                                         BLUETOOTH_EVENT_GATT_DISCONNECTED;
1048
1049                         address = g_malloc0(BT_ADDRESS_STRING_SIZE);
1050
1051                         _bt_convert_device_path_to_address(path, address);
1052
1053                         BT_DBG("gatt_connected: %d", gatt_connected);
1054                         BT_DBG("address: %s", address);
1055                         param = g_variant_new("(is)", result, address);
1056                         /* Send event to application */
1057                         _bt_send_event(BT_DEVICE_EVENT,
1058                                         event,
1059                                         param);
1060                         g_free(address);
1061                 } else if (strcasecmp(property, "Paired") == 0) {
1062                         gboolean paired = FALSE;
1063                         bt_remote_dev_info_t *remote_dev_info;
1064                         g_variant_get(val, "b", &paired);
1065                         _bt_agent_set_canceled(FALSE);
1066                         /* BlueZ sends paired signal for each paired device */
1067                         /* during activation, We should ignore this, otherwise*/
1068                         /* application thinks that a new device got paired */
1069                         if (_bt_adapter_get_status() != BT_ACTIVATED) {
1070                                 BT_DBG("BT is not activated, so ignore this");
1071                                 g_free(property);
1072                                 g_variant_unref(val);
1073                                 return;
1074                         }
1075
1076                         address = g_malloc0(BT_ADDRESS_STRING_SIZE);
1077
1078                         _bt_convert_device_path_to_address(path, address);
1079
1080                         remote_dev_info = _bt_get_remote_device_info_by_object_path(path);
1081                         if (remote_dev_info == NULL) {
1082                                 g_free(property);
1083                                 g_variant_unref(val);
1084                                 g_free(address);
1085                                 return;
1086                         }
1087
1088                         if (paired == FALSE) {
1089                                 BT_INFO("Unpaired: %s", address);
1090                                 __bt_update_remote_cache_devinfo(address, FALSE);
1091                                 param = g_variant_new("(is)", result, address);
1092                                 _bt_send_event(BT_ADAPTER_EVENT,
1093                                         BLUETOOTH_EVENT_BONDED_DEVICE_REMOVED,
1094                                         param);
1095 #ifdef TIZEN_BT_A2DP_SINK_AUTO_CONNECT
1096                                 {
1097                                         char *last_connected = NULL;
1098                                         last_connected = vconf_get_str(BT_LAST_CONNECTED_DEVICE);
1099                                         if (!g_strcmp0(address, last_connected))
1100                                                 _bt_audio_set_auto_connect_device_addr("");
1101                                         if (last_connected)
1102                                                 free(last_connected);
1103                                 }
1104 #endif
1105                         } else {
1106                                 char secure_addr[BT_ADDRESS_STRING_SIZE] = { 0 };
1107
1108                                 _bt_convert_addr_string_to_secure_string(secure_addr, address);
1109                                 BT_INFO("### Paired: %s", secure_addr);
1110                                 __bt_update_remote_cache_devinfo(address, TRUE);
1111
1112                                 if (_bt_is_device_creating() == TRUE) {
1113                                         BT_DBG("Try to Pair by me");
1114                                         _bt_free_device_info(remote_dev_info);
1115                                         g_free(address);
1116                                         g_free(property);
1117                                         g_variant_unref(val);
1118                                         return;
1119                                 }
1120                                 GVariant *uuids = NULL;
1121                                 GVariantBuilder *builder = NULL;
1122                                 int i = 0;
1123                                 builder = g_variant_builder_new(G_VARIANT_TYPE("as"));
1124                                 for (i = 0; i < remote_dev_info->uuid_count; i++) {
1125                                         g_variant_builder_add(builder, "s",
1126                                                 remote_dev_info->uuids[i]);
1127                                 }
1128                                 uuids = g_variant_new("as", builder);
1129                                 g_variant_builder_unref(builder);
1130                                 GVariant *manufacturer_data =  NULL;
1131                                 manufacturer_data = g_variant_new_from_data(G_VARIANT_TYPE_BYTESTRING,
1132                                                                         remote_dev_info->manufacturer_data,
1133                                                                         remote_dev_info->manufacturer_data_len,
1134                                                                         TRUE,
1135                                                                         NULL, NULL);
1136
1137                                 param = g_variant_new("(isunsbub@asn@ay)", result,
1138                                                         address, remote_dev_info->class,
1139                                                         remote_dev_info->rssi,
1140                                                         remote_dev_info->name,
1141                                                         remote_dev_info->paired,
1142                                                         remote_dev_info->connected,
1143                                                         remote_dev_info->trust,
1144                                                         uuids,
1145                                                         remote_dev_info->manufacturer_data_len,
1146                                                         manufacturer_data);
1147                                 _bt_send_event(BT_ADAPTER_EVENT,
1148                                         BLUETOOTH_EVENT_BONDING_FINISHED,
1149                                         param);
1150                         }
1151                         _bt_free_device_info(remote_dev_info);
1152                         g_free(address);
1153                 } else if (strcasecmp(property, "LegacyPaired") == 0) {
1154                         gboolean paired = FALSE;
1155                         bt_remote_dev_info_t *remote_dev_info;
1156                         unsigned char auth_info[5] = {0, };
1157
1158                         if (_bt_adapter_get_status() != BT_ACTIVATED) {
1159                                 BT_DBG("BT is not activated, so ignore this");
1160                                 g_free(property);
1161                                 g_variant_unref(val);
1162                                 return;
1163                         }
1164
1165                         g_variant_get(val, "b", &paired);
1166                         address = g_malloc0(BT_ADDRESS_STRING_SIZE);
1167                         BT_DBG("LegacyPaired: %d", paired);
1168                         _bt_convert_device_path_to_address(path, address);
1169
1170                         remote_dev_info = _bt_get_remote_device_info_by_object_path(path);
1171                         if (remote_dev_info == NULL) {
1172                                 g_free(address);
1173                                 g_free(property);
1174                                 g_variant_unref(val);
1175                                 return;
1176                         }
1177                         if (remote_dev_info->is_alias_set == FALSE) {
1178                                 /*minimum Size of the samsung specific manufacturer data is greater than 30 */
1179                                 if ((remote_dev_info->manufacturer_data_len > 30) &&
1180                                         (remote_dev_info->manufacturer_data[0] == 0x00) &&
1181                                         (remote_dev_info->manufacturer_data[1] == 0x75)) {
1182
1183                                         /* 2  samsung (0x00 0x75) + 1 (control and version) + 1 (service ID) +
1184                                         1 (discovery version) + 1 (associated service ID)
1185                                         2 (Proxamity and locality) + 2 (Device type and icon) = 10 */
1186
1187                                         memcpy(auth_info, &(remote_dev_info->manufacturer_data[10]), 5);
1188                                 }
1189                         }
1190
1191                         BT_DBG("LegacyPairing Failed with %s. Show Error Popup", remote_dev_info->name);
1192                         _bt_launch_system_popup(BT_AGENT_EVENT_LEGACY_PAIR_FAILED_FROM_REMOTE,
1193                                                 remote_dev_info->name, auth_info, NULL, NULL, NULL);
1194
1195                         _bt_free_device_info(remote_dev_info);
1196                         g_free(address);
1197                 } else if (strcasecmp(property, "Trusted") == 0) {
1198                         gboolean trusted = FALSE;
1199
1200                         g_variant_get(val, "b", &trusted);
1201
1202                         event = trusted ? BLUETOOTH_EVENT_DEVICE_AUTHORIZED :
1203                                         BLUETOOTH_EVENT_DEVICE_UNAUTHORIZED;
1204
1205                         address = g_malloc0(BT_ADDRESS_STRING_SIZE);
1206
1207                         _bt_convert_device_path_to_address(path, address);
1208
1209                         BT_DBG("trusted: %d", trusted);
1210                         BT_DBG("address: %s", address);
1211                         param = g_variant_new("(is)", result, address);
1212                         /* Send event to application */
1213                         _bt_send_event(BT_DEVICE_EVENT,
1214                                         event,
1215                                         param);
1216                         g_free(address);
1217                 } else if (strcasecmp(property, "TrustedProfiles") == 0) {
1218                         int trusted = 0;
1219
1220                         g_variant_get(val, "u", &trusted);
1221
1222                         address = g_malloc0(BT_ADDRESS_STRING_SIZE);
1223                         _bt_convert_device_path_to_address(path, address);
1224
1225                         BT_DBG("Address: %s, TrustedProfiles: %d", address, trusted);
1226                         _bt_send_event(BT_DEVICE_EVENT,
1227                                         BLUETOOTH_EVENT_SUPPORTED_PROFILE_TRUSTED,
1228                                         g_variant_new("(isi)", result, address, trusted));
1229                         g_free(address);
1230                 } else if (strcasecmp(property, "IpspConnected") == 0) {
1231                         gboolean connected = FALSE;
1232
1233                         g_variant_get(val, "b", &connected);
1234
1235
1236                         event = connected ? BLUETOOTH_EVENT_IPSP_CONNECTED :
1237                                                         BLUETOOTH_EVENT_IPSP_DISCONNECTED;
1238
1239                         address = g_malloc0(BT_ADDRESS_STRING_SIZE);
1240
1241                         _bt_convert_device_path_to_address(path, address);
1242
1243                         BT_DBG("Ipspconnected: %d", connected);
1244                         BT_DBG("address: %s", address);
1245                         param = g_variant_new("(is)", result, address);
1246
1247                         /* Send event to application */
1248                         _bt_send_event(BT_DEVICE_EVENT,
1249                                         event,
1250                                         param);
1251                         g_free(address);
1252                 } else if (strcasecmp(property, "IpspBtInterfaceInfo") == 0) {
1253                         char *ifname = NULL;
1254
1255                         g_variant_get(val, "s", &ifname);
1256
1257                         address = g_malloc0(BT_ADDRESS_STRING_SIZE);
1258
1259                         _bt_convert_device_path_to_address(path, address);
1260
1261                         BT_DBG("Ipsp BT Interface Name: %s", ifname);
1262                         BT_DBG("address: %s", address);
1263                         param = g_variant_new("(iss)", result, address, ifname);
1264
1265                         /* Send event to application */
1266                         _bt_send_event(BT_DEVICE_EVENT,
1267                                         BLUETOOTH_EVENT_IPSP_INTERFACE_INFO,
1268                                         param);
1269                         g_free(address);
1270                 }
1271         }
1272         BT_DBG("-");
1273 }
1274
1275 static void __bt_media_control_changed_event(GVariant *msg, const char *path)
1276 {
1277         int event;
1278         int result = BLUETOOTH_ERROR_NONE;
1279         GVariantIter value_iter;
1280         char *property = NULL;
1281         char *address;
1282         GVariant *val = NULL;
1283         GVariant *child = NULL;
1284         bt_remote_dev_info_t *remote_dev_info;
1285         GVariant *param = NULL;
1286         g_variant_iter_init(&value_iter, msg);
1287         while ((child = g_variant_iter_next_value(&value_iter))) {
1288                 g_variant_get(child, "{sv}", &property, &val);
1289                 BT_INFO("Property %s", property);
1290                 if (strcasecmp(property, "Connected") == 0) {
1291                         gboolean connected = FALSE;
1292
1293                         g_variant_get(val, "b", &connected);
1294
1295                         event = connected ? BLUETOOTH_EVENT_AVRCP_CONNECTED :
1296                                         BLUETOOTH_EVENT_AVRCP_DISCONNECTED;
1297
1298                         address = g_malloc0(BT_ADDRESS_STRING_SIZE);
1299
1300                         _bt_convert_device_path_to_address(path, address);
1301
1302                         BT_DBG("connected: %d", connected);
1303                         BT_DBG("address: %s", address);
1304
1305                         remote_dev_info = _bt_get_remote_device_info(address);
1306
1307                         if (remote_dev_info != NULL) {
1308                                 __bt_device_remote_connected_properties(
1309                                 remote_dev_info, address, connected);
1310                                 _bt_free_device_info(remote_dev_info);
1311                         }
1312                         param = g_variant_new("(is)", result, address);
1313                         /* Send event to application */
1314                         _bt_send_event(BT_AVRCP_EVENT,
1315                                 event,
1316                                 param);
1317                         g_free(address);
1318                 }
1319                 g_free(property);
1320                 g_variant_unref(child);
1321                 g_variant_unref(val);
1322         }
1323         BT_DBG("-");
1324 }
1325
1326 int get_alert_level_enum(const char *alert)
1327 {
1328         int lvl = -1;
1329
1330         if (strcmp(alert, "none") == 0)
1331                 lvl = BT_PXP_ALERT_NONE;
1332         else if (strcmp(alert, "mild") == 0)
1333                 lvl = BT_PXP_ALERT_MILD;
1334         else if (strcmp(alert, "high") == 0)
1335                 lvl = BT_PXP_ALERT_HIGH;
1336
1337         return lvl;
1338 }
1339
1340 static void _bt_handle_pxp_property_changed_event(GVariant *msg, const char *path, int role)
1341 {
1342         int result = BLUETOOTH_ERROR_NONE;
1343         int service_type;
1344         int alert_lvl = -1;
1345         GVariantIter value_iter;
1346         char *property = NULL;
1347         char *address;
1348         GVariant *val = NULL;
1349         GVariant *child = NULL;
1350         GVariant *param = NULL;
1351         g_variant_iter_init(&value_iter, msg);
1352
1353         BT_DBG("+");
1354         while ((child = g_variant_iter_next_value(&value_iter))) {
1355                 g_variant_get(child, "{sv}", &property, &val);
1356                 BT_INFO("Property %s", property);
1357
1358                 if ((strcasecmp(property, "LinkLossAlertLevel") == 0) ||
1359                         (strcasecmp(property, "ImmediateAlertLevel") == 0)) {
1360                         char *alert_str = NULL;
1361
1362                         address = g_malloc0(BT_ADDRESS_STRING_SIZE);
1363                         _bt_convert_device_path_to_address(path, address);
1364
1365                         if (strcasecmp(property, "LinkLossAlertLevel") == 0)
1366                                 service_type = BT_PXP_PROPERTY_LLS;
1367                         else
1368                                 service_type = BT_PXP_PROPERTY_IAS;
1369
1370                         g_variant_get(val, "s", &alert_str);
1371                         if (alert_str)
1372                                 alert_lvl = get_alert_level_enum(alert_str);
1373
1374                         param = g_variant_new("(isiii)", result, address,
1375                                                                 role, service_type, alert_lvl);
1376
1377                         /* Send event to application */
1378                         _bt_send_event(BT_DEVICE_EVENT,
1379                                         BLUETOOTH_EVENT_PXP_PROPERTY_CHANGED,
1380                                         param);
1381                         g_free(address);
1382                         g_free(alert_str);
1383                 }
1384                 g_free(property);
1385                 g_variant_unref(child);
1386                 g_variant_unref(val);
1387         }
1388         BT_DBG("-");
1389 }
1390
1391 void _bt_handle_property_changed_event(GVariant *msg, const char *object_path)
1392 {
1393         char *interface_name = NULL;
1394         GVariant *val = NULL;
1395
1396         g_variant_get(msg, "(&s@a{sv}@as)", &interface_name, &val, NULL);
1397
1398         if (strcasecmp(interface_name, BT_ADAPTER_INTERFACE) == 0) {
1399                 __bt_adapter_property_changed_event(val,
1400                                         object_path);
1401         } else if (strcasecmp(interface_name, BT_DEVICE_INTERFACE) == 0) {
1402                 __bt_device_property_changed_event(val, object_path);
1403         } else if (strcasecmp(interface_name, BT_OBEX_TRANSFER_INTERFACE) == 0) {
1404                 BT_DBG("BT_OBEX_TRANSFER_INTERFACE");
1405                 __bt_obex_property_changed_event(val,
1406                                         object_path);
1407         } else if (strcasecmp(interface_name, BT_MEDIA_CONTROL_INTERFACE) == 0) {
1408                 __bt_media_control_changed_event(val,
1409                                         object_path);
1410         } else if (strcasecmp(interface_name, BT_PLAYER_CONTROL_INTERFACE) == 0) {
1411                 _bt_handle_avrcp_control_event(val,
1412                                         object_path);
1413         } else if (strcasecmp(interface_name, BT_NETWORK_CLIENT_INTERFACE) == 0) {
1414                 BT_DBG("BT_NETWORK_CLIENT_INTERFACE");
1415                 _bt_handle_network_client_event(val,
1416                                         object_path);
1417         } else if (strcasecmp(interface_name, BT_GATT_CHAR_INTERFACE) == 0) {
1418                 __bt_gatt_char_property_changed_event(val,
1419                                         object_path);
1420         } else if (strcasecmp(interface_name, BT_PROXIMITY_REPORTER_INTERFACE) == 0) {
1421                 BT_DBG("BT_PROXIMITY_REPORTER_INTERFACE");
1422                 _bt_handle_pxp_property_changed_event(val,
1423                                         object_path, BT_PXP_REPORTER_ROLE);
1424         }
1425         g_variant_unref(val);
1426 }
1427
1428 void __bt_opc_property_changed_event(GVariant *msg,
1429                                                 const char *path)
1430 {
1431         GVariantIter value_iter;
1432         char *property = NULL;
1433         GVariant *val = NULL;
1434         GVariant *child = NULL;
1435
1436         g_variant_iter_init(&value_iter, msg);
1437         if ((child = g_variant_iter_next_value(&value_iter))) {
1438                 g_variant_get(child, "{sv}", &property, &val);
1439                 ret_if(property == NULL);
1440
1441                 if (strcasecmp(property, "Status") == 0) {
1442                         char *status = NULL;
1443                         g_variant_get(val, "s", &status);
1444                         BT_DBG("Status is %s", status);
1445
1446                         if (strcasecmp(status, "active") == 0)
1447                                 _bt_obex_client_started(path);
1448                         else if (strcasecmp(status, "complete") == 0)
1449                                 _bt_obex_client_completed(path, TRUE);
1450                         else if (strcasecmp(status, "error") == 0)
1451                                 _bt_obex_client_completed(path, FALSE);
1452
1453                         g_free(status);
1454                 } else if (strcasecmp(property, "Transferred") == 0) {
1455                         guint64 transferred  = 0;
1456                         g_variant_get(val, "t", &transferred);
1457
1458                         _bt_obex_client_progress(path, transferred);
1459                 } else {
1460                         BT_DBG("property : [%s]", property);
1461                 }
1462                 g_free(property);
1463                 g_variant_unref(child);
1464                 g_variant_unref(val);
1465         }
1466 }
1467
1468 void _bt_opc_property_changed_event(GVariant *msg, char *path)
1469 {
1470         char *interface_name = NULL;
1471         GVariant *value = NULL;
1472         g_variant_get(msg, "(&s@a{sv}@as)", &interface_name, &value, NULL);
1473         BT_INFO("interface_name = %s", interface_name);
1474         if (strcasecmp(interface_name, BT_OBEX_TRANSFER_INTERFACE) == 0) {
1475                 __bt_opc_property_changed_event(value,
1476                                         path);
1477         } else {
1478                 BT_DBG("interface_name : [%s]", interface_name);
1479         }
1480         g_variant_unref(value);
1481 }
1482
1483
1484 void __bt_map_property_changed_event(GVariant *msg,
1485                                                 const char *path)
1486 {
1487         BT_DBG("Entered");
1488         GVariantIter value_iter;
1489         char *property = NULL;
1490         GVariant *val = NULL;
1491         GVariant *child = NULL;
1492
1493         g_variant_iter_init(&value_iter, msg);
1494         while ((child = g_variant_iter_next_value(&value_iter))) {
1495                 g_variant_get(child, "{sv}", &property, &val);
1496                 ret_if(property == NULL);
1497
1498                 if (strcasecmp(property, "Status") == 0) {
1499                         char *status = NULL;
1500                         g_variant_get(val, "s", &status);
1501                         BT_DBG("Status is %s", status);
1502
1503                         if (strcasecmp(status, "active") == 0) {
1504                                 BT_DBG("EVENT : STARTED");
1505                                 // currently doing nothing
1506                         } else if (strcasecmp(status, "complete") == 0) {
1507                                 BT_DBG("EVENT : COMPLETED");
1508                                 _bt_map_on_transfer_finished(path, BLUETOOTH_ERROR_NONE);
1509                         } else if (strcasecmp(status, "error") == 0) {
1510                                 BT_DBG("EVENT : FAILED");
1511                                 _bt_map_on_transfer_finished(path, BLUETOOTH_ERROR_INTERNAL);
1512                         }
1513                         g_free(status);
1514                 } else if (strcasecmp(property, "Transferred") == 0) {
1515                         guint64 transferred  = 0;
1516                         g_variant_get(val, "t", &transferred);
1517
1518                         BT_DBG("EVENT : PROGRESS CALLBACK");
1519                         // currently doing nothing - progress callback type is not used
1520                 } else {
1521                         BT_DBG("OTHER EVENT : property : [%s]", property);
1522                 }
1523                 g_free(property);
1524                 g_variant_unref(child);
1525                 g_variant_unref(val);
1526         }
1527 }
1528
1529 void _bt_map_property_changed_event(GVariant *msg, const char *path)
1530 {
1531         BT_DBG("Entered _bt_map_property_changed_event");
1532         char *interface_name = NULL;
1533         GVariant *value = NULL;
1534         g_variant_get(msg, "(&s@a{sv}@as)", &interface_name, &value, NULL);
1535         BT_INFO("interface_name = %s", interface_name);
1536         if (strcasecmp(interface_name, BT_OBEX_TRANSFER_INTERFACE) == 0) {
1537                 __bt_map_property_changed_event(value,
1538                                 path);
1539         } else {
1540                 BT_DBG("interface_name : [%s]", interface_name);
1541         }
1542         g_variant_unref(value);
1543 }
1544
1545
1546 void _bt_handle_input_event(GVariant *msg, const char *path)
1547 {
1548         int result = BLUETOOTH_ERROR_NONE;
1549         gboolean property_flag = FALSE;
1550         GVariantIter value_iter;
1551         char *property = NULL;
1552         GVariant *child = NULL, *val = NULL;
1553         bt_remote_dev_info_t *remote_dev_info;
1554         GVariant *param = NULL;
1555         g_variant_iter_init(&value_iter, msg);
1556         while ((child = g_variant_iter_next_value(&value_iter))) {
1557                 g_variant_get(child, "{sv}", &property, &val);
1558
1559                 ret_if(property == NULL);
1560
1561                 if (strcasecmp(property, "Connected") == 0) {
1562                         int event = BLUETOOTH_EVENT_NONE;
1563                         char *address;
1564                         g_variant_get(val, "b", &property_flag);
1565
1566                         address = g_malloc0(BT_ADDRESS_STRING_SIZE);
1567
1568                         _bt_convert_device_path_to_address(path, address);
1569
1570                         event = (property_flag == TRUE) ?
1571                                         BLUETOOTH_HID_CONNECTED :
1572                                         BLUETOOTH_HID_DISCONNECTED;
1573                         param = g_variant_new("(is)", result, address);
1574                         _bt_send_event(BT_HID_EVENT, event,
1575                                 param);
1576                         /* Check HID connection type (Keyboard or Mouse) and update the status */
1577                         remote_dev_info = _bt_get_remote_device_info_by_object_path(path);
1578
1579                         if (property_flag == TRUE) {
1580                                 hid_connected_device_count++;
1581                                 __bt_set_device_values(TRUE,
1582                                                 VCONFKEY_BT_DEVICE_HID_CONNECTED);
1583                         } else {
1584                                 hid_connected_device_count--;
1585                                 if (hid_connected_device_count == 0)
1586                                         __bt_set_device_values(FALSE,
1587                                                         VCONFKEY_BT_DEVICE_HID_CONNECTED);
1588                         }
1589
1590                         if (remote_dev_info != NULL) {
1591                                 BT_DBG("HID device class [%x]", remote_dev_info->class);
1592                                 if (remote_dev_info->class &
1593                                         BLUETOOTH_DEVICE_MINOR_CLASS_KEY_BOARD) {
1594                                         __bt_set_device_values(property_flag,
1595                                                 VCONFKEY_BT_DEVICE_HID_KEYBOARD_CONNECTED);
1596
1597                                 }
1598
1599                                 if (remote_dev_info->class &
1600                                                 BLUETOOTH_DEVICE_MINOR_CLASS_POINTING_DEVICE) {
1601                                         __bt_set_device_values(property_flag,
1602                                                         VCONFKEY_BT_DEVICE_HID_MOUSE_CONNECTED);
1603                                 }
1604                                 _bt_free_device_info(remote_dev_info);
1605                         }
1606                         g_free(address);
1607                 }
1608                 g_free(property);
1609                 g_variant_unref(val);
1610                 g_variant_unref(child);
1611          }
1612 }
1613
1614 void _bt_handle_network_server_event(GVariant *msg, const char *member)
1615 {
1616         int result = BLUETOOTH_ERROR_NONE;
1617         char *address = NULL;
1618         char *device = NULL;
1619         GVariant *param = NULL;
1620         ret_if(member == NULL);
1621         if (strcasecmp(member, "PeerConnected") == 0) {
1622                 g_variant_get(msg, "(ss)", &device, &address);
1623
1624                 __bt_set_device_values(TRUE,
1625                                 VCONFKEY_BT_DEVICE_PAN_CONNECTED);
1626                 param = g_variant_new("(iss)", result, device, address);
1627                 _bt_send_event(BT_NETWORK_EVENT, BLUETOOTH_EVENT_NETWORK_SERVER_CONNECTED,
1628                         param);
1629                 g_free(device);
1630                 g_free(address);
1631                  nap_connected_device_count++;
1632         } else if (strcasecmp(member, "PeerDisconnected") == 0) {
1633                 g_variant_get(msg, "(ss)", &device, &address);
1634                 nap_connected_device_count--;
1635                 if (nap_connected_device_count == 0)
1636                         __bt_set_device_values(FALSE,
1637                                 VCONFKEY_BT_DEVICE_PAN_CONNECTED);
1638                 param = g_variant_new("(iss)", result, device, address);
1639                 _bt_send_event(BT_NETWORK_EVENT, BLUETOOTH_EVENT_NETWORK_SERVER_DISCONNECTED,
1640                         param);
1641                 g_free(device);
1642                 g_free(address);
1643         }
1644 }
1645
1646 void _bt_handle_network_client_event(GVariant *msg,
1647                                 const char *path)
1648 {
1649         BT_DBG("+");
1650
1651         int result = BLUETOOTH_ERROR_NONE;
1652         gboolean property_flag = FALSE;
1653         char *property = NULL;
1654         GVariant *val = NULL;
1655         GVariantIter value_iter;
1656         GVariant *param = NULL;
1657         g_variant_iter_init(&value_iter, msg);
1658         while ((g_variant_iter_loop(&value_iter, "{sv}", &property, &val))) {
1659                 if (strcasecmp(property, "Connected") == 0) {
1660                         int event = BLUETOOTH_EVENT_NONE;
1661                         char *address;
1662
1663                         g_variant_get(val, "b", &property_flag);
1664                         address = g_malloc0(BT_ADDRESS_STRING_SIZE);
1665
1666                         _bt_convert_device_path_to_address(path, address);
1667
1668                         BT_DBG("property_flag %d", property_flag);
1669                         if (property_flag == TRUE) {
1670                                 event = BLUETOOTH_EVENT_NETWORK_CONNECTED;
1671                                 nap_connected_device_count++;
1672                                 __bt_set_device_values(TRUE,
1673                                         VCONFKEY_BT_DEVICE_PAN_CONNECTED);
1674                         } else {
1675                                 event = BLUETOOTH_EVENT_NETWORK_DISCONNECTED;
1676                                 nap_connected_device_count--;
1677                                 if (nap_connected_device_count == 0)
1678                                         __bt_set_device_values(FALSE,
1679                                                 VCONFKEY_BT_DEVICE_PAN_CONNECTED);
1680                         }
1681                         param = g_variant_new("(is)", result, address);
1682                         _bt_send_event(BT_NETWORK_EVENT, event,
1683                                 param);
1684
1685                         g_free(address);
1686                 }
1687         }
1688         BT_DBG("-");
1689 }
1690
1691 void __bt_gatt_char_property_changed_event(GVariant *msg,
1692                                 const char *path)
1693 {
1694         GVariantIter value_iter;
1695         char *property = NULL;
1696         GVariant *val = NULL;
1697         g_variant_iter_init(&value_iter, msg);
1698         while ((g_variant_iter_loop(&value_iter, "{sv}", &property, &val))) {
1699                 BT_INFO("Property %s", property);
1700
1701                 ret_if(property == NULL);
1702
1703                 if (strcasecmp(property, "Notifying") == 0) {
1704                         gboolean property_flag = FALSE;
1705                         g_variant_get(val, "b", &property_flag);
1706                         if (property_flag == TRUE)
1707                                 BT_DBG("notifying is enabled");
1708                         else
1709                                 BT_DBG("notifying is disabled");
1710                 }
1711         }
1712 }
1713
1714 void _bt_handle_gatt_event(GVariant *msg, const char *member, const char *path)
1715 {
1716         ret_if(path == NULL);
1717         if (strcasecmp(member, "GattValueChanged") == 0) {
1718                 /* Check TDS seekers waiting for Indication  */
1719                 _bt_tds_check_indication(path, msg);
1720         } else {
1721                 BT_INFO("Unhandled event");
1722         }
1723 }
1724
1725 void _bt_handle_device_event(GVariant *msg, const char *member, const char *path)
1726 {
1727         int event = 0;
1728         int result = BLUETOOTH_ERROR_NONE;
1729         char *address;
1730         char *dev_name = NULL;
1731         const char *property = NULL;
1732         GVariant *param = NULL;
1733         char secure_address[BT_ADDRESS_STRING_SIZE] = { 0 };
1734         ret_if(path == NULL);
1735
1736         if (strcasecmp(member, "PropertyChanged") == 0) {
1737
1738                 g_variant_get(msg, "(s)", &property);
1739
1740                 ret_if(property == NULL);
1741
1742                 if (strcasecmp(property, "GattConnected") == 0) {
1743                         gboolean connected = FALSE;
1744                         char *address;
1745                         address = g_malloc0(BT_ADDRESS_STRING_SIZE);
1746
1747                         _bt_convert_device_path_to_address(path, address);
1748                         g_variant_get(msg, "(b)", &connected);
1749
1750                         event = connected ? BLUETOOTH_EVENT_GATT_CONNECTED :
1751                                         BLUETOOTH_EVENT_GATT_DISCONNECTED;
1752                         param = g_variant_new("(is)", result, address);
1753                         _bt_send_event(BT_DEVICE_EVENT,
1754                                         event,
1755                                         param);
1756                         g_free(address);
1757                 } else if (strcasecmp(property, "Paired") == 0) {
1758                         gboolean paired = FALSE;
1759                         bt_remote_dev_info_t *remote_dev_info;
1760                         g_variant_get(msg, "(b)", &paired);
1761
1762                         ret_if(paired == FALSE);
1763
1764                         /* BlueZ sends paired signal for each paired device */
1765                         /* during activation, We should ignore this, otherwise*/
1766                         /* application thinks that a new device got paired */
1767                         if (_bt_adapter_get_status() != BT_ACTIVATED) {
1768                                 BT_DBG("BT is not activated, so ignore this");
1769                                 return;
1770                         }
1771
1772                         if (_bt_is_device_creating() == TRUE) {
1773                                 BT_DBG("Try to Pair by me");
1774                                 return;
1775                         }
1776
1777                         address = g_malloc0(BT_ADDRESS_STRING_SIZE);
1778
1779                         _bt_convert_device_path_to_address(path, address);
1780
1781                         remote_dev_info = _bt_get_remote_device_info_by_object_path(path);
1782                         if (remote_dev_info == NULL) {
1783                                 g_free(address);
1784                                 return;
1785                         }
1786                         GVariant *uuids = NULL;
1787                         GVariantBuilder *builder = NULL;
1788                         int i = 0;
1789                         builder = g_variant_builder_new(G_VARIANT_TYPE("as"));
1790                         for (i = 0; i < remote_dev_info->uuid_count; i++) {
1791                                 g_variant_builder_add(builder, "s",
1792                                         remote_dev_info->uuids[i]);
1793                         }
1794                         uuids = g_variant_new("as", builder);
1795                         g_variant_builder_unref(builder);
1796                         GVariant *manufacturer_data = NULL;
1797                         manufacturer_data = g_variant_new_from_data(
1798                                                 G_VARIANT_TYPE_BYTESTRING,
1799                                                 remote_dev_info->manufacturer_data,
1800                                                 remote_dev_info->manufacturer_data_len,
1801                                                 TRUE, NULL, NULL);
1802                         param = g_variant_new("(isunsbub@asn@ay)", result,
1803                                                 address,
1804                                                 remote_dev_info->class,
1805                                                 remote_dev_info->rssi,
1806                                                 remote_dev_info->name,
1807                                                 remote_dev_info->paired,
1808                                                 remote_dev_info->connected,
1809                                                 remote_dev_info->trust,
1810                                                 uuids,
1811                                                 remote_dev_info->manufacturer_data_len,
1812                                                 manufacturer_data);
1813                         _bt_send_event(BT_ADAPTER_EVENT,
1814                                 BLUETOOTH_EVENT_BONDING_FINISHED,
1815                                 param);
1816                         _bt_free_device_info(remote_dev_info);
1817                         g_free(address);
1818
1819                 } else if (strcasecmp(property, "UUIDs") == 0) {
1820                         /* Once we get the updated uuid information after
1821                          * reverse service search, update it to application */
1822
1823                         bt_remote_dev_info_t *remote_dev_info;
1824
1825                         ret_if(_bt_is_device_creating() == TRUE);
1826
1827                         address = g_malloc0(BT_ADDRESS_STRING_SIZE);
1828
1829                         _bt_convert_device_path_to_address(path, address);
1830
1831                         remote_dev_info = _bt_get_remote_device_info_by_object_path(path);
1832                         if (remote_dev_info == NULL) {
1833                                 g_free(address);
1834                                 return;
1835                         }
1836
1837                         BT_DBG("UUID's count = %d", remote_dev_info->uuid_count);
1838                         if (remote_dev_info->paired && remote_dev_info->uuid_count) {
1839                                 GVariant *uuids = NULL;
1840                                 GVariantBuilder *builder = NULL;
1841                                 int i = 0;
1842                                 builder = g_variant_builder_new(G_VARIANT_TYPE("as"));
1843                                 for (i = 0; i < remote_dev_info->uuid_count; i++) {
1844                                         g_variant_builder_add(builder, "s",
1845                                                 remote_dev_info->uuids[i]);
1846                                 }
1847                                 uuids = g_variant_new("as", builder);
1848                                 g_variant_builder_unref(builder);
1849                                 GVariant *manufacture_data = g_variant_new_from_data((const GVariantType *)"ay",
1850                                                 remote_dev_info->manufacturer_data, remote_dev_info->manufacturer_data_len,
1851                                                 TRUE, NULL, NULL);
1852
1853                                 param = g_variant_new("(isunsbub@asn@ay)", result,
1854                                                         address, remote_dev_info->class,
1855                                                         remote_dev_info->rssi,
1856                                                         remote_dev_info->name,
1857                                                         remote_dev_info->paired,
1858                                                         remote_dev_info->connected,
1859                                                         remote_dev_info->trust,
1860                                                         uuids,
1861                                                         remote_dev_info->manufacturer_data_len,
1862                                                         manufacture_data);
1863                                 _bt_send_event(BT_ADAPTER_EVENT,
1864                                         BLUETOOTH_EVENT_SERVICE_SEARCHED,
1865                                         param);
1866                         }
1867
1868                         _bt_free_device_info(remote_dev_info);
1869                         g_free(address);
1870                 }
1871         } else if (strcasecmp(member, "DeviceConnected") == 0) {
1872                 unsigned char addr_type = 0;
1873
1874                 g_variant_get(msg, "(y)", &addr_type);
1875
1876                 address = g_malloc0(BT_ADDRESS_STRING_SIZE);
1877
1878                 _bt_convert_device_path_to_address(path, address);
1879                 dev_name = _bt_get_bonded_device_name(address);
1880
1881                 _bt_convert_addr_string_to_secure_string(secure_address, address);
1882                 BT_INFO("Address : %s Type : %d", secure_address, addr_type);
1883                 BT_ERR_C("### Connected [%s] [%s]", !addr_type ? "BREDR" : "LE",
1884                                 !addr_type ? dev_name : secure_address);
1885                 g_free(dev_name);
1886
1887                 if (addr_type)
1888                         _bt_add_le_connected_dev_info(address);
1889
1890                 _bt_logging_connection(TRUE, addr_type);
1891                 param = g_variant_new("(isy)", result, address, addr_type);
1892                 /*Send event to application*/
1893                 _bt_send_event(BT_DEVICE_EVENT,
1894                                         BLUETOOTH_EVENT_DEVICE_CONNECTED,
1895                                         param);
1896                 g_free(address);
1897         } else if (strcasecmp(member, "Disconnected") == 0) {
1898                 unsigned char disc_reason = 0;
1899                 unsigned char addr_type = 0;
1900                 char *dev_name = NULL;
1901                 gboolean sending = FALSE;
1902
1903                 g_variant_get(msg, "(yys)", &addr_type, &disc_reason, &dev_name);
1904
1905                 result = disc_reason;
1906
1907                 address = g_malloc0(BT_ADDRESS_STRING_SIZE);
1908
1909                 _bt_convert_device_path_to_address(path, address);
1910
1911                 /* 0x00 BDADDR_BRDER
1912                       0x01 BDADDR_LE_PUBLIC
1913                       0x02 BDADDR_LE_RANDOM */
1914                 _bt_convert_addr_string_to_secure_string(secure_address, address);
1915                 BT_INFO("Address : %s Type : %d", secure_address, addr_type);
1916                 BT_ERR_C("### Disconnected [%s] [%d : %s] [%s]", !addr_type ? "BREDR" : "LE",
1917                                 disc_reason, _bt_convert_disc_reason_to_string(disc_reason),
1918                                 !addr_type ? dev_name : secure_address);
1919                 g_free(dev_name);
1920
1921                 _bt_headset_set_local_connection(FALSE);
1922                 _bt_logging_connection(FALSE, addr_type);
1923
1924                 if (addr_type)
1925                         _bt_remove_le_connected_dev_info(address);
1926                 else {
1927 #ifdef TIZEN_BT_A2DP_SINK_AUTO_CONNECT
1928                         {
1929                                 int bt_device_state = VCONFKEY_BT_DEVICE_NONE;
1930
1931                                 if (vconf_get_int(VCONFKEY_BT_DEVICE, &bt_device_state) != 0)
1932                                         BT_ERR("vconf_get_int failed");
1933
1934                                 BT_INFO("conn_state[0x%x], adapter_state [%d]",
1935                                                         bt_device_state, _bt_adapter_get_status());
1936
1937                                 if (disc_reason == BLUETOOTH_ERROR_CONNECTION_TIMEOUT) {
1938                                         _bt_audio_start_auto_connect(TRUE);
1939                                 } else if (bt_device_state &
1940                                                         VCONFKEY_BT_DEVICE_A2DP_SOURCE_CONNECTED) {
1941                                         BT_INFO("Disconnected due to turning BT off. Skip a address");
1942                                 } else {
1943                                         char *last_connected = NULL;
1944                                         last_connected = vconf_get_str(BT_LAST_CONNECTED_DEVICE);
1945                                         if (!g_strcmp0(address, last_connected))
1946                                                 _bt_audio_set_auto_connect_device_addr("");
1947                                         if (last_connected)
1948                                                 free(last_connected);
1949                                 }
1950                         }
1951
1952 #endif
1953                         /*Check for any OPP transfer on the device and cancel
1954                          * the transfer
1955                          */
1956                         _bt_obex_check_pending_transfer(address);
1957                         _bt_opp_client_is_sending(&sending);
1958                         if (sending == TRUE)
1959                                 _bt_opp_client_check_pending_transfer(address);
1960                         /* TODO: MAP? see above */
1961                 }
1962                 param = g_variant_new("(isy)", result, address, addr_type);
1963                 _bt_send_event(BT_DEVICE_EVENT,
1964                                         BLUETOOTH_EVENT_DEVICE_DISCONNECTED,
1965                                         param);
1966                 g_free(address);
1967         } else if (strcasecmp(member, "ProfileStateChanged") == 0) {
1968                 int state = 0;
1969                 char *profile_uuid = NULL;
1970                 bt_headset_wait_t *wait_list;
1971                 bluetooth_device_address_t bd_addr;
1972
1973                 g_variant_get(msg, "(si)", &profile_uuid, &state);
1974
1975                 address = g_malloc0(BT_ADDRESS_STRING_SIZE);
1976
1977                 _bt_convert_device_path_to_address(path, address);
1978                 _bt_convert_addr_string_to_type(bd_addr.addr, address);
1979
1980                 _bt_convert_addr_string_to_secure_string(secure_address, address);
1981                 BT_DBG("Address: %s", secure_address);
1982                 BT_DBG("Profile UUID: %s", profile_uuid);
1983                 BT_DBG("State: %d", state);
1984
1985                 if ((strcmp(profile_uuid, A2DP_SINK_UUID) == 0)  &&
1986                         (state == BT_PROFILE_STATE_CONNECTED)) {
1987
1988                         int event = BLUETOOTH_EVENT_AV_CONNECTED;
1989 #ifndef TIZEN_BT_DUAL_HEADSET_CONNECT
1990                         bluetooth_device_address_t device_address;
1991                         char connected_address[BT_ADDRESS_STRING_SIZE + 1];
1992                         gboolean connected;
1993 #endif
1994                         bt_headset_wait_t *wait_list;
1995                         guint restricted = 0x0;
1996
1997                         __bt_set_device_values(TRUE,
1998                                 VCONFKEY_BT_DEVICE_A2DP_HEADSET_CONNECTED);
1999
2000                         __bt_connection_manager_set_state(address, event);
2001
2002                         _bt_get_restrict_profile(&bd_addr, RESTRICTED_PROFILE_HFP_HS, &restricted);
2003
2004                         if (_bt_headset_get_local_connection() == FALSE) {
2005                                 if (restricted == 0x0) /* not restricted*/
2006                                         _bt_start_timer_for_connection(address, BT_AUDIO_HSP);
2007                         } else {
2008                                 /* Connection Started from local device therefore no need to
2009                                  * intiate connection for pending profile */
2010                                 _bt_headset_set_local_connection(FALSE);
2011                         }
2012                         param = g_variant_new("(is)", result, address);
2013                         _bt_send_event(BT_HEADSET_EVENT, event,
2014                                 param);
2015 #ifdef TIZEN_BT_DUAL_HEADSET_CONNECT
2016                         _bt_check_already_connected_headset(BT_AUDIO_A2DP,
2017                                                 address);
2018 #else
2019                         connected = _bt_is_headset_type_connected(BT_AUDIO_A2DP,
2020                                                 connected_address);
2021                         if (connected) {
2022                                 if (g_strcmp0(connected_address, address) != 0) {
2023                                         _bt_convert_addr_string_to_type(
2024                                                 device_address.addr,
2025                                                 connected_address);
2026                                         _bt_audio_disconnect(0, BT_AUDIO_A2DP,
2027                                                 &device_address, NULL);
2028                                 }
2029                         }
2030 #endif
2031                         _bt_add_headset_to_list(BT_AUDIO_A2DP,
2032                                                 BT_STATE_CONNECTED, address);
2033
2034                         wait_list = _bt_get_audio_wait_data();
2035                         if (wait_list != NULL &&
2036                                 (g_strcmp0(wait_list->address, address) == 0))
2037                                 _bt_rel_wait_data();
2038
2039                 } else if ((strcmp(profile_uuid, A2DP_SINK_UUID) == 0)  &&
2040                         (state == BT_PROFILE_STATE_DISCONNECTED)) {
2041
2042                         int event = BLUETOOTH_EVENT_AV_DISCONNECTED;
2043
2044                         if (!_bt_is_service_connected(address, BT_AUDIO_A2DP)) {
2045                                 g_free(address);
2046                                 g_free(profile_uuid);
2047                                 return;
2048                         }
2049
2050                         __bt_set_device_values(FALSE,
2051                                 VCONFKEY_BT_DEVICE_A2DP_HEADSET_CONNECTED);
2052
2053                         __bt_connection_manager_set_state(address, event);
2054                         param = g_variant_new("(is)", result, address);
2055                         _bt_send_event(BT_HEADSET_EVENT, event,
2056                                 param);
2057                         /* Remove data from the connected list */
2058                         _bt_remove_headset_from_list(BT_AUDIO_A2DP, address);
2059                         wait_list = _bt_get_audio_wait_data();
2060
2061                         if (wait_list == NULL) {
2062                                 g_free(address);
2063                                 g_free(profile_uuid);
2064                                 return;
2065                         }
2066
2067                         if (((wait_list->type == BT_AUDIO_ALL) &&
2068                                 (wait_list->ag_flag == TRUE)) ||
2069                                 (wait_list->type == BT_AUDIO_A2DP) ||
2070                                 (wait_list->disconnection_type == BT_AUDIO_A2DP)) {
2071                                 bluetooth_device_address_t device_address;
2072                                 _bt_convert_addr_string_to_type(
2073                                                         device_address.addr,
2074                                                         wait_list->address);
2075
2076                                 _bt_audio_connect(wait_list->req_id,
2077                                                         wait_list->type,
2078                                                         &device_address,
2079                                                         NULL);
2080                         }
2081                 } else if (strcmp(profile_uuid, AVRCP_TARGET_UUID) == 0) {
2082
2083                         if (state == BT_PROFILE_STATE_CONNECTED) {
2084                                 int event = BLUETOOTH_EVENT_AVRCP_CONTROL_CONNECTED;
2085                                 char connected_address[BT_ADDRESS_STRING_SIZE + 1];
2086                                 bluetooth_device_address_t device_address;
2087                                 gboolean connected;
2088                                 param = g_variant_new("(is)", result, address);
2089                                 _bt_send_event(BT_AVRCP_CONTROL_EVENT, event,
2090                                         param);
2091                                 connected = _bt_is_headset_type_connected(
2092                                                         BT_AVRCP,
2093                                                         connected_address);
2094                                 if (connected) {
2095                                         if (g_strcmp0(connected_address,
2096                                                                 address) != 0) {
2097                                                 _bt_convert_addr_string_to_type(
2098                                                         device_address.addr,
2099                                                         connected_address);
2100                                                 _bt_audio_disconnect(0,
2101                                                         BT_AVRCP,
2102                                                         &device_address, NULL);
2103                                         }
2104                                 }
2105                                 BT_DBG("device Path: %s", path);
2106                                 _bt_add_headset_to_list(BT_AVRCP,
2107                                                 BT_STATE_CONNECTED, address);
2108                         } else if (state == BT_PROFILE_STATE_DISCONNECTED) {
2109                                 int event = BLUETOOTH_EVENT_AVRCP_CONTROL_DISCONNECTED;
2110                                 param = g_variant_new("(is)", result, address);
2111                                 _bt_send_event(BT_AVRCP_CONTROL_EVENT, event,
2112                                         param);
2113                                 /* Remove data from the connected list */
2114                                 _bt_remove_headset_from_list(BT_AVRCP, address);
2115                                 }
2116                 } else if (strcasecmp(profile_uuid, A2DP_SOURCE_UUID) == 0) {
2117                         if (state == BT_PROFILE_STATE_CONNECTED) {
2118                                 int event = BLUETOOTH_EVENT_AV_SOURCE_CONNECTED;
2119                                 BT_INFO("A2DP Source is connected");
2120 #ifdef TIZEN_BT_A2DP_SINK_ENABLE
2121                                 __bt_set_device_values(TRUE,
2122                                                 VCONFKEY_BT_DEVICE_A2DP_SOURCE_CONNECTED);
2123 #endif
2124
2125 #ifdef TIZEN_BT_A2DP_SINK_AUTO_CONNECT
2126                                 _bt_audio_set_auto_connect_device_addr(address);
2127                                 _bt_audio_stop_auto_connect();
2128 #endif
2129                                 _bt_add_headset_to_list(BT_AUDIO_A2DP_SOURCE,
2130                                                 BT_STATE_CONNECTED, address);
2131                                 _bt_send_event(BT_A2DP_SOURCE_EVENT, event,
2132                                         g_variant_new("(is)", result, address));
2133                         } else if (state == BT_PROFILE_STATE_DISCONNECTED) {
2134                                 int event = BLUETOOTH_EVENT_AV_SOURCE_DISCONNECTED;
2135                                 BT_INFO("A2DP Source Disconnected");
2136 #ifdef TIZEN_BT_A2DP_SINK_ENABLE
2137                                 __bt_set_device_values(FALSE,
2138                                                 VCONFKEY_BT_DEVICE_A2DP_SOURCE_CONNECTED);
2139 #endif
2140                                 _bt_remove_headset_from_list(BT_AUDIO_A2DP_SOURCE, address);
2141                                 _bt_send_event(BT_A2DP_SOURCE_EVENT, event,
2142                                                 g_variant_new("(is)", result, address));
2143
2144                                 wait_list = _bt_get_audio_wait_data();
2145                                 if (wait_list && wait_list->type == BT_AUDIO_A2DP_SOURCE) {
2146                                         bluetooth_device_address_t device_address;
2147                                         _bt_convert_addr_string_to_type(
2148                                                         device_address.addr,
2149                                                         wait_list->address);
2150
2151                                         _bt_audio_connect(wait_list->req_id,
2152                                                         wait_list->type,
2153                                                         &device_address,
2154                                                         NULL);
2155                                         /* Now free the wait list */
2156                                         _bt_rel_wait_data();
2157                                 }
2158                         }
2159                 } else if ((strcmp(profile_uuid, HID_UUID) == 0) &&
2160                         ((state == BT_PROFILE_STATE_CONNECTED) ||
2161                                 (state == BT_PROFILE_STATE_DISCONNECTED))) {
2162                         int event;
2163                         if (state == BT_PROFILE_STATE_CONNECTED)
2164                                 event = BLUETOOTH_HID_CONNECTED;
2165                         else
2166                                 event = BLUETOOTH_HID_DISCONNECTED;
2167                         param = g_variant_new("(is)", result, address);
2168                         _bt_send_event(BT_HID_EVENT, event,
2169                                 param);
2170
2171                         /* Set the vconf value for device */
2172                         if (state == BT_PROFILE_STATE_CONNECTED) {
2173                                 hid_connected_device_count++;
2174                                 __bt_set_device_values(TRUE,
2175                                                 VCONFKEY_BT_DEVICE_HID_CONNECTED);
2176                         } else {
2177                                 hid_connected_device_count--;
2178                                 if (hid_connected_device_count == 0)
2179                                         __bt_set_device_values(FALSE,
2180                                                 VCONFKEY_BT_DEVICE_HID_CONNECTED);
2181                         }
2182                 } else if (strcmp(profile_uuid, HID_DEVICE_UUID) == 0) {
2183                         if (state == BT_PROFILE_STATE_CONNECTED) {
2184                                 int event;
2185                                 event = BLUETOOTH_HID_DEVICE_CONNECTED;
2186                                 param = g_variant_new("(is)", result, address);
2187                                 _bt_send_event(BT_HID_DEVICE_EVENT, event,
2188                                         param);
2189                         } else if (state == BT_PROFILE_STATE_DISCONNECTED) {
2190                                 event = BLUETOOTH_HID_DEVICE_DISCONNECTED;
2191                                 param = g_variant_new("(is)", result, address);
2192                                 _bt_send_event(BT_HID_DEVICE_EVENT, event,
2193                                         param);
2194                         }
2195                 }
2196                 g_free(address);
2197                 g_free(profile_uuid);
2198         } else if (strcasecmp(member, "AdvReport") == 0) {
2199
2200                 bt_remote_le_dev_info_t *le_dev_info = NULL;
2201                 char *buffer = NULL;
2202                 int buffer_len = 0;
2203                 bt_le_adv_info_t *adv_info = NULL;
2204                 GVariant *value = NULL;
2205                 ret_if(_bt_is_le_scanning() == FALSE);
2206
2207                 le_dev_info = g_malloc0(sizeof(bt_remote_le_dev_info_t));
2208
2209                 g_variant_get(msg, "(syyii@ay)", &le_dev_info->address,
2210                                                 &le_dev_info->addr_type,
2211                                                 &le_dev_info->adv_type,
2212                                                 &le_dev_info->rssi,
2213                                                 &le_dev_info->adv_data_len,
2214                                                 &value);
2215
2216                 if (value == NULL) {
2217                         _bt_free_le_device_info(le_dev_info);
2218                         return;
2219                 }
2220
2221                 _bt_convert_device_path_to_address(path, le_dev_info->address);
2222
2223                 buffer_len = g_variant_get_size(value);
2224                 if (buffer_len > 0)
2225                         buffer = (char *)g_variant_get_data(value);
2226
2227                 le_dev_info->adv_data = g_memdup(buffer, buffer_len);
2228                 if (le_dev_info->adv_data == NULL &&
2229                         le_dev_info->adv_type != BT_LE_ADV_SCAN_RSP) {
2230                         _bt_free_le_device_info(le_dev_info);
2231                         g_variant_unref(value);
2232                         return;
2233                 }
2234
2235                 if (_bt_get_le_scan_type() == BT_LE_PASSIVE_SCAN) {
2236                         _bt_send_scan_result_event(le_dev_info, NULL);
2237                         _bt_free_le_device_info(le_dev_info);
2238                         g_variant_unref(value);
2239                         return;
2240                 }
2241
2242                 if (le_dev_info->adv_type != BT_LE_ADV_SCAN_RSP) {       /* ADV_IND */
2243                         adv_info = g_malloc0(sizeof(bt_le_adv_info_t));
2244                         adv_info->addr = g_strdup(le_dev_info->address);
2245                         adv_info->addr_type = le_dev_info->addr_type;
2246                         adv_info->rssi = le_dev_info->rssi;
2247                         adv_info->data_len = le_dev_info->adv_data_len;
2248                         adv_info->data = g_malloc0(le_dev_info->adv_data_len);
2249                         memcpy(adv_info->data, le_dev_info->adv_data,
2250                                         le_dev_info->adv_data_len);
2251
2252                         if (__bt_add_adv_ind_info(adv_info) == 0) {
2253                                 adv_info->timer_id = g_timeout_add(1000,
2254                                         (GSourceFunc)__bt_adv_scan_req_timeout_cb, (void*)adv_info);
2255                         }
2256                 } else {     /* SCAN_RSP */
2257                         adv_info = __bt_get_adv_ind_info(le_dev_info->address);
2258                         if (adv_info) {
2259                                 _bt_send_scan_result_event(le_dev_info, adv_info);
2260                                 __bt_del_adv_ind_info(le_dev_info->address);
2261                         }
2262                 }
2263                 _bt_free_le_device_info(le_dev_info);
2264                 g_variant_unref(value);
2265         } else if  (strcasecmp(member, "LEDataLengthChanged") == 0) {
2266                 guint16 tx_octets = 0;
2267                 guint16 tx_time = 0;
2268                 guint16 rx_octets = 0;
2269                 guint16 rx_time = 0;
2270
2271                 g_variant_get(msg, "(qqqq)",
2272                                 &tx_octets, &tx_time, &rx_octets, &rx_time);
2273
2274                 address = g_malloc0(BT_ADDRESS_STRING_SIZE);
2275                 _bt_convert_device_path_to_address(path, address);
2276
2277                 param = g_variant_new("(isqqqq)", result, address, tx_octets, tx_time,
2278                                 rx_octets, rx_time);
2279                 /* Send event to application */
2280                 _bt_send_event(BT_DEVICE_EVENT,
2281                                 BLUETOOTH_EVENT_LE_DATA_LENGTH_CHANGED, param);
2282                 g_free(address);
2283         } else if  (strcasecmp(member, "IpspStateChanged") == 0) {
2284                 gboolean connected = FALSE;
2285                 char *ifname = NULL;
2286                 GVariant *ipsp_param = NULL;
2287
2288                 g_variant_get(msg, "(bs)", &connected, &ifname);
2289
2290                 event = connected ? BLUETOOTH_EVENT_IPSP_CONNECTED :
2291                                                 BLUETOOTH_EVENT_IPSP_DISCONNECTED;
2292
2293                 address = g_malloc0(BT_ADDRESS_STRING_SIZE);
2294                 _bt_convert_device_path_to_address(path, address);
2295
2296                 BT_DBG("Ipsp BT Interface Name: %s", ifname);
2297                 BT_DBG("address: %s", address);
2298                 param = g_variant_new("(iss)", result, address, ifname);
2299                 ipsp_param = g_variant_new("(ss)", ifname, address);
2300
2301                 /* Set Ipv6 Addr */
2302                 GDBusProxy *ipsp_proxy;
2303                 if (connected) {
2304                         BT_DBG("IPSP connected, Set Ipv6 Addr");
2305                         ipsp_proxy = _bt_get_ipsp_proxy();
2306                         if (ipsp_proxy == NULL) {
2307                                 BT_ERR("can not get ipsp proxy");
2308                                 g_free(address);
2309                                 return;
2310                         }
2311
2312                         g_dbus_proxy_call(ipsp_proxy, "SetIpv6Addr",
2313                                         ipsp_param, G_DBUS_CALL_FLAGS_NONE,
2314                                         -1, NULL, NULL, NULL);
2315                 } else {
2316                         BT_DBG("IPSP disconnected");
2317                         ipsp_proxy = _bt_get_ipsp_proxy();
2318                         if (ipsp_proxy == NULL) {
2319                                 BT_ERR("can not get ipsp proxy");
2320                                 g_free(address);
2321                                 return;
2322                         }
2323
2324                         g_dbus_proxy_call(ipsp_proxy, "DisableIpsp",
2325                                         NULL, G_DBUS_CALL_FLAGS_NONE,
2326                                         -1, NULL, NULL, NULL);
2327                 }
2328
2329                 /* Send event to application */
2330                 _bt_send_event(BT_DEVICE_EVENT,
2331                                                 event,
2332                                                 param);
2333                 g_free(address);
2334         } else if (strcasecmp(member, "AttMtuChanged") == 0) {
2335                 int result = BLUETOOTH_ERROR_NONE;
2336                 guint16 mtu = 0;
2337                 guint8 status = 0;
2338
2339                 g_variant_get(msg, "(q)", &mtu);
2340
2341                 address = g_malloc0(BT_ADDRESS_STRING_SIZE);
2342
2343                 _bt_convert_device_path_to_address(path, address);
2344                 _bt_convert_addr_string_to_secure_string(secure_address, address);
2345                 BT_DBG("Address : %s MTU changed : %d", secure_address, mtu);
2346
2347                 param = g_variant_new("(isqy)",
2348                         result,
2349                         address,
2350                         mtu,
2351                         status);
2352
2353                 /* Send the event to application */
2354                 _bt_send_event(BT_DEVICE_EVENT,
2355                         BLUETOOTH_EVENT_GATT_ATT_MTU_CHANGED,
2356                         param);
2357
2358                 g_free(address);
2359         }
2360 }
2361
2362 void __bt_set_audio_values(gboolean connected, char *address)
2363 {
2364         char *name = NULL;
2365         int bt_device_state = VCONFKEY_BT_DEVICE_NONE;
2366
2367         /*  Set the headset name */
2368         if (connected == TRUE)
2369                 name = _bt_get_bonded_device_name(address);
2370         else
2371                 name = g_strdup("");
2372
2373         if (vconf_set_str(VCONFKEY_BT_HEADSET_NAME, name) != 0)
2374                 BT_ERR("vconf_set_str failed");
2375
2376         g_free(name);
2377
2378         /*  Set the headset state */
2379         if (vconf_get_int(VCONFKEY_BT_DEVICE, &bt_device_state) != 0)
2380                 BT_ERR("vconf_get_int failed");
2381
2382 #ifdef TIZEN_SUPPORT_DUAL_HF
2383         if ((connected == TRUE) &&
2384                 (FALSE == __bt_is_companion_device(address))) {
2385                 bt_device_state |= VCONFKEY_BT_DEVICE_HEADSET_CONNECTED;
2386         } else if ((bt_device_state & VCONFKEY_BT_DEVICE_HEADSET_CONNECTED) &&
2387                         (FALSE == __bt_is_companion_device(address))) {
2388                 bt_device_state ^= VCONFKEY_BT_DEVICE_HEADSET_CONNECTED;
2389         }
2390 #else
2391         if (connected == TRUE)
2392                 bt_device_state |= VCONFKEY_BT_DEVICE_HEADSET_CONNECTED;
2393         else if (bt_device_state & VCONFKEY_BT_DEVICE_HEADSET_CONNECTED)
2394                 bt_device_state ^= VCONFKEY_BT_DEVICE_HEADSET_CONNECTED;
2395 #endif
2396
2397         if (vconf_set_int(VCONFKEY_BT_DEVICE,
2398                                 bt_device_state) != 0) {
2399                 BT_ERR("vconf_set_int failed");
2400         }
2401 }
2402
2403 void _bt_handle_headset_event(GVariant *msg, const char *path)
2404 {
2405         int result = BLUETOOTH_ERROR_NONE;
2406         gboolean property_flag = FALSE;
2407         char *property = NULL;
2408         GVariant *value = NULL;
2409         GVariant *param = NULL;
2410         g_variant_get(msg, "(sv)", &property, &value);
2411         bluetooth_device_address_t bd_addr;
2412
2413         ret_if(property == NULL);
2414
2415         BT_DBG("Property = %s \n", property);
2416         /* We allow only 1 headset connection (HSP or HFP)*/
2417         if (strcasecmp(property, "Connected") == 0) {
2418                 int event = BLUETOOTH_EVENT_NONE;
2419                 bt_headset_wait_t *wait_list;
2420                 char *address;
2421                 guint restricted = 0x0;
2422                 g_variant_get(value, "b", &property_flag);
2423
2424                 address = g_malloc0(BT_ADDRESS_STRING_SIZE);
2425
2426                 _bt_convert_device_path_to_address(path, address);
2427                 _bt_convert_addr_string_to_type(bd_addr.addr, address);
2428
2429                 if (property_flag == TRUE) {
2430                         event = BLUETOOTH_EVENT_AG_CONNECTED;
2431                         _bt_get_restrict_profile(&bd_addr, RESTRICTED_PROFILE_A2DP, &restricted);
2432
2433                         if (_bt_headset_get_local_connection() == FALSE) {
2434                                 if (restricted == 0x0) /* not restricted*/
2435                                         _bt_start_timer_for_connection(address, BT_AUDIO_A2DP);
2436                         } else
2437                                 _bt_headset_set_local_connection(FALSE);
2438                 } else {
2439                         int previous_state;
2440
2441                         event = BLUETOOTH_EVENT_AG_DISCONNECTED;
2442
2443                         previous_state = _bt_get_device_state_from_list(BT_AUDIO_HSP, address);
2444                         if (previous_state == BT_STATE_DISCONNECTING)
2445                                 _bt_send_hf_local_term_event(address);
2446                 }
2447                 /* Set the State machine here */
2448                 __bt_connection_manager_set_state(address, event);
2449                 __bt_set_audio_values(property_flag, address);
2450                 param = g_variant_new("(is)", result, address);
2451                 _bt_send_event(BT_HEADSET_EVENT, event,
2452                         param);
2453
2454                 if (event == BLUETOOTH_EVENT_AG_DISCONNECTED) {
2455                         /* Remove data from the connected list */
2456                         _bt_remove_headset_from_list(BT_AUDIO_HSP, address);
2457
2458                         wait_list = _bt_get_audio_wait_data();
2459                         if (wait_list == NULL) {
2460                                 g_free(address);
2461                                 return;
2462                         }
2463
2464                         bluetooth_device_address_t device_address;
2465
2466                         _bt_set_audio_wait_data_flag(TRUE);
2467
2468                         _bt_convert_addr_string_to_type(device_address.addr,
2469                                                         wait_list->address);
2470                         _bt_audio_connect(wait_list->req_id, wait_list->type,
2471                                         &device_address, NULL);
2472                 } else if (event == BLUETOOTH_EVENT_AG_CONNECTED) {
2473                         /* Add data to the connected list */
2474                         _bt_add_headset_to_list(BT_AUDIO_HSP,
2475                                                 BT_STATE_CONNECTED, address);
2476
2477                         wait_list = _bt_get_audio_wait_data();
2478                         if (wait_list != NULL &&
2479                                 (g_strcmp0(wait_list->address, address) == 0))
2480                         _bt_rel_wait_data();
2481
2482                         BT_INFO("Check A2DP pending connect");
2483                         _bt_audio_check_pending_connect();
2484                 }
2485                 g_free(address);
2486         } else if (strcasecmp(property, "State") == 0) {
2487                 char *state = NULL;
2488
2489                 g_variant_get(value, "s", &state);
2490
2491                 /* This code assumes we support only 1 headset connection */
2492                 /* Need to use the headset list, if we support multi-headsets */
2493                 if (strcasecmp(state, "Playing") == 0) {
2494                         BT_DBG("Playing: Sco Connected");
2495                 } else if (strcasecmp(state, "connected") == 0 ||
2496                                 strcasecmp(state, "disconnected") == 0) {
2497                         BT_DBG("connected/disconnected: Sco Disconnected");
2498                 } else {
2499                         BT_ERR("Not handled state - %s", state);
2500                         g_free(state);
2501                         return;
2502                 }
2503                 g_free(state);
2504         } else if (strcasecmp(property, "SpeakerGain") == 0) {
2505                 guint16 spkr_gain;
2506                 char *address;
2507
2508                 address = g_malloc0(BT_ADDRESS_STRING_SIZE);
2509
2510                 _bt_convert_device_path_to_address(path, address);
2511
2512                 spkr_gain = g_variant_get_uint16(value);
2513
2514                 BT_DBG("spkr_gain: %d", spkr_gain);
2515
2516                 param = g_variant_new("(i&sq)", result, address, spkr_gain);
2517                 _bt_send_event(BT_HEADSET_EVENT, BLUETOOTH_EVENT_AG_SPEAKER_GAIN,
2518                         param);
2519
2520                 g_free(address);
2521         } else if (strcasecmp(property, "MicrophoneGain") == 0) {
2522                 guint16 mic_gain;
2523                 char *address;
2524
2525                 address = g_malloc0(BT_ADDRESS_STRING_SIZE);
2526
2527                 _bt_convert_device_path_to_address(path, address);
2528
2529                 mic_gain = g_variant_get_uint16(value);
2530
2531                 param = g_variant_new("(i&sq)", result, address, mic_gain);
2532                 _bt_send_event(BT_HEADSET_EVENT, BLUETOOTH_EVENT_AG_MIC_GAIN,
2533                         param);
2534                 g_free(address);
2535         }
2536
2537         if (property)
2538                 g_free(property);
2539         g_variant_unref(value);
2540 }
2541
2542 void _bt_handle_sink_event(GVariant *msg, const char *path)
2543 {
2544         GVariantIter value_iter;
2545         char *property = NULL;
2546
2547         bt_headset_wait_t *wait_list;
2548
2549         GVariant *child = NULL;
2550         GVariant *val = NULL;
2551         GVariant *param = NULL;
2552         g_variant_iter_init(&value_iter, msg);
2553         while ((child = g_variant_iter_next_value(&value_iter))) {
2554
2555                 g_variant_get(child, "{sv}", &property, &val);
2556
2557                 ret_if(property == NULL);
2558
2559                 BT_DBG("Property = %s \n", property);
2560
2561
2562                 if (strcasecmp(property, "State") == 0) {
2563                         int result = BLUETOOTH_ERROR_NONE;
2564                         char *value;
2565
2566                         g_variant_get(val, "s", &value);
2567                         BT_DBG("value: %s", value);
2568
2569                         if (g_strcmp0(value, "disconnected") == 0) {
2570                                 char *address;
2571
2572                                 address = g_malloc0(BT_ADDRESS_STRING_SIZE);
2573
2574                                 _bt_convert_device_path_to_address(path, address);
2575
2576                                 __bt_set_device_values(FALSE,
2577                                         VCONFKEY_BT_DEVICE_A2DP_HEADSET_CONNECTED);
2578                                 param = g_variant_new("(is)", result, address);
2579                                 _bt_send_event(BT_HEADSET_EVENT,
2580                                         BLUETOOTH_EVENT_AV_DISCONNECTED,
2581                                         param);
2582
2583                                 /* Remove data from the connected list */
2584                                 _bt_remove_headset_from_list(BT_AUDIO_A2DP, address);
2585                                 wait_list = _bt_get_audio_wait_data();
2586                                 if (wait_list == NULL) {
2587                                         g_free(value);
2588                                         g_free(property);
2589                                         g_variant_unref(val);
2590                                         g_variant_unref(child);
2591                                         g_free(address);
2592                                         return;
2593                                 }
2594
2595                                 if (((wait_list->type == BT_AUDIO_ALL) &&
2596                                         (wait_list->ag_flag == TRUE)) ||
2597                                         (wait_list->type == BT_AUDIO_A2DP) ||
2598                                         (wait_list->disconnection_type == BT_AUDIO_A2DP)) {
2599                                         bluetooth_device_address_t device_address;
2600                                         _bt_convert_addr_string_to_type(
2601                                                                 device_address.addr,
2602                                                                 wait_list->address);
2603
2604                                         _bt_audio_connect(wait_list->req_id,
2605                                                                 wait_list->type,
2606                                                                 &device_address,
2607                                                                 NULL);
2608                                 }
2609                                 g_free(address);
2610                         } else if (strcasecmp(value, "Connected") == 0) {
2611                                 char *address;
2612                                 char connected_address[BT_ADDRESS_STRING_SIZE + 1];
2613                                 bluetooth_device_address_t device_address;
2614                                 gboolean connected;
2615
2616                                 address = g_malloc0(BT_ADDRESS_STRING_SIZE);
2617
2618                                 _bt_convert_device_path_to_address(path, address);
2619
2620                                 __bt_set_device_values(TRUE,
2621                                                 VCONFKEY_BT_DEVICE_A2DP_HEADSET_CONNECTED);
2622                                 param = g_variant_new("(is)", result, address);
2623                                 _bt_send_event(BT_HEADSET_EVENT,
2624                                         BLUETOOTH_EVENT_AV_CONNECTED,
2625                                         param);
2626                                 /* Check for existing Media device to disconnect */
2627                                 connected = _bt_is_headset_type_connected(BT_AUDIO_A2DP,
2628                                                                         connected_address);
2629                                 if (connected) {
2630                                         /* Match connected device address */
2631                                         if (g_strcmp0(connected_address, address) != 0) {
2632                                                 /* Convert BD adress from string type */
2633                                                 _bt_convert_addr_string_to_type(
2634                                                                 device_address.addr,
2635                                                                 connected_address);
2636                                                 _bt_audio_disconnect(0, BT_AUDIO_A2DP,
2637                                                                 &device_address, NULL);
2638                                         }
2639                                 }
2640
2641                                 /* Add data to the connected list */
2642                                 _bt_add_headset_to_list(BT_AUDIO_A2DP,
2643                                                 BT_STATE_CONNECTED, address);
2644
2645                                 g_free(address);
2646                         }
2647                         g_free(value);
2648                 }
2649                 g_free(property);
2650                 g_variant_unref(val);
2651                 g_variant_unref(child);
2652         }
2653 }
2654
2655 void _bt_handle_agent_event(GVariant *msg, const char *member)
2656 {
2657         int result = BLUETOOTH_ERROR_NONE;
2658         char *address = NULL;
2659         char *name = NULL;
2660         char *uuid = NULL;
2661         GVariant *param = NULL;
2662         ret_if(member == NULL);
2663
2664         if (strcasecmp(member, "ObexAuthorize") == 0) {
2665                 __bt_get_agent_signal_info(msg, &address, &name, &uuid);
2666                 param = g_variant_new("(iss)", result, address, name);
2667                 _bt_send_event(BT_OPP_SERVER_EVENT,
2668                         BLUETOOTH_EVENT_OBEX_SERVER_CONNECTION_AUTHORIZE,
2669                         param);
2670                 /* TODO: MAP? see above */
2671                 g_free(address);
2672                 g_free(name);
2673         } else if (strcasecmp(member, "RfcommAuthorize") == 0) {
2674                 bt_rfcomm_server_info_t *server_info;
2675
2676                 __bt_get_agent_signal_info(msg, &address, &name, &uuid);
2677
2678                 server_info = _bt_rfcomm_get_server_info_using_uuid(uuid);
2679                 ret_if(server_info == NULL);
2680                 ret_if(server_info->server_type != BT_CUSTOM_SERVER);
2681                 param = g_variant_new("(isssn)", result, address, uuid, name,
2682                                         server_info->control_fd);
2683                 _bt_send_event(BT_RFCOMM_SERVER_EVENT,
2684                         BLUETOOTH_EVENT_RFCOMM_AUTHORIZE,
2685                         param);
2686                 g_free(address);
2687                 g_free(uuid);
2688                 g_free(name);
2689         }
2690 }
2691
2692 void _bt_handle_tds_provider_event(GVariant *msg, const char *member, const char *path)
2693 {
2694         BT_INFO("member: %s, path: %s", member, path);
2695
2696         ret_if(path == NULL);
2697
2698         if (strcasecmp(member, "TdsActivationRequested") == 0) {
2699                 GVariant *value = NULL;
2700                 int len = 0;
2701                 unsigned char *buffer = NULL;
2702                 unsigned char org_id;
2703
2704                 g_variant_get(msg, "(y@ay)", &org_id, &value);
2705                 BT_DBG("org_id: %.2x", org_id);
2706                 len = g_variant_get_size(value);
2707                 if (len > 0) {
2708                         int i;
2709                         buffer = (unsigned char *)g_variant_get_data(value);
2710                         for (i = 0; i < len; i++)
2711                                 BT_DBG("%.2x", buffer[i]);
2712                 }
2713
2714                 /* Send event only registered client */
2715                 _bt_tds_handle_activation_request(path, org_id, buffer, len);
2716                 g_variant_unref(value);
2717         }
2718 }
2719
2720 static int __bt_get_object_path(GVariant *msg, char **path)
2721 {
2722         g_variant_get(msg, "(o*)", path, NULL);
2723         if (*path == NULL)
2724                 return BLUETOOTH_ERROR_INTERNAL;
2725
2726         return BLUETOOTH_ERROR_NONE;
2727 }
2728
2729 static void __bt_devices_list_free(void)
2730 {
2731         bt_cache_info_t *cache_info;
2732         GList *node;
2733
2734         node = g_list_first(p_cache_list);
2735
2736         while (node != NULL) {
2737                 cache_info = (bt_cache_info_t *)node->data;
2738                 p_cache_list = g_list_remove(p_cache_list, cache_info);
2739                 __bt_free_cache_info(cache_info);
2740
2741                 node = g_list_next(node);
2742         }
2743 }
2744
2745 static int __bt_parse_event(GVariant *msg)
2746 {
2747         GVariantIter iter;
2748         GVariant *child;
2749         char *interface_name = NULL;
2750         GVariant *inner_iter = NULL;
2751
2752         g_variant_iter_init(&iter, msg);
2753
2754         while ((child = g_variant_iter_next_value(&iter))) {
2755                 g_variant_get(child, "{&s@a{sv}}", &interface_name, &inner_iter);
2756                 if (g_strcmp0(interface_name,
2757                                 BT_DEVICE_INTERFACE) == 0) {
2758                         g_variant_unref(inner_iter);
2759                         g_variant_unref(child);
2760                         return BT_DEVICE_EVENT;
2761                 } else if (g_strcmp0(interface_name,
2762                                 BT_MEDIATRANSPORT_INTERFACE) == 0) {
2763                         g_variant_unref(inner_iter);
2764                         g_variant_unref(child);
2765                         return BT_MEDIA_TRANSFER_EVENT;
2766                 } else if (g_strcmp0(interface_name,
2767                                 BT_PLAYER_CONTROL_INTERFACE) == 0) {
2768                         g_variant_unref(inner_iter);
2769                         g_variant_unref(child);
2770                         return BT_AVRCP_CONTROL_EVENT;
2771                 }
2772                 g_variant_unref(inner_iter);
2773                 g_variant_unref(child);
2774         }
2775
2776         return 0;
2777 }
2778
2779 static  void __bt_manager_event_filter(GDBusConnection *connection,
2780                                         const gchar *sender_name,
2781                                         const gchar *object_path,
2782                                         const gchar *interface_name,
2783                                         const gchar *signal_name,
2784                                         GVariant *parameters,
2785                                         gpointer user_data)
2786 {
2787         bt_event_type_t bt_event = 0x00;
2788         int result = BLUETOOTH_ERROR_NONE;
2789         GVariant *value;
2790         char *obj_path = NULL;
2791         GVariant *param = NULL;
2792         if (signal_name == NULL)
2793                 return;
2794         if (strcasecmp(signal_name, "InterfacesAdded") == 0) {
2795                 g_variant_get(parameters, "(&o@a{sa{sv}})", &obj_path, &value);
2796
2797                 if (strcasecmp(obj_path, BT_BLUEZ_HCI_PATH) == 0) {
2798 #ifdef TIZEN_FEATURE_BT_USB_DONGLE
2799                         BT_DBG("Enable Adapter");
2800                         _bt_enable_adapter();
2801 #else
2802                         _bt_handle_adapter_added();
2803 #endif
2804                 } else {
2805                         bt_event = __bt_parse_event(value);
2806                         if (bt_event == BT_DEVICE_EVENT) {
2807                                 bt_cache_info_t *cache_info;
2808                                 bt_remote_dev_info_t *dev_info;
2809 #ifdef TIZEN_FEATURE_BT_DPM
2810                                 int desktop_state = DPM_BT_ERROR;
2811 #endif
2812                                 ret_if(_bt_is_discovering() == FALSE &&
2813                                                 _bt_is_le_scanning() == FALSE);
2814
2815                                 cache_info = g_malloc0(sizeof(bt_cache_info_t));
2816
2817                                 dev_info = g_malloc0(sizeof(bt_remote_dev_info_t));
2818
2819                                 cache_info->dev_info = dev_info;
2820
2821                                 if (__bt_parse_interface(parameters, dev_info) == FALSE) {
2822                                         BT_ERR("Fail to parse the properies");
2823                                         __bt_free_cache_info(cache_info);
2824                                         g_variant_unref(value);
2825                                         return;
2826                                 }
2827
2828                                 if (dev_info->addr_type != BDADDR_BREDR) {
2829                                         /* Whenever emit the property changed from bluez,
2830                                                 some property doesn't reach to bt-service.
2831                                                 So LE device is handled as AdvReport signal */
2832                                         __bt_free_cache_info(cache_info);
2833                                         g_variant_unref(value);
2834                                         return;
2835                                 }
2836
2837                                 if (dev_info->name == NULL)
2838                                         /* If Remote device name is NULL or still RNR is not done
2839                                          * then display address as name.
2840                                          */
2841                                         dev_info->name = g_strdup(dev_info->address);
2842
2843 #ifdef TIZEN_FEATURE_BT_DPM
2844                                 _bt_dpm_get_bluetooth_desktop_connectivity_state(&desktop_state);
2845                                 if (desktop_state == DPM_RESTRICTED) {
2846                                         bluetooth_device_class_t device_class;
2847                                         _bt_divide_device_class(&device_class, dev_info->class);
2848                                         BT_DBG("[%s]device_class.major_class : %d", dev_info->name, device_class.major_class);
2849
2850                                         if (device_class.major_class ==
2851                                                 BLUETOOTH_DEVICE_MAJOR_CLASS_COMPUTER) {
2852                                                 __bt_free_cache_info(cache_info);
2853                                                 g_variant_unref(value);
2854                                                 return;
2855                                         }
2856                                 }
2857 #endif
2858
2859                                 GVariant *uuids = NULL;
2860                                 GVariantBuilder *builder = NULL;
2861                                 int i = 0;
2862                                 builder = g_variant_builder_new(G_VARIANT_TYPE("as"));
2863                                 for (i = 0; i < dev_info->uuid_count; i++) {
2864                                         g_variant_builder_add(builder, "s",
2865                                                 dev_info->uuids[i]);
2866                                 }
2867                                 uuids = g_variant_new("as", builder);
2868                                 g_variant_builder_unref(builder);
2869                                 GVariant *manufacturer_data = NULL;
2870                                 manufacturer_data = g_variant_new_from_data(
2871                                                         G_VARIANT_TYPE_BYTESTRING,
2872                                                         dev_info->manufacturer_data,
2873                                                         dev_info->manufacturer_data_len,
2874                                                         TRUE, NULL, NULL);
2875                                 param = g_variant_new("(isunsbub@asn@ay)", result,
2876                                                         dev_info->address,
2877                                                         dev_info->class,
2878                                                         dev_info->rssi,
2879                                                         dev_info->name,
2880                                                         dev_info->paired,
2881                                                         dev_info->connected,
2882                                                         dev_info->trust,
2883                                                         uuids,
2884                                                         dev_info->manufacturer_data_len,
2885                                                         manufacturer_data);
2886                                 _bt_send_event(BT_ADAPTER_EVENT,
2887                                         BLUETOOTH_EVENT_REMOTE_DEVICE_FOUND,
2888                                          param);
2889                                 p_cache_list = g_list_append(p_cache_list, cache_info);
2890                         } else if (bt_event == BT_AVRCP_CONTROL_EVENT) {
2891                                 BT_DBG("Device path : %s ", obj_path);
2892                                 _bt_set_control_device_path(obj_path);
2893                         }
2894                 }
2895                 g_variant_unref(value);
2896         } else if (strcasecmp(signal_name, "InterfacesRemoved") == 0) {
2897 #ifdef TIZEN_FEATURE_BT_USB_DONGLE
2898                 BT_DBG("InterfacesRemoved");
2899                 _bt_handle_adapter_removed();
2900 #endif
2901                 if (g_strcmp0(interface_name, BT_MEDIATRANSPORT_INTERFACE) == 0)
2902                         bt_event = BT_MEDIA_TRANSFER_EVENT;
2903                 else if (g_strcmp0(interface_name, BT_DEVICE_INTERFACE) == 0)
2904                         bt_event = BT_DEVICE_EVENT;
2905                 else if (g_strcmp0(interface_name, BT_PLAYER_CONTROL_INTERFACE) == 0)
2906                         bt_event = BT_AVRCP_CONTROL_EVENT;
2907
2908                 if ((bt_event != 0) && (bt_event != BT_MEDIA_TRANSFER_EVENT)) {
2909                         _bt_handle_adapter_event(parameters, signal_name);
2910                         if (bt_event == BT_AVRCP_CONTROL_EVENT) {
2911                                 BT_INFO("Object Path %s", obj_path);
2912                                 _bt_remove_control_device_path(obj_path);
2913                         }
2914                 }
2915         } else if (strcasecmp(signal_name, "NameOwnerChanged") == 0) {
2916                 gboolean value;
2917                 char *name = NULL;
2918                 char *previous = NULL;
2919                 char *current = NULL;
2920
2921                 if (__bt_get_owner_info(parameters, &name, &previous, &current)) {
2922                         BT_ERR("Fail to get the owner info");
2923                         return;
2924                 }
2925
2926                 if (*current != '\0') {
2927                         g_free(current);
2928                         if (name)
2929                                 g_free(name);
2930                         if (previous)
2931                                 g_free(previous);
2932                         return;
2933                 }
2934
2935                 if (strcasecmp(name, BT_BLUEZ_NAME) == 0) {
2936                         BT_INFO_C("### Bluetoothd is terminated");
2937                         if (_bt_adapter_get_status() != BT_DEACTIVATING &&
2938                                 _bt_adapter_get_status() != BT_DEACTIVATED) {
2939                                 BT_INFO_C("Turn Off Bluetooth");
2940                                 _bt_set_le_disabled(BLUETOOTH_ERROR_NONE);
2941                                 _bt_disable_cb();
2942                         }
2943                         _bt_handle_adapter_removed();
2944                         __bt_devices_list_free();
2945                         _bt_service_adapter_le_deinit();
2946                 }
2947
2948                 _bt_obex_server_check_allocation(&value);
2949
2950                 if (value == TRUE) {
2951                         /* Check if the obex server was terminated abnormally */
2952                         _bt_obex_server_check_termination(name);
2953                 }
2954
2955                 _bt_rfcomm_server_check_existence(&value);
2956
2957                 if (value == TRUE) {
2958                         /* The obex server was terminated abnormally */
2959                         _bt_rfcomm_server_check_termination(name);
2960                 }
2961
2962                 /* Reset connection interval */
2963                 _bt_remove_all_le_conn_param_info(name);
2964
2965                 /* Stop advertising started by terminated process */
2966                 _bt_stop_advertising_by_terminated_process(name);
2967                 /* Stop LE Scan */
2968                 _bt_stop_le_scan(name);
2969
2970                 /* Stop the Proximity reporter service */
2971                 _bt_proximity_reporter_stop_by_terminated_process(name);
2972
2973                 /* Stop the Transport Discovery service */
2974                 _bt_tds_stop_by_terminated_process(name);
2975
2976                 g_free(name);
2977                 g_free(previous);
2978                 g_free(current);
2979         } else if (g_strcmp0(interface_name, BT_PROPERTIES_INTERFACE) == 0) {
2980                 const char *path = object_path;
2981
2982                 if (strncmp(path, BT_MEDIA_OBJECT_PATH,
2983                                 strlen(BT_MEDIA_OBJECT_PATH)) == 0)
2984                         return;
2985
2986                 _bt_handle_property_changed_event(parameters, object_path);
2987         } else if (g_strcmp0(interface_name, BT_ADAPTER_INTERFACE) == 0) {
2988                 _bt_handle_adapter_event(parameters, signal_name);
2989         } else if (g_strcmp0(interface_name, BT_INPUT_INTERFACE) == 0) {
2990                 _bt_handle_input_event(parameters, object_path);
2991         } else if (g_strcmp0(interface_name, BT_NETWORK_SERVER_INTERFACE) == 0) {
2992                 _bt_handle_network_server_event(parameters, signal_name);
2993         } else if (g_strcmp0(interface_name, BT_HEADSET_INTERFACE) == 0) {
2994                 _bt_handle_headset_event(parameters, object_path);
2995         } else if (g_strcmp0(interface_name, BT_SINK_INTERFACE) == 0) {
2996                 _bt_handle_sink_event(parameters, object_path);
2997         } else if (g_strcmp0(interface_name, BT_AGENT_INTERFACE) == 0) {
2998                 _bt_handle_agent_event(parameters, signal_name);
2999         } else if (g_strcmp0(interface_name, BT_DEVICE_INTERFACE) == 0) {
3000                 _bt_handle_device_event(parameters, signal_name, object_path);
3001         } else if (g_strcmp0(interface_name, BT_TDS_PROVIDER_INTERFACE) == 0) {
3002                 _bt_handle_tds_provider_event(parameters, signal_name, object_path);
3003         } else if (g_strcmp0(interface_name, BT_GATT_CHAR_INTERFACE) == 0) {
3004                 _bt_handle_gatt_event(parameters, signal_name, object_path);
3005         }
3006
3007         return;
3008 }
3009
3010 static gboolean __bt_is_obexd_event(GVariant *msg, const char *interface)
3011 {
3012
3013         if (g_strcmp0(interface, BT_PROPERTIES_INTERFACE) == 0) {
3014                 char *interface_name = NULL;
3015
3016                 g_variant_get(msg, "(&s@a{sv}@as)", &interface_name, NULL, NULL);
3017                 retv_if(interface_name == NULL, FALSE);
3018
3019                 if (strcasecmp(interface_name, BT_OBEX_TRANSFER_INTERFACE) == 0) {
3020                         BT_DBG("BT_OBEX_TRANSFER_INTERFACE");
3021                         return TRUE;
3022                 }
3023         }
3024
3025         return FALSE;
3026 }
3027
3028 static  void __bt_obexd_event_filter(GDBusConnection *connection,
3029                                         const gchar *sender_name,
3030                                         const gchar *object_path,
3031                                         const gchar *interface_name,
3032                                         const gchar *signal_name,
3033                                         GVariant *parameters,
3034                                         gpointer user_data)
3035 {
3036         const char *member = signal_name;
3037         char *obj_path = NULL;
3038         ret_if(member == NULL);
3039
3040         if (strcasecmp(member, "InterfacesAdded") == 0) {
3041                 if (__bt_get_object_path(parameters, &obj_path)) {
3042                         BT_ERR("Fail to get the path");
3043                         return;
3044                 }
3045                 BT_INFO("object_path = [%s]", obj_path);
3046
3047                 /*Handle OPP_SERVER_CONNECTED_EVENT here */
3048                 /* TODO: MAP? see above */
3049                 if (strncmp(obj_path, BT_SESSION_BASEPATH_SERVER,
3050                                 strlen(BT_SESSION_BASEPATH_SERVER)) != 0) {
3051                         g_free(obj_path);
3052                         return;
3053                 }
3054
3055                 if (g_strrstr(obj_path, "session") && g_strrstr(obj_path, "transfer")) {
3056                         BT_DBG("Obex_Server_Session_Transfer connected");
3057                         _bt_obex_transfer_connected(obj_path);
3058                 }
3059                 g_free(obj_path);
3060         } else if (strcasecmp(member, "InterfacesRemoved") == 0) {
3061                 /*Handle OPP_SERVER_DISCONNECTED_EVENT here */
3062                 /* TODO: MAP? see above */
3063                 if (__bt_get_object_path(parameters, &obj_path)) {
3064                         BT_ERR("Fail to get the path");
3065                         return;
3066                 }
3067                 BT_INFO("object_path = [%s]", obj_path);
3068
3069                 if (strncmp(obj_path, BT_SESSION_BASEPATH_CLIENT,
3070                                 strlen(BT_SESSION_BASEPATH_CLIENT)) == 0) {
3071                         BT_DBG("Call PBAP Disconnected");
3072                         _bt_obex_pbap_client_disconnect(obj_path);
3073                 }
3074
3075                 if (strncmp(obj_path, BT_SESSION_BASEPATH_SERVER,
3076                                 strlen(BT_SESSION_BASEPATH_SERVER)) != 0) {
3077                         g_free(obj_path);
3078                         return;
3079                 }
3080
3081                 if (g_strrstr(obj_path, "session") && g_strrstr(obj_path, "transfer")) {
3082                         BT_DBG("Obex_Server_Session_Transfer disconnected %s",
3083                                                                 obj_path);
3084
3085                         _bt_obex_transfer_disconnected(obj_path);
3086                 }
3087                 g_free(obj_path);
3088         } else if (__bt_is_obexd_event(parameters, interface_name) == TRUE) {
3089                 const char *path = object_path;
3090
3091                 if (strncmp(path, BT_SESSION_BASEPATH_SERVER,
3092                                 strlen(BT_SESSION_BASEPATH_SERVER)) != 0 &&
3093                         strncmp(path, BT_SESSION_BASEPATH_CLIENT,
3094                                 strlen(BT_SESSION_BASEPATH_CLIENT)) != 0) {
3095                         BT_DBG("DBUS_HANDLER_RESULT_NOT_YET_HANDLED");
3096                         return;
3097                 }
3098
3099                 _bt_handle_property_changed_event(parameters, path);
3100         }
3101         BT_DBG("-");
3102         return;
3103 }
3104
3105 static gboolean __bt_is_obexd_client_event(GVariant *msg, const char *interface)
3106 {
3107         BT_DBG("+");
3108
3109         if (g_strcmp0(interface, BT_PROPERTIES_INTERFACE) == 0) {
3110                 char *interface_name = NULL;
3111
3112                 g_variant_get(msg, "(&s@a{sv}@as)", &interface_name, NULL, NULL);
3113
3114                 retv_if(interface_name == NULL, FALSE);
3115
3116                 if (strcasecmp(interface_name,
3117                                         BT_OBEX_TRANSFER_INTERFACE) == 0) {
3118                         BT_DBG("-");
3119                         return TRUE;
3120                 }
3121         }
3122
3123         BT_DBG("-");
3124
3125         return FALSE;
3126 }
3127
3128 static  void __bt_opc_event_filter(GDBusConnection *connection,
3129                                         const gchar *sender_name,
3130                                         const gchar *object_path,
3131                                         const gchar *interface_name,
3132                                         const gchar *signal_name,
3133                                         GVariant *parameters,
3134                                         gpointer user_data)
3135 {
3136         const char *member = signal_name;
3137         char *obj_path = NULL;
3138         if (strcasecmp(member, "InterfacesAdded") == 0) {
3139                 BT_DBG("InterfacesAdded");
3140         } else if (strcasecmp(member, "InterfacesRemoved") == 0) {
3141
3142                 if (__bt_get_object_path(parameters, &obj_path)) {
3143                         BT_ERR("Fail to get the path");
3144                         return;
3145                 }
3146
3147                 BT_DBG("object_path = %s", obj_path);
3148
3149                 if (strncmp(obj_path, BT_SESSION_BASEPATH_CLIENT,
3150                                 strlen(BT_SESSION_BASEPATH_CLIENT)) != 0
3151                                 || strstr(obj_path, "transfer") == NULL) {
3152                         g_free(obj_path);
3153                         return;
3154                 } else if (strncmp(obj_path, BT_SESSION_BASEPATH_CLIENT,
3155                                 strlen(BT_SESSION_BASEPATH_CLIENT)) == 0) {
3156                         BT_DBG("Going to call opc disconnected");
3157                         _bt_opc_disconnected(obj_path);
3158                 }
3159
3160                 _bt_sending_files();
3161                 g_free(obj_path);
3162         } else if (__bt_is_obexd_client_event(parameters, interface_name) == TRUE) {
3163                 char *path = (char *)object_path;
3164                 BT_INFO("object_path %s", path);
3165                 if (strncmp(path, BT_SESSION_BASEPATH_CLIENT,
3166                         strlen(BT_SESSION_BASEPATH_CLIENT)) != 0) {
3167                         BT_DBG("NOT BT_SESSION_BASEPATH_CLIENT");
3168                         return;
3169                 }
3170
3171                 _bt_opc_property_changed_event(parameters, path);
3172         }
3173
3174         return;
3175 }
3176
3177 int _bt_opp_client_event_init(void)
3178 {
3179         GError *error = NULL;
3180
3181         if (opc_obexd_conn == NULL) {
3182                 opc_obexd_conn = g_bus_get_sync(G_BUS_TYPE_SESSION, NULL, &error);
3183
3184                 if (!opc_obexd_conn) {
3185                         if (error) {
3186                                 BT_ERR("Unable to connect to dbus: %s", error->message);
3187                                 g_clear_error(&error);
3188                         }
3189                 return BLUETOOTH_ERROR_INTERNAL;
3190                 }
3191         }
3192
3193         if (_bt_register_service_event(opc_obexd_conn,
3194                         BT_OPP_CLIENT_EVENT) != BLUETOOTH_ERROR_NONE) {
3195                         g_object_unref(opc_obexd_conn);
3196                         opc_obexd_conn = NULL;
3197                         return BLUETOOTH_ERROR_INTERNAL;
3198         }
3199
3200         return BLUETOOTH_ERROR_NONE;
3201 }
3202
3203 void _bt_opp_client_event_deinit(void)
3204 {
3205         if (opc_obexd_conn) {
3206                 _bt_unregister_service_event(opc_obexd_conn,
3207                                                 BT_OPP_CLIENT_EVENT);
3208                  g_object_unref(opc_obexd_conn);
3209                  opc_obexd_conn = NULL;
3210         }
3211 }
3212
3213 static  void __bt_map_event_filter(GDBusConnection *connection,
3214                                         const gchar *sender_name,
3215                                         const gchar *object_path,
3216                                         const gchar *interface_name,
3217                                         const gchar *signal_name,
3218                                         GVariant *parameters,
3219                                         gpointer user_data)
3220 {
3221         BT_DBG("Entered __bt_map_event_filter");
3222         const char *member = signal_name;
3223
3224         if (strcasecmp(member, "InterfacesAdded") == 0) {
3225                 BT_DBG("------------------------------------ADDED------------------------------------");
3226                 // currently doing nothing
3227         } else if (strcasecmp(member, "InterfacesRemoved") == 0) {
3228                 BT_DBG("------------------------------------REMOVED------------------------------------");
3229                 // TODO check if something should be called here?
3230                 //_bt_map_on_transfer_finished(object_path, error);
3231         } else if (__bt_is_obexd_client_event(parameters, interface_name) == TRUE) {
3232                 BT_DBG("------------------------------------CLIENT EVENT------------------------------------");
3233                 _bt_map_property_changed_event(parameters, object_path);
3234         }
3235
3236         return;
3237 }
3238
3239 int _bt_map_client_event_init(void)
3240 {
3241         GError *error = NULL;
3242
3243         if (map_obexd_conn == NULL) {
3244                 map_obexd_conn = g_bus_get_sync(G_BUS_TYPE_SESSION, NULL, &error);
3245
3246                 if (!map_obexd_conn) {
3247                         if (error) {
3248                                 BT_ERR("Unable to connect to dbus: %s", error->message);
3249                                 g_clear_error(&error);
3250                         }
3251                 return BLUETOOTH_ERROR_INTERNAL;
3252                 }
3253         }
3254
3255         if (_bt_register_service_event(map_obexd_conn,
3256                         BT_MAP_CLIENT_EVENT) != BLUETOOTH_ERROR_NONE) {
3257                         g_object_unref(map_obexd_conn);
3258                         map_obexd_conn = NULL;
3259                         return BLUETOOTH_ERROR_INTERNAL;
3260         }
3261
3262         return BLUETOOTH_ERROR_NONE;
3263 }
3264
3265 void _bt_map_client_event_deinit(void)
3266 {
3267         if (map_obexd_conn) {
3268                 _bt_unregister_service_event(map_obexd_conn,
3269                                                 BT_MAP_CLIENT_EVENT);
3270                  g_object_unref(map_obexd_conn);
3271                  map_obexd_conn = NULL;
3272         }
3273 }
3274
3275 int _bt_register_manager_subscribe_signal(GDBusConnection *conn,
3276                 int subscribe)
3277 {
3278         if (conn == NULL)
3279                 return -1;
3280
3281         static guint subs_interface_added_id;
3282         static guint subs_interface_removed_id;
3283         static guint subs_name_owner_id;
3284         static guint subs_property_id;
3285         static guint subs_adapter_id;
3286         static guint subs_gatt_id;
3287
3288         if (subscribe) {
3289                 if (subs_interface_added_id == 0) {
3290                         subs_interface_added_id = g_dbus_connection_signal_subscribe(conn,
3291                                 NULL, BT_MANAGER_INTERFACE,
3292                                 BT_INTERFACES_ADDED, NULL, NULL, 0,
3293                                 __bt_manager_event_filter,
3294                                 NULL, NULL);
3295                 }
3296                 if (subs_interface_removed_id == 0) {
3297                         subs_interface_removed_id = g_dbus_connection_signal_subscribe(conn,
3298                                 NULL, BT_MANAGER_INTERFACE,
3299                                 BT_INTERFACES_REMOVED, NULL, NULL, 0,
3300                                 __bt_manager_event_filter,
3301                                 NULL, NULL);
3302                 }
3303                 if (subs_name_owner_id == 0) {
3304                         subs_name_owner_id = g_dbus_connection_signal_subscribe(conn,
3305                                 NULL, BT_FREEDESKTOP_INTERFACE,
3306                                 BT_NAME_OWNER_CHANGED, NULL, NULL, 0,
3307                                 __bt_manager_event_filter,
3308                                 NULL, NULL);
3309                 }
3310                 if (subs_property_id == 0) {
3311                         subs_property_id = g_dbus_connection_signal_subscribe(conn,
3312                                 NULL, BT_PROPERTIES_INTERFACE,
3313                                 BT_PROPERTIES_CHANGED, NULL, NULL, 0,
3314                                 __bt_manager_event_filter,
3315                                 NULL, NULL);
3316                 }
3317                 if (subs_adapter_id == 0) {
3318                         subs_adapter_id = g_dbus_connection_signal_subscribe(conn,
3319                                 NULL, BT_ADAPTER_INTERFACE,
3320                                 NULL, NULL, NULL, 0,
3321                                 __bt_manager_event_filter,
3322                                 NULL, NULL);
3323                 }
3324                 if (subs_gatt_id == 0) {
3325                         subs_gatt_id = g_dbus_connection_signal_subscribe(conn,
3326                                 NULL, BT_GATT_CHAR_INTERFACE,
3327                                 NULL, NULL, NULL, 0,
3328                                 __bt_manager_event_filter,
3329                                 NULL, NULL);
3330                 }
3331         } else {
3332                 if (subs_interface_added_id > 0) {
3333                         g_dbus_connection_signal_unsubscribe(conn,
3334                                         subs_interface_added_id);
3335                         subs_interface_added_id = 0;
3336                 }
3337                 if (subs_interface_removed_id > 0) {
3338                         g_dbus_connection_signal_unsubscribe(conn,
3339                                         subs_interface_removed_id);
3340                         subs_interface_removed_id = 0;
3341                 }
3342                 if (subs_name_owner_id > 0) {
3343                         g_dbus_connection_signal_unsubscribe(conn,
3344                                         subs_name_owner_id);
3345                         subs_name_owner_id = 0;
3346                 }
3347                 if (subs_property_id > 0) {
3348                         g_dbus_connection_signal_unsubscribe(conn,
3349                                         subs_property_id);
3350                         subs_property_id = 0;
3351                 }
3352                 if (subs_adapter_id > 0) {
3353                         g_dbus_connection_signal_unsubscribe(conn, subs_adapter_id);
3354                         subs_adapter_id = 0;
3355                 }
3356                 if (subs_gatt_id > 0) {
3357                         g_dbus_connection_signal_unsubscribe(conn, subs_gatt_id);
3358                         subs_gatt_id = 0;
3359                 }
3360         }
3361         return 0;
3362 }
3363
3364 int _bt_register_device_subscribe_signal(GDBusConnection *conn,
3365                 int subscribe)
3366 {
3367         if (conn == NULL)
3368                 return -1;
3369
3370         static guint subs_device_id;
3371
3372         if (subscribe) {
3373                 if (subs_device_id == 0) {
3374                         subs_device_id = g_dbus_connection_signal_subscribe(conn,
3375                                 NULL, BT_DEVICE_INTERFACE,
3376                                 NULL, NULL, NULL, 0,
3377                                 __bt_manager_event_filter,
3378                                 NULL, NULL);
3379                 }
3380         } else {
3381                 if (subs_device_id > 0) {
3382                         g_dbus_connection_signal_unsubscribe(conn,
3383                                         subs_device_id);
3384                         subs_device_id = 0;
3385                 }
3386         }
3387         return 0;
3388 }
3389
3390 int _bt_register_input_subscribe_signal(GDBusConnection *conn,
3391                 int subscribe)
3392 {
3393         if (conn == NULL)
3394                 return -1;
3395
3396         static int subs_input_id;
3397
3398         if (subscribe) {
3399                 if (subs_input_id == 0) {
3400                         subs_input_id = g_dbus_connection_signal_subscribe(conn,
3401                                 NULL, BT_INPUT_INTERFACE,
3402                                 NULL, NULL, NULL, 0,
3403                                 __bt_manager_event_filter,
3404                                 NULL, NULL);
3405                 }
3406         } else {
3407                 if (subs_input_id > 0) {
3408                         g_dbus_connection_signal_unsubscribe(conn,
3409                                         subs_input_id);
3410                         subs_input_id = 0;
3411                 }
3412         }
3413         return 0;
3414 }
3415
3416 int _bt_register_network_subscribe_signal(GDBusConnection *conn,
3417                 int subscribe)
3418 {
3419         if (conn == NULL)
3420                 return -1;
3421
3422         static guint subs_serv_id;
3423         static guint subs_client_id;
3424
3425         if (subscribe) {
3426                 if (subs_serv_id == 0) {
3427                         subs_serv_id = g_dbus_connection_signal_subscribe(conn,
3428                                 NULL, BT_NETWORK_SERVER_INTERFACE,
3429                                 NULL, NULL, NULL, 0,
3430                                 __bt_manager_event_filter,
3431                                 NULL, NULL);
3432                 }
3433                 if (subs_client_id == 0) {
3434                         subs_client_id = g_dbus_connection_signal_subscribe(conn,
3435                                 NULL, BT_NETWORK_CLIENT_INTERFACE,
3436                                 NULL, NULL, NULL, 0,
3437                                 __bt_manager_event_filter,
3438                                 NULL, NULL);
3439                 }
3440         } else {
3441                 if (subs_serv_id > 0) {
3442                         g_dbus_connection_signal_unsubscribe(conn,
3443                                         subs_serv_id);
3444                         subs_serv_id = 0;
3445                 }
3446                 if (subs_client_id > 0) {
3447                         g_dbus_connection_signal_unsubscribe(conn,
3448                                         subs_client_id);
3449                         subs_client_id = 0;
3450                 }
3451         }
3452         return 0;
3453 }
3454
3455 int _bt_register_audio_subscribe_signal(GDBusConnection *conn,
3456                 int subscribe)
3457 {
3458         if (conn == NULL)
3459                 return -1;
3460
3461         static guint subs_headset_id;
3462         static guint subs_sink_id;
3463
3464         if (subscribe) {
3465                 if (subs_headset_id == 0) {
3466                         subs_headset_id = g_dbus_connection_signal_subscribe(conn,
3467                                 NULL, BT_HEADSET_INTERFACE,
3468                                 NULL, NULL, NULL, 0,
3469                                 __bt_manager_event_filter,
3470                                 NULL, NULL);
3471                 }
3472                 if (subs_sink_id == 0) {
3473                         subs_sink_id = g_dbus_connection_signal_subscribe(conn,
3474                                 NULL, BT_SINK_INTERFACE,
3475                                 NULL, NULL, NULL, 0,
3476                                 __bt_manager_event_filter,
3477                                 NULL, NULL);
3478                 }
3479         } else {
3480                 if (subs_headset_id > 0) {
3481                         g_dbus_connection_signal_unsubscribe(conn,
3482                                         subs_headset_id);
3483                         subs_headset_id = 0;
3484                 }
3485                 if (subs_sink_id > 0) {
3486                         g_dbus_connection_signal_unsubscribe(conn,
3487                                         subs_sink_id);
3488                         subs_sink_id = 0;
3489                 }
3490         }
3491         return 0;
3492 }
3493
3494 int _bt_register_opp_server_subscribe_signal(GDBusConnection *conn,
3495                 int subscribe)
3496 {
3497         if (conn == NULL)
3498                 return -1;
3499
3500         static guint subs_opp_server_interface_added_id;
3501         static guint subs_opp_server_interface_removed_id;
3502         static guint subs_opp_server_property_id;
3503
3504
3505         if (subscribe) {
3506                 if (subs_opp_server_interface_added_id == 0) {
3507                         subs_opp_server_interface_added_id = g_dbus_connection_signal_subscribe(conn,
3508                                 NULL, BT_MANAGER_INTERFACE,
3509                                 BT_INTERFACES_ADDED, NULL, NULL, 0,
3510                                 __bt_obexd_event_filter,
3511                                 NULL, NULL);
3512                 }
3513                 if (subs_opp_server_interface_removed_id == 0) {
3514                         subs_opp_server_interface_removed_id = g_dbus_connection_signal_subscribe(conn,
3515                                 NULL, BT_MANAGER_INTERFACE,
3516                                 BT_INTERFACES_REMOVED, NULL, NULL, 0,
3517                                 __bt_obexd_event_filter,
3518                                 NULL, NULL);
3519                 }
3520                 if (subs_opp_server_property_id == 0) {
3521                         subs_opp_server_property_id = g_dbus_connection_signal_subscribe(conn,
3522                                 NULL, BT_PROPERTIES_INTERFACE,
3523                                 BT_PROPERTIES_CHANGED, NULL, NULL, 0,
3524                                 __bt_obexd_event_filter,
3525                                 NULL, NULL);
3526                 }
3527         } else {
3528                 if (subs_opp_server_interface_added_id > 0) {
3529                         g_dbus_connection_signal_unsubscribe(conn,
3530                                         subs_opp_server_interface_added_id);
3531                         subs_opp_server_interface_added_id = 0;
3532                 }
3533                 if (subs_opp_server_interface_removed_id > 0) {
3534                         g_dbus_connection_signal_unsubscribe(conn,
3535                                         subs_opp_server_interface_removed_id);
3536                         subs_opp_server_interface_removed_id = 0;
3537                 }
3538                 if (subs_opp_server_property_id > 0) {
3539                         g_dbus_connection_signal_unsubscribe(conn,
3540                                         subs_opp_server_property_id);
3541                         subs_opp_server_property_id = 0;
3542                 }
3543         }
3544         return 0;
3545 }
3546
3547 int _bt_register_opp_client_subscribe_signal(GDBusConnection *conn,
3548                 int subscribe)
3549 {
3550         if (conn == NULL)
3551                 return -1;
3552
3553         static guint subs_opp_client_interface_added_id;
3554         static guint subs_opp_client_interface_removed_id;
3555         static guint subs_opp_client_property_id;
3556
3557
3558         if (subscribe) {
3559                 if (subs_opp_client_interface_added_id == 0) {
3560                         subs_opp_client_interface_added_id = g_dbus_connection_signal_subscribe(conn,
3561                                 NULL, BT_MANAGER_INTERFACE,
3562                                 BT_INTERFACES_ADDED, NULL, NULL, 0,
3563                                 __bt_opc_event_filter,
3564                                 NULL, NULL);
3565                 }
3566                 if (subs_opp_client_interface_removed_id == 0) {
3567                         subs_opp_client_interface_removed_id = g_dbus_connection_signal_subscribe(conn,
3568                                 NULL, BT_MANAGER_INTERFACE,
3569                                 BT_INTERFACES_REMOVED, NULL, NULL, 0,
3570                                 __bt_opc_event_filter,
3571                                 NULL, NULL);
3572                 }
3573                 if (subs_opp_client_property_id == 0) {
3574                         subs_opp_client_property_id = g_dbus_connection_signal_subscribe(conn,
3575                                 NULL, BT_PROPERTIES_INTERFACE,
3576                                 BT_PROPERTIES_CHANGED, NULL, NULL, 0,
3577                                 __bt_opc_event_filter,
3578                                 NULL, NULL);
3579                 }
3580         } else {
3581                 if (subs_opp_client_interface_added_id > 0) {
3582                         g_dbus_connection_signal_unsubscribe(conn,
3583                                         subs_opp_client_interface_added_id);
3584                         subs_opp_client_interface_added_id = 0;
3585                 }
3586                 if (subs_opp_client_interface_removed_id > 0) {
3587                         g_dbus_connection_signal_unsubscribe(conn,
3588                                         subs_opp_client_interface_removed_id);
3589                         subs_opp_client_interface_removed_id = 0;
3590                 }
3591                 if (subs_opp_client_property_id > 0) {
3592                         g_dbus_connection_signal_unsubscribe(conn,
3593                                         subs_opp_client_property_id);
3594                         subs_opp_client_property_id = 0;
3595                 }
3596         }
3597         return 0;
3598 }
3599
3600 int _bt_register_map_client_subscribe_signal(GDBusConnection *conn,
3601                 int subscribe)
3602 {
3603         if (conn == NULL)
3604                 return -1;
3605
3606         static guint subs_map_client_interface_added_id;
3607         static guint subs_map_client_interface_removed_id;
3608         static guint subs_map_client_property_id;
3609
3610
3611         if (subscribe) {
3612                 if (subs_map_client_interface_added_id == 0) {
3613                         subs_map_client_interface_added_id = g_dbus_connection_signal_subscribe(conn,
3614                                 NULL, BT_MANAGER_INTERFACE,
3615                                 BT_INTERFACES_ADDED, NULL, NULL, 0,
3616                                 __bt_map_event_filter,
3617                                 NULL, NULL);
3618                 }
3619                 if (subs_map_client_interface_removed_id == 0) {
3620                         subs_map_client_interface_removed_id = g_dbus_connection_signal_subscribe(conn,
3621                                 NULL, BT_MANAGER_INTERFACE,
3622                                 BT_INTERFACES_REMOVED, NULL, NULL, 0,
3623                                 __bt_map_event_filter,
3624                                 NULL, NULL);
3625                 }
3626                 if (subs_map_client_property_id == 0) {
3627                         subs_map_client_property_id = g_dbus_connection_signal_subscribe(conn,
3628                                 NULL, BT_PROPERTIES_INTERFACE,
3629                                 BT_PROPERTIES_CHANGED, NULL, NULL, 0,
3630                                 __bt_map_event_filter,
3631                                 NULL, NULL);
3632                 }
3633         } else {
3634                 if (subs_map_client_interface_added_id > 0) {
3635                         g_dbus_connection_signal_unsubscribe(conn,
3636                                         subs_map_client_interface_added_id);
3637                         subs_map_client_interface_added_id = 0;
3638                 }
3639                 if (subs_map_client_interface_removed_id > 0) {
3640                         g_dbus_connection_signal_unsubscribe(conn,
3641                                         subs_map_client_interface_removed_id);
3642                         subs_map_client_interface_removed_id = 0;
3643                 }
3644                 if (subs_map_client_property_id > 0) {
3645                         g_dbus_connection_signal_unsubscribe(conn,
3646                                         subs_map_client_property_id);
3647                         subs_map_client_property_id = 0;
3648                 }
3649         }
3650         return 0;
3651 }
3652
3653 int _bt_register_a2dp_subscribe_signal(GDBusConnection *conn,
3654                 int subscribe)
3655 {
3656         if (conn == NULL)
3657                 return -1;
3658
3659         static guint subs_a2dp_source_id;
3660         static guint subs_a2dp_sink_id;
3661
3662         if (subscribe) {
3663                 if (subs_a2dp_source_id == 0) {
3664                         subs_a2dp_source_id = g_dbus_connection_signal_subscribe(conn,
3665                                 NULL, BT_A2DP_SOURCE_INTERFACE,
3666                                 NULL, NULL, NULL, 0,
3667                                 __bt_opc_event_filter,
3668                                 NULL, NULL);
3669                 }
3670                 if (subs_a2dp_sink_id == 0) {
3671                         subs_a2dp_sink_id = g_dbus_connection_signal_subscribe(conn,
3672                                 NULL, BT_SINK_INTERFACE,
3673                                 NULL, NULL, NULL, 0,
3674                                 __bt_opc_event_filter,
3675                                 NULL, NULL);
3676                 }
3677         } else {
3678                 if (subs_a2dp_source_id > 0) {
3679                         g_dbus_connection_signal_unsubscribe(conn,
3680                                         subs_a2dp_source_id);
3681                         subs_a2dp_source_id = 0;
3682                 }
3683                 if (subs_a2dp_sink_id > 0) {
3684                         g_dbus_connection_signal_unsubscribe(conn,
3685                                         subs_a2dp_sink_id);
3686                         subs_a2dp_sink_id = 0;
3687                 }
3688         }
3689         return 0;
3690 }
3691
3692 int _bt_register_tds_provider_subscribe_signal(GDBusConnection *conn, int subscribe)
3693 {
3694         if (conn == NULL)
3695                 return -1;
3696
3697         static guint subs_custom_id;
3698
3699         if (subscribe) {
3700                 if (subs_custom_id == 0) {
3701                         subs_custom_id = g_dbus_connection_signal_subscribe(conn,
3702                                 NULL, BT_TDS_PROVIDER_INTERFACE,
3703                                 NULL, NULL, NULL, 0,
3704                                 __bt_manager_event_filter,
3705                                 NULL, NULL);
3706                 }
3707         } else {
3708                 if (subs_custom_id > 0) {
3709                         g_dbus_connection_signal_unsubscribe(conn,
3710                                         subs_custom_id);
3711                         subs_custom_id = 0;
3712                 }
3713         }
3714
3715         return 0;
3716 }
3717
3718 static void __bt_dump_event_filter(GDBusConnection *connection,
3719                                         const gchar *sender_name,
3720                                         const gchar *object_path,
3721                                         const gchar *interface_name,
3722                                         const gchar *signal_name,
3723                                         GVariant *parameters,
3724                                         gpointer user_data)
3725 {
3726         return;
3727 }
3728
3729 int __bt_register_dump_subscribe_signal(GDBusConnection *conn,
3730                 gboolean subscribe)
3731 {
3732         if (conn == NULL)
3733                 return -1;
3734
3735         static guint subs_source_id;
3736
3737         if (subscribe) {
3738                 if (subs_source_id == 0) {
3739                         subs_source_id = g_dbus_connection_signal_subscribe(conn,
3740                                 NULL, BT_DUMP_SERVICE_INTERFACE,
3741                                 BT_DUMP_SERVICE_SIGNAL, BT_DUMP_SERVICE_PATH, NULL, 0,
3742                                 __bt_dump_event_filter,
3743                                 NULL, NULL);
3744                 }
3745         } else {
3746                 if (subs_source_id > 0) {
3747                         g_dbus_connection_signal_unsubscribe(conn,
3748                                         subs_source_id);
3749                         subs_source_id = 0;
3750                 }
3751         }
3752         return 0;
3753 }
3754
3755 int _bt_register_service_event(GDBusConnection *g_conn, int event_type)
3756 {
3757         BT_DBG("+");
3758
3759         retv_if(g_conn == NULL, BLUETOOTH_ERROR_INTERNAL);
3760
3761         switch (event_type) {
3762         case BT_MANAGER_EVENT:
3763                 _bt_register_manager_subscribe_signal(g_conn, TRUE);
3764                 break;
3765         case BT_DEVICE_EVENT:
3766                 _bt_register_device_subscribe_signal(g_conn, TRUE);
3767                 break;
3768         case BT_HID_EVENT:
3769                 _bt_register_input_subscribe_signal(g_conn, TRUE);
3770                 break;
3771         case BT_NETWORK_EVENT:
3772                 _bt_register_network_subscribe_signal(g_conn, TRUE);
3773                 break;
3774         case BT_HEADSET_EVENT:
3775                 _bt_register_audio_subscribe_signal(g_conn, TRUE);
3776                 break;
3777         case BT_OPP_SERVER_EVENT:
3778                 BT_ERR("BT_OPP_SERVER_EVENT: register service event");
3779                 _bt_register_opp_server_subscribe_signal(g_conn, TRUE);
3780                 break;
3781
3782         case BT_OPP_CLIENT_EVENT:
3783                 BT_ERR("BT_OPP_CLIENT_EVENT: register service event");
3784                 _bt_register_opp_client_subscribe_signal(g_conn, TRUE);
3785                 break;
3786         case BT_MAP_CLIENT_EVENT:
3787                 BT_ERR("BT_MAP_CLIENT_EVENT: register service event");
3788                 _bt_register_map_client_subscribe_signal(g_conn, TRUE);
3789                 break;
3790         case BT_A2DP_SOURCE_EVENT:
3791                 BT_INFO("A2dp Source event");
3792                 _bt_register_a2dp_subscribe_signal(g_conn, TRUE);
3793                 break;
3794         case BT_TDS_EVENT:
3795                 BT_INFO("TDS provider event");
3796                 _bt_register_tds_provider_subscribe_signal(g_conn, TRUE);
3797                 break;
3798         default:
3799                 BT_ERR("Unknown event");
3800                 return BLUETOOTH_ERROR_INTERNAL;
3801         }
3802
3803         return BLUETOOTH_ERROR_NONE;
3804 }
3805
3806 void _bt_unregister_service_event(GDBusConnection *g_conn, int event_type)
3807 {
3808         BT_DBG("+");
3809
3810         ret_if(g_conn == NULL);
3811
3812         switch (event_type) {
3813         case BT_MANAGER_EVENT:
3814                 _bt_register_manager_subscribe_signal(g_conn, FALSE);
3815                 _bt_register_device_subscribe_signal(g_conn, FALSE);
3816                 _bt_register_input_subscribe_signal(g_conn, FALSE);
3817                 _bt_register_network_subscribe_signal(g_conn, FALSE);
3818                 _bt_register_audio_subscribe_signal(g_conn, FALSE);
3819                 break;
3820         case BT_OPP_SERVER_EVENT:
3821                 _bt_register_opp_server_subscribe_signal(g_conn, FALSE);
3822                 break;
3823         case BT_OPP_CLIENT_EVENT:
3824                 _bt_register_opp_client_subscribe_signal(g_conn, FALSE);
3825                 break;
3826         case BT_MAP_CLIENT_EVENT:
3827                 _bt_register_map_client_subscribe_signal(g_conn, FALSE);
3828                 break;
3829         default:
3830                 BT_ERR("Unknown event");
3831                 return;
3832         }
3833
3834         BT_DBG("-");
3835 }
3836
3837 static int __bt_init_manager_receiver(void)
3838 {
3839         BT_DBG("+");
3840
3841         GError *error = NULL;
3842
3843         if (manager_conn == NULL) {
3844                 manager_conn =  g_bus_get_sync(G_BUS_TYPE_SYSTEM, NULL, &error);
3845                 if (error != NULL) {
3846                         BT_ERR("ERROR: Can't get on system bus [%s]", error->message);
3847                         g_clear_error(&error);
3848                 }
3849                 retv_if(manager_conn == NULL, BLUETOOTH_ERROR_INTERNAL);
3850         }
3851
3852         if (_bt_register_service_event(manager_conn,
3853                                 BT_MANAGER_EVENT) != BLUETOOTH_ERROR_NONE)
3854                 goto fail;
3855         if (_bt_register_service_event(manager_conn,
3856                                 BT_DEVICE_EVENT) != BLUETOOTH_ERROR_NONE)
3857                 goto fail;
3858
3859         if (_bt_register_service_event(manager_conn,
3860                                 BT_HID_EVENT) != BLUETOOTH_ERROR_NONE)
3861                 goto fail;
3862
3863         if (_bt_register_service_event(manager_conn,
3864                                 BT_HEADSET_EVENT) != BLUETOOTH_ERROR_NONE)
3865                 goto fail;
3866
3867         if (_bt_register_service_event(manager_conn,
3868                                 BT_NETWORK_EVENT) != BLUETOOTH_ERROR_NONE)
3869                 goto fail;
3870
3871         if (_bt_register_service_event(manager_conn,
3872                                 BT_TDS_EVENT) != BLUETOOTH_ERROR_NONE)
3873                 goto fail;
3874
3875         __bt_register_dump_subscribe_signal(manager_conn, TRUE);
3876         return BLUETOOTH_ERROR_NONE;
3877 fail:
3878         if (manager_conn) {
3879                 g_object_unref(manager_conn);
3880                 manager_conn = NULL;
3881         }
3882
3883         BT_DBG("-");
3884
3885         return BLUETOOTH_ERROR_INTERNAL;
3886 }
3887
3888 static int __bt_init_obexd_receiver(void)
3889 {
3890         BT_DBG("+");
3891 #ifndef TIZEN_PROFILE_TV /* TODO: obexd doesn't work in TV profile. It should be resolved later. */
3892         GError *error = NULL;
3893
3894         if (obexd_conn == NULL) {
3895                 obexd_conn = g_bus_get_sync(G_BUS_TYPE_SESSION, NULL, &error);
3896                 if (error != NULL) {
3897                         BT_ERR("ERROR: Can't get on session bus [%s]", error->message);
3898                         g_clear_error(&error);
3899                 }
3900                 retv_if(obexd_conn == NULL, BLUETOOTH_ERROR_INTERNAL);
3901         }
3902
3903         if (_bt_register_service_event(obexd_conn,
3904                                 BT_OPP_SERVER_EVENT) != BLUETOOTH_ERROR_NONE) {
3905                 BT_ERR("Error while registering service event");
3906                 g_object_unref(obexd_conn);
3907                 obexd_conn = NULL;
3908                 return BLUETOOTH_ERROR_INTERNAL;
3909         }
3910 #endif
3911         BT_DBG("-");
3912
3913         return BLUETOOTH_ERROR_NONE;
3914 }
3915
3916 gboolean __bt_reinit_obexd_receiver(gpointer user_data)
3917 {
3918         static int retry_cnt = 0;
3919         int result = BLUETOOTH_ERROR_NONE;
3920
3921         BT_DBG("+");
3922
3923         result = __bt_init_obexd_receiver();
3924         if (result != BLUETOOTH_ERROR_NONE) {
3925                 /* 20 ms * 50 = 10 seconds. During 10 seconds fail to initialize,
3926                    then it is not the timing issue. Just can't use the session bus connection */
3927                 if (retry_cnt > 100) {
3928                         BT_ERR("Fail to init obexd receiver by 50 times.");
3929                         retry_cnt = 0;
3930                         session_reinit_timer = 0;
3931                         return FALSE;
3932                 }
3933                 retry_cnt++;
3934                 BT_DBG("Retry to initialize the obexd receiver");
3935                 return TRUE;
3936         }
3937
3938         retry_cnt = 0;
3939         session_reinit_timer = 0;
3940
3941         BT_DBG("-");
3942
3943         return FALSE;
3944 }
3945
3946 /* To receive the event from bluez */
3947 int _bt_init_service_event_receiver(void)
3948 {
3949         BT_DBG("+");
3950
3951         int result;
3952
3953         result = __bt_init_manager_receiver();
3954         retv_if(result != BLUETOOTH_ERROR_NONE, result);
3955
3956         result = __bt_init_obexd_receiver();
3957         if (result != BLUETOOTH_ERROR_NONE) {
3958                 BT_ERR("Fail to init obexd receiver");
3959
3960                 /* Try to re-initialize obexd receiver in the timer */
3961                 if (session_reinit_timer > 0)
3962                         g_source_remove(session_reinit_timer);
3963
3964                 session_reinit_timer = g_timeout_add(BT_SESSION_BUS_GET_TIMEOUT,
3965                                                         (GSourceFunc)__bt_reinit_obexd_receiver, NULL);
3966         }
3967
3968         BT_DBG("-");
3969
3970         return BLUETOOTH_ERROR_NONE;
3971 }
3972
3973 void _bt_deinit_service_event_receiver(void)
3974 {
3975         BT_DBG("+");
3976
3977         _bt_unregister_service_event(manager_conn, BT_MANAGER_EVENT);
3978
3979         _bt_unregister_service_event(obexd_conn, BT_OPP_SERVER_EVENT);
3980
3981         __bt_register_dump_subscribe_signal(manager_conn, FALSE);
3982
3983         if (manager_conn) {
3984                 g_object_unref(manager_conn);
3985                 manager_conn = NULL;
3986         }
3987
3988         if (obexd_conn) {
3989                 g_object_unref(obexd_conn);
3990                 obexd_conn = NULL;
3991         }
3992
3993         if (event_id > 0)
3994                 g_source_remove(event_id);
3995         event_id = 0;
3996
3997         if (le_scan_event_id > 0)
3998                 g_source_remove(le_scan_event_id);
3999         le_scan_event_id = 0;
4000
4001         BT_DBG("-");
4002 }
4003