bt-service-adaptation/services/obex/bt-service-obex-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-core-device.h"
  31 #include "bt-service-obex-server.h"
  32 #include "bt-service-obex-agent.h"
  33 #include "bt-service-pbap.h"
  34 #include "bt-service-opp-client.h"
  35 #include "bt-service-map-client.h"
  36 #include "bt-service-core-adapter.h"
  37
  38 #ifdef TIZEN_FEATURE_BT_DPM
  39 #include "bt-service-dpm.h"
  40 #endif
  41
  42 #define DBUS_TIMEOUT 20 * 1000 /* 20 Sec */
  43 static GDBusConnection *manager_conn;
  44 static GDBusConnection *obexd_conn;
  45 static GDBusConnection *opc_obexd_conn;
  46 static GDBusConnection *map_obexd_conn;
  47
  48 static GList *p_cache_list = NULL;
  49
  50 static guint event_id;
  51
  52 static guint session_reinit_timer;
  53
  54 typedef struct {
  55         bt_remote_dev_info_t *dev_info;
  56 } bt_cache_info_t;
  57
  58 /**
  59  * obexd connection type
  60  */
  61 typedef enum {
  62         OBEX_OPP = (1 << 1),
  63         OBEX_FTP = (1 << 2),
  64         OBEX_BIP = (1 << 3),
  65         OBEX_PBAP = (1 << 4),
  66         OBEX_IRMC = (1 << 5),
  67         OBEX_PCSUITE = (1 << 6),
  68         OBEX_SYNCEVOLUTION = (1 << 7),
  69         OBEX_MAS = (1 << 8),
  70         OBEX_MAP = (1 << 9),
  71 } bluetooth_obex_connection_type_t;
  72
  73
  74 void _bt_handle_property_changed_event(GVariant *msg, const char *object_path);
  75 void _bt_opc_property_changed_event(GVariant *msg, char *path);
  76 void _bt_map_property_changed_event(GVariant *msg, const char *path);
  77 int _bt_register_service_event(GDBusConnection *g_conn, int event_type);
  78 void _bt_unregister_service_event(GDBusConnection *g_conn, int event_type);
  79 void _bt_opp_client_event_deinit(void);
  80 void _bt_map_client_event_deinit(void);
  81 void _bt_map_on_transfer_finished(const char *transfer_object_path, const int error);
  82
  83 static void __bt_free_cache_info(bt_cache_info_t *cache_info)
  84 {
  85         ret_if(cache_info == NULL);
  86         _bt_free_remote_dev(cache_info->dev_info);
  87         g_free(cache_info);
  88 }
  89
  90
  91 /* Temp Adapter changes required to make OBEX work for handling device events here ,
  92    This code will be removed and moved to OAL Event Handling part .
  93 */
  94
  95 #if 0
  96 static void __bt_get_uuids(GVariant *value, bt_remote_dev_info_t *info)
  97 {
  98         ret_if(value == NULL);
  99         ret_if(info == NULL);
 100
 101         gsize uuid_count = 0;
 102
 103         info->uuids = g_variant_dup_strv(value, &uuid_count);
 104         info->uuid_count = (unsigned int)uuid_count;
 105
 106         BT_DBG("uuid count : %d", uuid_count);
 107 }
 108 #endif
 109
 110 void _bt_convert_addr_string_to_secure_string(char *addr,
 111                                         const char *address)
 112 {
 113         int len;
 114
 115         ret_if(address == NULL);
 116         ret_if(addr == NULL);
 117
 118         len = strlen(address);
 119         ret_if(len != BT_ADDRESS_STRING_SIZE - 1);
 120
 121         strncpy(addr, address, len);
 122
 123         addr[len-1] = 'X';
 124         addr[len-2] = 'X';
 125
 126         return;
 127 }
 128
 129 bt_status_t _bt_adapter_get_status_for_Obex(void)
 130 {
 131         int value = VCONFKEY_BT_STATUS_OFF;
 132
 133         /* check VCONFKEY_BT_STATUS */
 134         if (vconf_get_int(VCONFKEY_BT_STATUS, &value) != 0) {
 135                 BT_ERR("fail to get vconf key!");
 136                 return BLUETOOTH_ADAPTER_DISABLED;
 137         }
 138
 139         return value;
 140 }
 141
 142 static int __bt_get_owner_info(GVariant *msg, char **name,
 143                                 char **previous, char **current)
 144 {
 145         g_variant_get(msg, "(sss)", name, previous, current);
 146         return BLUETOOTH_ERROR_NONE;
 147 }
 148
 149 static int __bt_get_agent_signal_info(GVariant *msg, char **address,
 150                                 char **name, char **uuid)
 151 {
 152         g_variant_get(msg, "(sss)", address, name, uuid);
 153         return BLUETOOTH_ERROR_NONE;
 154 }
 155
 156 void __bt_update_remote_cache_devinfo(const char *address, gboolean paired_status)
 157 {
 158         BT_DBG("+");
 159
 160         ret_if(address == NULL);
 161
 162         GList * node;
 163         bt_cache_info_t *cache_info;
 164         bt_remote_dev_info_t *dev_info;
 165
 166         node = g_list_first(p_cache_list);
 167
 168         while (node != NULL) {
 169                 cache_info = (bt_cache_info_t *)node->data;
 170
 171                 if (cache_info == NULL) {
 172                         node = g_list_next(node);
 173                         continue;
 174                 }
 175
 176                 dev_info = cache_info->dev_info;
 177                 if (strcasecmp(dev_info->address,
 178                                         address) == 0) {
 179                         BT_DBG("Device Found");
 180                         if (paired_status == TRUE)
 181                                 cache_info->dev_info->paired = TRUE;
 182                         else
 183                                 cache_info->dev_info->paired = FALSE;
 184                         break;
 185                 }
 186                 node = g_list_next(node);
 187         }
 188         BT_DBG("-");
 189 }
 190
 191 gboolean __bt_handle_is_flight_mode_enabled(void)
 192 {
 193         if (TIZEN_FEATURE_FLIGHTMODE_ENABLED) {
 194                 int is_flight_mode = 0;
 195                 int ret = -1;
 196                 ret = vconf_get_bool(VCONFKEY_TELEPHONY_FLIGHT_MODE, &is_flight_mode);
 197                 if (ret != 0)
 198                         BT_ERR("vconf_get_bool failed");
 199
 200                 return (is_flight_mode == 0) ? FALSE : TRUE;
 201         } else {
 202                 return FALSE;
 203         }
 204 }
 205
 206 void _bt_handle_adapter_event(GVariant *msg, const char *member)
 207 {
 208         BT_DBG("+");
 209         ret_if(member == NULL);
 210
 211         if (strcasecmp(member, "DeviceCreated") == 0) {
 212                 char *object_path = NULL;
 213                 char *address;
 214                 ret_if(_bt_is_device_creating() == FALSE);
 215
 216                 /* Bonding from remote device */
 217                 address = g_malloc0(BT_ADDRESS_STRING_SIZE);
 218
 219                 g_variant_get(msg, "(&o)", &object_path);
 220                 _bt_convert_device_path_to_address((const char*)object_path, address);
 221
 222                 g_free(address);
 223         } else if (strcasecmp(member, "InterfacesRemoved") == 0) {
 224                 char *object_path = NULL;
 225                 char *address;
 226                 bt_cache_info_t *cache_info;
 227                 bt_remote_dev_info_t *dev_info;
 228                 GList * node;
 229
 230                 /* Bonding from remote device */
 231                 address = g_malloc0(BT_ADDRESS_STRING_SIZE);
 232
 233                 g_variant_get(msg, "(&o)", &object_path);
 234
 235                 _bt_convert_device_path_to_address((const char *)object_path, address);
 236
 237                 node = g_list_first(p_cache_list);
 238
 239                 while (node != NULL) {
 240                         cache_info = (bt_cache_info_t *)node->data;
 241
 242                         if (cache_info == NULL) {
 243                                 node = g_list_next(node);
 244                                 continue;
 245                         }
 246
 247                         dev_info = cache_info->dev_info;
 248                         if (strcasecmp(dev_info->address,
 249                                                 address) == 0) {
 250                                 p_cache_list = g_list_remove(p_cache_list,
 251                                                 cache_info);
 252                                 __bt_free_cache_info(cache_info);
 253                                 break;
 254                         }
 255                         node = g_list_next(node);
 256                 }
 257                 g_free(address);
 258         } else if (strcasecmp(member, BT_HARDWARE_ERROR) == 0) {
 259                 BT_ERR_C("### Hardware error received from BLUEZ");
 260         } else if (strcasecmp(member, BT_TX_TIMEOUT_ERROR) == 0) {
 261                 BT_ERR_C("### Tx timeout error received from BLUEZ");
 262         }
 263         BT_DBG("-");
 264 }
 265 static void __bt_obex_property_changed_event(GVariant *msg, const char *path)
 266 {
 267         BT_DBG("+");
 268
 269         GVariantIter value_iter;
 270         GVariant *child = NULL, *val = NULL;
 271         char *property = NULL;
 272         g_variant_iter_init(&value_iter, msg);
 273         while ((child = g_variant_iter_next_value(&value_iter))) {
 274                 g_variant_get(child, "{sv}", &property, &val);
 275
 276                 ret_if(property == NULL);
 277
 278                 BT_DBG("property :%s", property);
 279
 280                 if (strcasecmp(property, "Status") == 0) {
 281                         char  *status;
 282                         g_variant_get(val, "s", &status);
 283
 284                         if (strcasecmp(status, "active") == 0) {
 285                                 _bt_obex_transfer_started(path);
 286                         } else if (strcasecmp(status, "complete") == 0) {
 287                                 _bt_obex_transfer_completed(path, TRUE);
 288                                 _bt_pbap_obex_transfer_completed(path, TRUE);
 289                         } else if (strcasecmp(status, "error") == 0) {
 290                                 _bt_obex_transfer_completed(path, FALSE);
 291                                 _bt_pbap_obex_transfer_completed(path, FALSE);
 292                         }
 293                         g_free(status);
 294                 } else if (strcasecmp(property, "Transferred") == 0) {
 295                         guint64 transferred  = 0;
 296                         /* As Transferred is expected guint64 so change int to guint64 and
 297                          * eariler transferred is static because of it can overwrite data
 298                          * on present on opc_obex_conn or obexd_conn as these are
 299                          * static memory are in sequential */
 300                         g_variant_get(val, "t", &transferred);
 301
 302                         _bt_obex_transfer_progress(path, transferred);
 303                 }
 304                 /* TODO: MAP, "Complete"? see above */
 305                 g_free(property);
 306                 g_variant_unref(val);
 307                 g_variant_unref(child);
 308         }
 309         BT_DBG("-");
 310 }
 311
 312 #if 0
 313 static void __bt_device_remote_connected_properties(
 314                                 bt_remote_dev_info_t *remote_dev_info,
 315                                 char *address, gboolean connected)
 316 {
 317         int result = BLUETOOTH_ERROR_NONE;
 318         int i;
 319         GVariant *param = NULL;
 320         BT_DBG("+");
 321
 322         if (remote_dev_info->uuid_count > 0) {
 323                 for (i = 0; i < remote_dev_info->uuid_count; i++) {
 324                         char *uuid = remote_dev_info->uuids[i];
 325                         if (strcasecmp(uuid, HID_UUID) == 0) {
 326                                 int event = BLUETOOTH_EVENT_NONE;
 327
 328                                 event = (connected == TRUE) ?
 329                                         BLUETOOTH_HID_CONNECTED :
 330                                         BLUETOOTH_HID_DISCONNECTED;
 331                                 param = g_variant_new("(is)", result,
 332                                                         address);
 333                                 _bt_send_event(BT_HID_EVENT, event,
 334                                         param);
 335                                 break;
 336                         }
 337                 }
 338         }
 339
 340         BT_DBG("-");
 341 }
 342
 343 bt_remote_dev_info_t *_bt_get_remote_device_info_by_object_path(
 344                                                         const char *object_path)
 345 {
 346         bt_remote_dev_info_t *dev_info;
 347         GDBusProxy *adapter_proxy;
 348         GDBusProxy *device_proxy;
 349         GVariant *value;
 350         GVariant *tmp_value;
 351         gchar *name;
 352         gchar * address;
 353         GDBusConnection *conn;
 354         GError *error = NULL;
 355         GVariant *result = NULL;
 356         GVariantIter *value_iter;
 357         guint8 m_value;
 358         int i = 0;
 359
 360         adapter_proxy = _bt_get_adapter_proxy();
 361         retv_if(adapter_proxy == NULL, NULL);
 362
 363         retv_if(object_path == NULL, NULL);
 364
 365         conn = _bt_gdbus_get_system_gconn();
 366         if (conn == NULL) {
 367                 BT_ERR("conn == NULL");
 368                 return NULL;
 369         }
 370
 371         device_proxy = g_dbus_proxy_new_sync(conn, G_DBUS_PROXY_FLAGS_NONE,
 372                                         NULL, BT_BLUEZ_NAME, object_path,
 373                                         BT_PROPERTIES_INTERFACE,  NULL, NULL);
 374
 375         retv_if(device_proxy == NULL, NULL);
 376
 377         result = g_dbus_proxy_call_sync(device_proxy, "GetAll",
 378                                 g_variant_new("(s)", BT_DEVICE_INTERFACE),
 379                                 G_DBUS_CALL_FLAGS_NONE,
 380                                 -1,
 381                                 NULL,
 382                                 &error);
 383
 384         g_object_unref(device_proxy);
 385
 386         dev_info = g_malloc0(sizeof(bt_remote_dev_info_t));
 387
 388         if (result != NULL) {
 389                 g_variant_get(result , "(@a{sv})", &value);
 390                 g_variant_unref(result);
 391
 392                 tmp_value = g_variant_lookup_value(value, "Alias", G_VARIANT_TYPE_STRING);
 393
 394                 g_variant_get(tmp_value, "s", &name);
 395                 g_variant_unref(tmp_value);
 396                 if (name != NULL)
 397                         DBG_SECURE("Alias Name [%s]", name);
 398                 else {
 399                         tmp_value = g_variant_lookup_value(value, "Name", G_VARIANT_TYPE_STRING);
 400                         g_variant_get(tmp_value, "s", &name);
 401                         g_variant_unref(tmp_value);
 402                 }
 403
 404                 tmp_value = g_variant_lookup_value(value, "IsAliasSet", G_VARIANT_TYPE_BOOLEAN);
 405                 if (tmp_value) {
 406                         dev_info->is_alias_set = g_variant_get_boolean(tmp_value);
 407                         g_variant_unref(tmp_value);
 408                 } else {
 409                         dev_info->is_alias_set = FALSE;
 410                 }
 411                 BT_DBG("IsAliasSet: [%s]", dev_info->is_alias_set ? "TRUE" : "FALSE");
 412
 413                 tmp_value = g_variant_lookup_value(value, "Class", G_VARIANT_TYPE_UINT32);
 414                 if (tmp_value) {
 415                         dev_info->class = g_variant_get_uint32(tmp_value);
 416                         g_variant_unref(tmp_value);
 417                 } else
 418                         dev_info->class = 0;
 419
 420                 tmp_value = g_variant_lookup_value(value, "Connected",  G_VARIANT_TYPE_BYTE);
 421                 if (tmp_value) {
 422                         dev_info->connected = g_variant_get_byte(tmp_value);
 423                         g_variant_unref(tmp_value);
 424                 } else
 425                         dev_info->connected = BLUETOOTH_CONNECTED_LINK_NONE;
 426                 BT_DBG("connected link : %d", dev_info->connected);
 427
 428                 tmp_value = g_variant_lookup_value(value, "Trusted",  G_VARIANT_TYPE_BOOLEAN);
 429                 if (tmp_value) {
 430                         dev_info->trust = g_variant_get_boolean(tmp_value);
 431                         g_variant_unref(tmp_value);
 432                 } else
 433                         dev_info->trust = FALSE;
 434
 435                 tmp_value = g_variant_lookup_value(value, "Paired",  G_VARIANT_TYPE_BOOLEAN);
 436                 if (tmp_value) {
 437                         dev_info->paired = g_variant_get_boolean(tmp_value);
 438                         g_variant_unref(tmp_value);
 439                 } else
 440                         dev_info->paired = FALSE;
 441
 442                 tmp_value = g_variant_lookup_value(value, "RSSI", G_VARIANT_TYPE_INT16);
 443                 if (tmp_value) {
 444                         dev_info->rssi = g_variant_get_int16(tmp_value);
 445                         g_variant_unref(tmp_value);
 446                 } else
 447                         dev_info->rssi = 0;
 448
 449                 tmp_value = g_variant_lookup_value(value, "LastAddrType", G_VARIANT_TYPE_BYTE);
 450                 if (tmp_value) {
 451                         dev_info->addr_type = g_variant_get_byte(tmp_value);
 452                         g_variant_unref(tmp_value);
 453                 } else
 454                         dev_info->addr_type = 0;
 455
 456                 tmp_value = g_variant_lookup_value(value, "UUIDs", G_VARIANT_TYPE_STRING_ARRAY);
 457                 if (tmp_value) {
 458                         __bt_get_uuids(tmp_value, dev_info);
 459                         g_variant_unref(tmp_value);
 460                 }
 461
 462                 tmp_value = g_variant_lookup_value(value, "ManufacturerDataLen", G_VARIANT_TYPE_UINT16);
 463                 if (tmp_value) {
 464                         dev_info->manufacturer_data_len = g_variant_get_uint16(tmp_value);
 465                         if (dev_info->manufacturer_data_len > BLUETOOTH_MANUFACTURER_DATA_LENGTH_MAX) {
 466                                 BT_ERR("manufacturer_data_len is too long(len = %d)", dev_info->manufacturer_data_len);
 467                                 dev_info->manufacturer_data_len = BLUETOOTH_MANUFACTURER_DATA_LENGTH_MAX;
 468                         }
 469                         g_variant_unref(tmp_value);
 470                 } else
 471                         dev_info->manufacturer_data_len = 0;
 472
 473                 tmp_value = g_variant_lookup_value(value, "ManufacturerData", G_VARIANT_TYPE_ARRAY);
 474                 if (tmp_value) {
 475                         if ((dev_info->manufacturer_data_len == 0) ||
 476                                         dev_info->manufacturer_data_len != g_variant_get_size(tmp_value)) {
 477                                 BT_ERR("manufacturer data length doesn't match");
 478                                 dev_info->manufacturer_data_len = 0;
 479                                 dev_info->manufacturer_data = NULL;
 480                         } else {
 481                                 dev_info->manufacturer_data = g_malloc0(dev_info->manufacturer_data_len);
 482                                 g_variant_get(tmp_value, "ay", &value_iter);
 483                                 while (g_variant_iter_loop(value_iter, "y", &m_value))
 484                                         dev_info->manufacturer_data[i++] = m_value;
 485                         }
 486                         g_variant_unref(tmp_value);
 487                 } else {
 488                         BT_INFO("manufacture data is not a G_VARIANT_TYPE_ARRAY ");
 489                         dev_info->manufacturer_data_len = 0;
 490                         dev_info->manufacturer_data = NULL;
 491                 }
 492
 493                 tmp_value = g_variant_lookup_value(value, "Address", G_VARIANT_TYPE_STRING);
 494                 g_variant_get(tmp_value, "s", &address);
 495                 g_variant_unref(tmp_value);
 496
 497                 dev_info->address = g_strdup(address);
 498                 dev_info->name = g_strdup(name);
 499                 g_free(name);
 500                 g_variant_unref(value);
 501         } else {
 502                 BT_ERR("result  is NULL\n");
 503                 g_free(dev_info);
 504                 dev_info = NULL;
 505         }
 506
 507         return dev_info;
 508 }
 509 #endif
 510
 511 void _bt_handle_property_changed_event(GVariant *msg, const char *object_path)
 512 {
 513         char *interface_name = NULL;
 514         GVariant *val = NULL;
 515
 516         g_variant_get(msg, "(&s@a{sv}@as)", &interface_name, &val, NULL);
 517         BT_DBG("_bt_handle_property_changed_event");
 518
 519         if (strcasecmp(interface_name, BT_OBEX_TRANSFER_INTERFACE) == 0) {
 520                 BT_DBG("BT_OBEX_TRANSFER_INTERFACE");
 521                 __bt_obex_property_changed_event(val,
 522                                         object_path);
 523         }
 524         g_variant_unref(val);
 525 }
 526
 527 void __bt_opc_property_changed_event(GVariant *msg,
 528                                                 const char *path)
 529 {
 530         GVariantIter value_iter;
 531         char *property = NULL;
 532         GVariant *val = NULL;
 533         GVariant *child = NULL;
 534
 535         g_variant_iter_init(&value_iter, msg);
 536         if ((child = g_variant_iter_next_value(&value_iter))) {
 537                 g_variant_get(child, "{sv}", &property, &val);
 538                 ret_if(property == NULL);
 539
 540                 if (strcasecmp(property, "Status") == 0) {
 541                         char *status = NULL;
 542                         g_variant_get(val, "s", &status);
 543                         BT_DBG("Status is %s", status);
 544
 545                         if (strcasecmp(status, "active") == 0)
 546                                 _bt_obex_client_started(path);
 547                         else if (strcasecmp(status, "complete") == 0)
 548                                 _bt_obex_client_completed(path, TRUE);
 549                         else if (strcasecmp(status, "error") == 0)
 550                                 _bt_obex_client_completed(path, FALSE);
 551
 552                         g_free(status);
 553                 } else if (strcasecmp(property, "Transferred") == 0) {
 554                         guint64 transferred  = 0;
 555                         g_variant_get(val, "t", &transferred);
 556
 557                         _bt_obex_client_progress(path, transferred);
 558                 } else {
 559                         BT_DBG("property : [%s]", property);
 560                 }
 561                 g_free(property);
 562                 g_variant_unref(child);
 563                 g_variant_unref(val);
 564         }
 565 }
 566
 567 void _bt_opc_property_changed_event(GVariant *msg, char *path)
 568 {
 569         char *interface_name = NULL;
 570         GVariant *value = NULL;
 571         g_variant_get(msg, "(&s@a{sv}@as)", &interface_name, &value, NULL);
 572         BT_INFO("interface_name = %s", interface_name);
 573         if (strcasecmp(interface_name, BT_OBEX_TRANSFER_INTERFACE) == 0) {
 574                 __bt_opc_property_changed_event(value,
 575                                         path);
 576         } else {
 577                 BT_DBG("interface_name : [%s]", interface_name);
 578         }
 579         g_variant_unref(value);
 580 }
 581
 582
 583 void __bt_map_property_changed_event(GVariant *msg,
 584                                                 const char *path)
 585 {
 586         BT_DBG("Entered");
 587         GVariantIter value_iter;
 588         char *property = NULL;
 589         GVariant *val = NULL;
 590         GVariant *child = NULL;
 591
 592         g_variant_iter_init(&value_iter, msg);
 593         while ((child = g_variant_iter_next_value(&value_iter))) {
 594                 g_variant_get(child, "{sv}", &property, &val);
 595                 ret_if(property == NULL);
 596
 597                 if (strcasecmp(property, "Status") == 0) {
 598                         char *status = NULL;
 599                         g_variant_get(val, "s", &status);
 600                         BT_DBG("Status is %s", status);
 601
 602                         if (strcasecmp(status, "active") == 0) {
 603                                 BT_DBG("EVENT : STARTED");
 604                                 // currently doing nothing
 605                         } else if (strcasecmp(status, "complete") == 0) {
 606                                 BT_DBG("EVENT : COMPLETED");
 607                                 _bt_map_on_transfer_finished(path, BLUETOOTH_ERROR_NONE);
 608                         } else if (strcasecmp(status, "error") == 0) {
 609                                 BT_DBG("EVENT : FAILED");
 610                                 _bt_map_on_transfer_finished(path, BLUETOOTH_ERROR_INTERNAL);
 611                         }
 612                         g_free(status);
 613                 } else if (strcasecmp(property, "Transferred") == 0) {
 614                         guint64 transferred  = 0;
 615                         g_variant_get(val, "t", &transferred);
 616
 617                         BT_DBG("EVENT : PROGRESS CALLBACK");
 618                         // currently doing nothing - progress callback type is not used
 619                 } else {
 620                         BT_DBG("OTHER EVENT : property : [%s]", property);
 621                 }
 622                 g_free(property);
 623                 g_variant_unref(child);
 624                 g_variant_unref(val);
 625         }
 626 }
 627
 628 void _bt_map_property_changed_event(GVariant *msg, const char *path)
 629 {
 630         BT_DBG("Entered _bt_map_property_changed_event");
 631         char *interface_name = NULL;
 632         GVariant *value = NULL;
 633         g_variant_get(msg, "(&s@a{sv}@as)", &interface_name, &value, NULL);
 634         BT_INFO("interface_name = %s", interface_name);
 635         if (strcasecmp(interface_name, BT_OBEX_TRANSFER_INTERFACE) == 0) {
 636                 __bt_map_property_changed_event(value,
 637                                 path);
 638         } else {
 639                 BT_DBG("interface_name : [%s]", interface_name);
 640         }
 641         g_variant_unref(value);
 642 }
 643
 644
 645 void _bt_handle_agent_event(GVariant *msg, const char *member)
 646 {
 647         int result = BLUETOOTH_ERROR_NONE;
 648         char *address = NULL;
 649         char *name = NULL;
 650         char *uuid = NULL;
 651         GVariant *param = NULL;
 652         ret_if(member == NULL);
 653
 654         if (strcasecmp(member, "ObexAuthorize") == 0) {
 655                 __bt_get_agent_signal_info(msg, &address, &name, &uuid);
 656                 param = g_variant_new("(iss)", result, address, name);
 657                 _bt_send_event(BT_OPP_SERVER_EVENT,
 658                         BLUETOOTH_EVENT_OBEX_SERVER_CONNECTION_AUTHORIZE,
 659                         param);
 660                 /* TODO: MAP? see above */
 661                 g_free(address);
 662                 g_free(name);
 663         }
 664 }
 665
 666 static int __bt_get_object_path(GVariant *msg, char **path)
 667 {
 668         g_variant_get(msg, "(o*)", path, NULL);
 669         if (*path == NULL)
 670                 return BLUETOOTH_ERROR_INTERNAL;
 671
 672         return BLUETOOTH_ERROR_NONE;
 673 }
 674
 675 #if 0
 676 static void __bt_get_service_list(GVariant *value, bluetooth_device_info_t *dev)
 677 {
 678         int i = 0;
 679         char **parts;
 680         GVariantIter *iter;
 681         gchar *uuid = NULL;
 682
 683         ret_if(value == NULL);
 684         ret_if(dev == NULL);
 685
 686         dev->service_index = 0;
 687
 688         g_variant_get(value, "as", &iter);
 689         while (g_variant_iter_loop(iter, "s", &uuid)) {
 690                 g_strlcpy(dev->uuids[i], uuid, BLUETOOTH_UUID_STRING_MAX);
 691                 parts = g_strsplit(uuid, "-", -1);
 692
 693                 if (parts == NULL || parts[0] == NULL) {
 694                         g_free(uuid);
 695                         break;
 696                 }
 697
 698                 dev->service_list_array[i] = g_ascii_strtoull(parts[0], NULL, 16);
 699                 g_strfreev(parts);
 700
 701                 dev->service_index++;
 702                 i++;
 703         }
 704         g_variant_iter_free(iter);
 705 }
 706
 707 static int __bt_get_bonded_device_info(gchar *device_path,
 708                 bluetooth_device_info_t *dev_info)
 709 {
 710         GError *error = NULL;
 711         GDBusProxy *device_proxy;
 712         gchar *address = NULL;
 713         gchar *name = NULL;
 714         unsigned int cod = 0;
 715         gint rssi = 0;
 716         gboolean trust = FALSE;
 717         gboolean paired = FALSE;
 718         guchar connected = 0;
 719         GByteArray *manufacturer_data = NULL;
 720         int ret;
 721         GDBusConnection *conn;
 722         GVariant *result;
 723         GVariantIter *property_iter;
 724         const gchar *key;
 725         GVariant *value;
 726         guint8 char_value;
 727         GVariantIter *char_value_iter;
 728
 729         BT_CHECK_PARAMETER(device_path, return);
 730         BT_CHECK_PARAMETER(dev_info, return);
 731
 732         conn = _bt_gdbus_get_system_gconn();
 733         retv_if(conn == NULL, BLUETOOTH_ERROR_INTERNAL);
 734
 735         device_proxy = g_dbus_proxy_new_sync(conn, G_DBUS_PROXY_FLAGS_NONE,
 736                                         NULL,
 737                                         BT_BLUEZ_NAME,
 738                                         device_path,
 739                                         BT_PROPERTIES_INTERFACE,
 740                                         NULL, NULL);
 741
 742         retv_if(device_proxy == NULL, BLUETOOTH_ERROR_INTERNAL);
 743
 744         result = g_dbus_proxy_call_sync(device_proxy,
 745                                 "GetAll",
 746                                 g_variant_new("(s)", BT_DEVICE_INTERFACE),
 747                                 G_DBUS_CALL_FLAGS_NONE,
 748                                 -1,
 749                                 NULL,
 750                                 &error);
 751
 752         if (!result) {
 753                 BT_ERR("Error occured in Proxy call");
 754                 if (error != NULL) {
 755                         BT_ERR("Error occured in Proxy call (Error: %s)", error->message);
 756                         g_clear_error(&error);
 757                 }
 758                 g_object_unref(device_proxy);
 759                 return BLUETOOTH_ERROR_INTERNAL;
 760         }
 761
 762         g_object_unref(device_proxy);
 763
 764         g_variant_get(result, "(a{sv})", &property_iter);
 765
 766         while (g_variant_iter_loop(property_iter, "{sv}", &key, &value)) {
 767                 if (!g_strcmp0(key, "Paired")) {
 768                         paired = g_variant_get_boolean(value);
 769                 } else if (!g_strcmp0(key, "Address")) {
 770                         g_variant_get(value, "s", &address);
 771                 } else if (!g_strcmp0(key, "Alias")) {
 772                         g_variant_get(value, "s", &name);
 773                 } else if (!g_strcmp0(key, "Name")) {
 774                         if (!name)
 775                                 g_variant_get(value, "s", &name);
 776                 } else if (!g_strcmp0(key, "Class")) {
 777                         cod = g_variant_get_uint32(value);
 778                 } else if (!g_strcmp0(key, "Connected")) {
 779                         connected = g_variant_get_byte(value);
 780                 } else if (!g_strcmp0(key, "Trusted")) {
 781                         trust = g_variant_get_boolean(value);
 782                 } else if (!g_strcmp0(key, "RSSI")) {
 783                         rssi = g_variant_get_int16(value);
 784                 } else if (!g_strcmp0(key, "UUIDs")) {
 785                         __bt_get_service_list(value, dev_info);
 786                 } else if (!g_strcmp0(key, "ManufacturerDataLen")) {
 787                         dev_info->manufacturer_data.data_len = g_variant_get_uint16(value);
 788                 } else if (!g_strcmp0(key, "ManufacturerData")) {
 789                         manufacturer_data = g_byte_array_new();
 790                         g_variant_get(value, "ay", &char_value_iter);
 791                         while (g_variant_iter_loop(char_value_iter, "y",  &char_value))
 792                                 g_byte_array_append(manufacturer_data, &char_value, 1);
 793
 794                         g_variant_iter_free(char_value_iter);
 795
 796                         if (manufacturer_data) {
 797                                 if (manufacturer_data->len > 0) {
 798                                         memcpy(dev_info->manufacturer_data.data, manufacturer_data->data,
 799                                                 manufacturer_data->len);
 800                                 }
 801                         }
 802                         g_byte_array_free(manufacturer_data, TRUE);
 803                 }
 804         }
 805         g_variant_iter_free(property_iter);
 806
 807         BT_DBG("trust: %d, paired: %d", trust, paired);
 808
 809         g_variant_unref(result);
 810
 811         if ((paired == FALSE) && (trust == FALSE)) {
 812                 g_free(address);
 813                 g_free(name);
 814                 return BLUETOOTH_ERROR_NOT_PAIRED;
 815         }
 816
 817         _bt_convert_addr_string_to_type(dev_info->device_address.addr,
 818                                         address);
 819
 820         _bt_divide_device_class(&dev_info->device_class, cod);
 821
 822         g_strlcpy(dev_info->device_name.name, name,
 823                         BLUETOOTH_DEVICE_NAME_LENGTH_MAX+1);
 824
 825         dev_info->rssi = rssi;
 826         dev_info->trust = trust;
 827         dev_info->paired = paired;
 828         dev_info->connected = connected;
 829         ret = BLUETOOTH_ERROR_NONE;
 830         g_free(address);
 831         g_free(name);
 832
 833         return ret;
 834 }
 835
 836 int _bt_get_bonded_device_info(bluetooth_device_address_t *device_address,
 837                                 bluetooth_device_info_t *dev_info)
 838 {
 839         char *object_path = NULL;
 840         GDBusProxy *adapter_proxy;
 841         char address[BT_ADDRESS_STRING_SIZE] = { 0 };
 842         int ret = BLUETOOTH_ERROR_NONE;
 843
 844         BT_CHECK_PARAMETER(device_address, return);
 845         BT_CHECK_PARAMETER(dev_info, return);
 846
 847         adapter_proxy = _bt_get_adapter_proxy();
 848         retv_if(adapter_proxy == NULL, BLUETOOTH_ERROR_INTERNAL);
 849
 850         _bt_convert_addr_type_to_string(address, device_address->addr);
 851
 852         object_path = _bt_get_device_object_path(address);
 853
 854         retv_if(object_path == NULL, BLUETOOTH_ERROR_NOT_PAIRED);
 855
 856         ret = __bt_get_bonded_device_info(object_path, dev_info);
 857         g_free(object_path);
 858
 859         return ret;
 860 }
 861 #endif
 862
 863 char *_bt_get_bonded_device_name(char *address)
 864 {
 865         bt_remote_dev_info_t *dev_info;
 866
 867         retv_if(address == NULL, strdup(""));
 868
 869         dev_info = _bt_service_get_remote_dev_info(address);
 870         retv_if(dev_info == NULL, strdup(""));
 871         retv_if(dev_info->name == NULL, strdup(""));
 872
 873         return g_strdup(dev_info->name);
 874 }
 875 /* Temp Adapter Util changes to make OBEX work.
 876 */
 877
 878 void _bt_handle_device_event(GVariant *msg, const char *member, const char *path)
 879 {
 880 //      int event = 0;
 881         int result = BLUETOOTH_ERROR_NONE;
 882         char *address;
 883         char *dev_name = NULL;
 884 //      const char *property = NULL;
 885         GVariant *param = NULL;
 886         char secure_address[BT_ADDRESS_STRING_SIZE] = { 0 };
 887         ret_if(path == NULL);
 888
 889         if (strcasecmp(member, "DeviceConnected") == 0) {
 890                 unsigned char addr_type = 0;
 891
 892                 g_variant_get(msg, "(y)", &addr_type);
 893
 894                 address = g_malloc0(BT_ADDRESS_STRING_SIZE);
 895
 896                 _bt_convert_device_path_to_address(path, address);
 897                 dev_name = _bt_get_bonded_device_name(address);
 898
 899                 _bt_convert_addr_string_to_secure_string(secure_address, address);
 900                 BT_INFO("Address : %s Type : %d", secure_address, addr_type);
 901                 BT_ERR_C("### Connected [%s] [%s]", !addr_type ? "BREDR" : "LE",
 902                                 !addr_type ? dev_name : secure_address);
 903                 g_free(dev_name);
 904
 905                 _bt_logging_connection(TRUE, addr_type);
 906                 param = g_variant_new("(isy)", result, address, addr_type);
 907                 /*Send event to application*/
 908                 _bt_send_event(BT_DEVICE_EVENT,
 909                                         BLUETOOTH_EVENT_DEVICE_CONNECTED,
 910                                         param);
 911                 g_free(address);
 912         } else if (strcasecmp(member, "Disconnected") == 0) {
 913                 unsigned char disc_reason = 0;
 914                 unsigned char addr_type = 0;
 915                 char *dev_name = NULL;
 916                 gboolean sending = FALSE;
 917
 918                 g_variant_get(msg, "(yys)", &addr_type, &disc_reason, &dev_name);
 919
 920                 result = disc_reason;
 921
 922                 address = g_malloc0(BT_ADDRESS_STRING_SIZE);
 923
 924                 _bt_convert_device_path_to_address(path, address);
 925
 926                 /* 0x00 BDADDR_BRDER
 927                       0x01 BDADDR_LE_PUBLIC
 928                       0x02 BDADDR_LE_RANDOM */
 929                 _bt_convert_addr_string_to_secure_string(secure_address, address);
 930                 BT_INFO("Address : %s Type : %d", secure_address, addr_type);
 931                 BT_ERR_C("### Disconnected [%s] [%d : %s] [%s]", !addr_type ? "BREDR" : "LE",
 932                                 disc_reason, _bt_convert_disc_reason_to_string(disc_reason),
 933                                 !addr_type ? dev_name : secure_address);
 934                 g_free(dev_name);
 935
 936                 //_bt_headset_set_local_connection(FALSE);
 937                 _bt_logging_connection(FALSE, addr_type);
 938
 939                 if (!addr_type) {
 940 #ifdef TIZEN_BT_A2DP_SINK_AUTO_CONNECT
 941                         {
 942                                 int bt_device_state = VCONFKEY_BT_DEVICE_NONE;
 943
 944                                 if (vconf_get_int(VCONFKEY_BT_DEVICE, &bt_device_state) != 0)
 945                                         BT_ERR("vconf_get_int failed");
 946
 947                                 BT_INFO("conn_state[0x%x], adapter_state [%d]",
 948                                                         bt_device_state, _bt_adapter_get_status_for_Obex());
 949
 950                                 if (disc_reason == BLUETOOTH_ERROR_CONNECTION_TIMEOUT) {
 951                                         _bt_audio_start_auto_connect(TRUE);
 952                                 } else if (bt_device_state &
 953                                                         VCONFKEY_BT_DEVICE_A2DP_SOURCE_CONNECTED) {
 954                                         BT_INFO("Disconnected due to turning BT off. Skip a address");
 955                                 } else {
 956                                         char *last_connected = NULL;
 957                                         last_connected = vconf_get_str(BT_LAST_CONNECTED_DEVICE);
 958                                         if (!g_strcmp0(address, last_connected))
 959                                                 _bt_audio_set_auto_connect_device_addr("");
 960                                         if (last_connected)
 961                                                 free(last_connected);
 962                                 }
 963                         }
 964
 965 #endif
 966                         /*Check for any OPP transfer on the device and cancel
 967                          * the transfer
 968                          */
 969                         _bt_obex_check_pending_transfer(address);
 970                         _bt_opp_client_is_sending(&sending);
 971                         if (sending == TRUE)
 972                                 _bt_opp_client_check_pending_transfer(address);
 973                         /* TODO: MAP? see above */
 974                 }
 975                 param = g_variant_new("(isy)", result, address, addr_type);
 976                 _bt_send_event(BT_DEVICE_EVENT,
 977                                         BLUETOOTH_EVENT_DEVICE_DISCONNECTED,
 978                                         param);
 979                 g_free(address);
 980         } else if (strcasecmp(member, "ProfileStateChanged") == 0) {
 981                         int state = 0;
 982                         char *profile_uuid = NULL;
 983                         bluetooth_device_address_t bd_addr;
 984
 985                         g_variant_get(msg, "(si)", &profile_uuid, &state);
 986
 987                         address = g_malloc0(BT_ADDRESS_STRING_SIZE);
 988
 989                         _bt_convert_device_path_to_address(path, address);
 990                         _bt_convert_addr_string_to_type(bd_addr.addr, address);
 991
 992                         _bt_convert_addr_string_to_secure_string(secure_address, address);
 993                         BT_DBG("Address: %s", secure_address);
 994                         BT_DBG("Profile UUID: %s", profile_uuid);
 995                         BT_DBG("State: %d", state);
 996                 }
 997 }
 998 static gboolean __bt_parse_device_properties(GVariant *item,
 999                                                 bt_remote_dev_info_t *dev_info)
1000 {
1001         GVariantIter iter;
1002         gchar *key;
1003         GVariant *val;
1004         gsize len = 0;
1005         if (item == NULL)
1006                 return FALSE;
1007
1008         g_variant_iter_init(&iter, item);
1009         while (g_variant_iter_loop(&iter, "{sv}", &key, &val)) {
1010                 if (strcasecmp(key, "Address") == 0)  {
1011                         dev_info->address = g_variant_dup_string(val, &len);
1012                 } else if (strcasecmp(key, "Class") == 0) {
1013                         dev_info->class = g_variant_get_uint32(val);
1014                 } else if (strcasecmp(key, "name") == 0) {
1015                         if (dev_info->name == NULL)
1016                                 dev_info->name = g_variant_dup_string(val, &len);
1017                 } else if (strcasecmp(key, "Connected") == 0) {
1018                         dev_info->connected = g_variant_get_byte(val);
1019                 } else if (strcasecmp(key, "paired") == 0) {
1020                         dev_info->paired = g_variant_get_boolean(val);
1021                 } else if (strcasecmp(key, "Trusted") == 0) {
1022                         dev_info->trust = g_variant_get_boolean(val);
1023                 } else if (strcasecmp(key, "RSSI") == 0) {
1024                         dev_info->rssi = g_variant_get_int16(val);
1025                 } else if (strcasecmp(key, "LastAddrType") == 0) {
1026                         dev_info->addr_type = g_variant_get_byte(val);
1027                 } else if (strcasecmp(key, "UUIDs") == 0) {
1028                         char **uuid_value;
1029                         gsize size = 0;
1030                         int i = 0;
1031                         size = g_variant_get_size(val);
1032
1033                         if (size > 0) {
1034                                 uuid_value = (char **)g_variant_get_strv(val, &size);
1035                                 if (dev_info->uuids == NULL)
1036                                         dev_info->uuids = g_malloc0(sizeof(char *) * size);
1037
1038                                 for (i = 0; uuid_value[i] != NULL; i++) {
1039                                         dev_info->uuid_count++;
1040                                         dev_info->uuids[i] = g_strdup(uuid_value[i]);
1041                                 }
1042                                 g_free(uuid_value);
1043                         }
1044                 } else if (strcasecmp(key, "ManufacturerDataLen") == 0) {
1045                         g_variant_get(val, "q", &dev_info->manufacturer_data_len);
1046                         if (dev_info->manufacturer_data_len > BLUETOOTH_MANUFACTURER_DATA_LENGTH_MAX) {
1047                                 BT_ERR("manufacturer_data_len is too long(len = %d)", dev_info->manufacturer_data_len);
1048                                 dev_info->manufacturer_data_len = BLUETOOTH_MANUFACTURER_DATA_LENGTH_MAX;
1049                         }
1050
1051                         if (dev_info->manufacturer_data_len == 0)
1052                                 dev_info->manufacturer_data = g_strdup("");
1053                 } else if (strcasecmp(key, "ManufacturerData") == 0) {
1054                         int i = 0;
1055                         int len = 0;
1056                         GVariantIter *value_iter;
1057                         guint8 m_value;
1058
1059                         len = g_variant_get_size(val);
1060                         if (len <= 0)
1061                                 continue;
1062
1063                         dev_info->manufacturer_data = g_malloc0(len);
1064
1065                         g_variant_get(val, "ay", &value_iter);
1066                         while (g_variant_iter_loop(value_iter, "y", &m_value))
1067                                 dev_info->manufacturer_data[i++] = m_value;
1068                         g_variant_iter_free(value_iter);
1069                 }
1070         }
1071
1072         BT_DBG("-");
1073         return TRUE;
1074 }
1075
1076 static gboolean __bt_parse_interface(GVariant *msg,
1077                                         bt_remote_dev_info_t *dev_info)
1078 {
1079         char *path = NULL;
1080         GVariant *optional_param = NULL;
1081         GVariantIter iter;
1082         GVariant *child;
1083         char *interface_name = NULL;
1084         GVariant *inner_iter = NULL;
1085         g_variant_get(msg, "(&o@a{sa{sv}})",
1086                                         &path, &optional_param);
1087         g_variant_iter_init(&iter, optional_param);
1088
1089         retv_if(optional_param == NULL, FALSE);
1090
1091         while ((child = g_variant_iter_next_value(&iter))) {
1092                 g_variant_get(child, "{&s@a{sv}}", &interface_name, &inner_iter);
1093                 if (g_strcmp0(interface_name, BT_DEVICE_INTERFACE) == 0) {
1094                         BT_DBG("Found a device: %s", path);
1095                         if (__bt_parse_device_properties(inner_iter,
1096                                 dev_info) == FALSE) {
1097                                 g_variant_unref(inner_iter);
1098                                 g_variant_unref(child);
1099                                 g_variant_unref(optional_param);
1100                                 BT_ERR("Fail to parse the properies");
1101                                 return FALSE;
1102                         } else {
1103                                 g_variant_unref(inner_iter);
1104                                 g_variant_unref(child);
1105                                 g_variant_unref(optional_param);
1106                                 return TRUE;
1107                         }
1108                 }
1109                 g_variant_unref(inner_iter);
1110                 g_variant_unref(child);
1111         }
1112
1113         g_variant_unref(optional_param);
1114
1115         return FALSE;
1116 }
1117
1118 static int __bt_parse_event(GVariant *msg)
1119 {
1120         GVariantIter iter;
1121         GVariant *child;
1122         char *interface_name = NULL;
1123         GVariant *inner_iter = NULL;
1124
1125         g_variant_iter_init(&iter, msg);
1126
1127         while ((child = g_variant_iter_next_value(&iter))) {
1128                 g_variant_get(child, "{&s@a{sv}}", &interface_name, &inner_iter);
1129                 if (g_strcmp0(interface_name,
1130                                 BT_DEVICE_INTERFACE) == 0) {
1131                         g_variant_unref(inner_iter);
1132                         g_variant_unref(child);
1133                         return BT_DEVICE_EVENT;
1134                 } else if (g_strcmp0(interface_name,
1135                                 BT_MEDIATRANSPORT_INTERFACE) == 0) {
1136                         g_variant_unref(inner_iter);
1137                         g_variant_unref(child);
1138                         return BT_MEDIA_TRANSFER_EVENT;
1139                 } else if (g_strcmp0(interface_name,
1140                                 BT_PLAYER_CONTROL_INTERFACE) == 0) {
1141                         g_variant_unref(inner_iter);
1142                         g_variant_unref(child);
1143                         return BT_AVRCP_CONTROL_EVENT;
1144                 }
1145                 g_variant_unref(inner_iter);
1146                 g_variant_unref(child);
1147         }
1148
1149         return 0;
1150 }
1151
1152 static  void __bt_manager_event_filter(GDBusConnection *connection,
1153                                         const gchar *sender_name,
1154                                         const gchar *object_path,
1155                                         const gchar *interface_name,
1156                                         const gchar *signal_name,
1157                                         GVariant *parameters,
1158                                         gpointer user_data)
1159 {
1160
1161         bt_event_type_t bt_event = 0x00;
1162         int result = BLUETOOTH_ERROR_NONE;
1163         GVariant *value;
1164         char *obj_path = NULL;
1165         GVariant *param = NULL;
1166 #ifdef TIZEN_FEATURE_BT_DPM
1167         int desktop_state = DPM_BT_ERROR;
1168 #endif
1169
1170         if (signal_name == NULL)
1171                 return;
1172
1173         if (strcasecmp(signal_name, "InterfacesAdded") == 0) {
1174                 g_variant_get(parameters, "(&o@a{sa{sv}})", &obj_path, &value);
1175
1176                 if (strcasecmp(obj_path, BT_BLUEZ_HCI_PATH) == 0) {
1177                         if (!TIZEN_FEATURE_BT_USB_DONGLE) {
1178                                 if (_bt_register_obex_server() != BLUETOOTH_ERROR_NONE)
1179                                         BT_ERR("Fail to init obex server");
1180                         }
1181                 } else {
1182                         bt_event = __bt_parse_event(value);
1183                         if (bt_event == BT_DEVICE_EVENT) {
1184                                 bt_cache_info_t *cache_info;
1185                                 bt_remote_dev_info_t *dev_info;
1186
1187                                 if(_bt_is_discovering() == FALSE) {
1188                                         g_variant_unref(value);
1189                                         return;
1190                                 }
1191
1192                                 cache_info = g_malloc0(sizeof(bt_cache_info_t));
1193                                 ret_if(cache_info == NULL);
1194
1195                                 dev_info = g_malloc0(sizeof(bt_remote_dev_info_t));
1196                                 if (dev_info == NULL) {
1197                                         __bt_free_cache_info(cache_info);
1198                                         return;
1199                                 }
1200
1201                                 cache_info->dev_info = dev_info;
1202
1203                                 if (__bt_parse_interface(parameters, dev_info) == FALSE) {
1204                                         BT_ERR("Fail to parse the properies");
1205                                         __bt_free_cache_info(cache_info);
1206                                         g_variant_unref(value);
1207                                         return;
1208                                 }
1209
1210                                 if (dev_info->addr_type != BDADDR_BREDR) {
1211                                         /* Whenever emit the property changed from bluez,
1212                                                 some property doesn't reach to bt-service.
1213                                                 So LE device is handled as AdvReport signal */
1214                                         __bt_free_cache_info(cache_info);
1215                                         g_variant_unref(value);
1216                                         return;
1217                                 }
1218
1219                                 if (dev_info->name == NULL)
1220                                         /* If Remote device name is NULL or still RNR is not done
1221                                          * then display address as name.
1222                                          */
1223                                         dev_info->name = g_strdup(dev_info->address);
1224
1225 #ifdef TIZEN_FEATURE_BT_DPM
1226                                 _bt_dpm_get_bluetooth_desktop_connectivity_state(&desktop_state);
1227                                 if (desktop_state == DPM_RESTRICTED) {
1228                                         bluetooth_device_class_t device_class;
1229                                         _bt_divide_device_class(&device_class, dev_info->class);
1230                                         BT_DBG("[%s]device_class.major_class : %d", dev_info->name, device_class.major_class);
1231
1232                                         if (device_class.major_class ==
1233                                                 BLUETOOTH_DEVICE_MAJOR_CLASS_COMPUTER) {
1234                                                 __bt_free_cache_info(cache_info);
1235                                                 g_variant_unref(value);
1236                                                 return;
1237                                         }
1238                                 }
1239 #endif
1240
1241                                 GVariant *uuids = NULL;
1242                                 GVariantBuilder *builder = NULL;
1243                                 int i = 0;
1244                                 builder = g_variant_builder_new(G_VARIANT_TYPE("as"));
1245                                 for (i = 0; i < dev_info->uuid_count; i++) {
1246                                         g_variant_builder_add(builder, "s",
1247                                                 dev_info->uuids[i]);
1248                                 }
1249                                 uuids = g_variant_new("as", builder);
1250                                 g_variant_builder_unref(builder);
1251                                 GVariant *manufacturer_data = NULL;
1252                                 manufacturer_data = g_variant_new_from_data(
1253                                                         G_VARIANT_TYPE_BYTESTRING,
1254                                                         dev_info->manufacturer_data,
1255                                                         dev_info->manufacturer_data_len,
1256                                                         TRUE, NULL, NULL);
1257                                 param = g_variant_new("(isunsbub@asn@ay)", result,
1258                                                         dev_info->address,
1259                                                         dev_info->class,
1260                                                         dev_info->rssi,
1261                                                         dev_info->name,
1262                                                         dev_info->paired,
1263                                                         dev_info->connected,
1264                                                         dev_info->trust,
1265                                                         uuids,
1266                                                         dev_info->manufacturer_data_len,
1267                                                         manufacturer_data);
1268                                 _bt_send_event(BT_ADAPTER_EVENT,
1269                                         BLUETOOTH_EVENT_REMOTE_DEVICE_FOUND,
1270                                          param);
1271                                 p_cache_list = g_list_append(p_cache_list, cache_info);
1272                         } else if (bt_event == BT_AVRCP_CONTROL_EVENT) {
1273                                 BT_DBG("Device path : %s ", obj_path);
1274                                 //_bt_set_control_device_path(obj_path);
1275                         }
1276                 }
1277                 g_variant_unref(value);
1278                 }       else if (strcasecmp(signal_name, "InterfacesRemoved") == 0) {
1279                         if (TIZEN_FEATURE_BT_USB_DONGLE) {
1280                                 if (_bt_unregister_obex_server() != BLUETOOTH_ERROR_NONE)
1281                                         BT_ERR("Fail to unregister obex server");
1282                         }
1283         } else if (strcasecmp(signal_name, "NameOwnerChanged") == 0) {
1284                 gboolean value;
1285                 char *name = NULL;
1286                 char *previous = NULL;
1287                 char *current = NULL;
1288
1289                 if (__bt_get_owner_info(parameters, &name, &previous, &current)) {
1290                         BT_ERR("Fail to get the owner info");
1291                         return;
1292                 }
1293
1294                 if (*current != '\0') {
1295                         g_free(current);
1296                         if (name)
1297                                 g_free(name);
1298                         if (previous)
1299                                 g_free(previous);
1300                         return;
1301                 }
1302
1303                 if (strcasecmp(name, BT_BLUEZ_NAME) == 0) {
1304                         BT_INFO_C("### Bluetoothd is terminated");
1305
1306                         if (_bt_unregister_obex_server() != BLUETOOTH_ERROR_NONE)
1307                                 BT_ERR("Fail to unregister obex server");
1308
1309                 }
1310
1311                 _bt_obex_server_check_allocation(&value);
1312
1313                 if (value == TRUE) {
1314                         /* Check if the obex server was terminated abnormally */
1315                         _bt_obex_server_check_termination(name);
1316                 }
1317
1318                 g_free(name);
1319                 g_free(previous);
1320                 g_free(current);
1321         } else if (g_strcmp0(interface_name, BT_AGENT_INTERFACE) == 0) {
1322                 _bt_handle_agent_event(parameters, signal_name);
1323         } else if (g_strcmp0(interface_name, BT_DEVICE_INTERFACE) == 0) {
1324                 _bt_handle_device_event(parameters, signal_name, object_path);
1325         }
1326
1327         return;
1328 }
1329
1330 static gboolean __bt_is_obexd_event(GVariant *msg, const char *interface)
1331 {
1332
1333         if (g_strcmp0(interface, BT_PROPERTIES_INTERFACE) == 0) {
1334                 char *interface_name = NULL;
1335
1336                 g_variant_get(msg, "(&s@a{sv}@as)", &interface_name, NULL, NULL);
1337                 retv_if(interface_name == NULL, FALSE);
1338
1339                 if (strcasecmp(interface_name, BT_OBEX_TRANSFER_INTERFACE) == 0) {
1340                         BT_DBG("BT_OBEX_TRANSFER_INTERFACE");
1341                         return TRUE;
1342                 }
1343         }
1344
1345         return FALSE;
1346 }
1347
1348 static  void __bt_obexd_event_filter(GDBusConnection *connection,
1349                                         const gchar *sender_name,
1350                                         const gchar *object_path,
1351                                         const gchar *interface_name,
1352                                         const gchar *signal_name,
1353                                         GVariant *parameters,
1354                                         gpointer user_data)
1355 {
1356         const char *member = signal_name;
1357         char *obj_path = NULL;
1358         ret_if(member == NULL);
1359
1360         if (strcasecmp(member, "InterfacesAdded") == 0) {
1361                 if (__bt_get_object_path(parameters, &obj_path)) {
1362                         BT_ERR("Fail to get the path");
1363                         return;
1364                 }
1365                 BT_INFO("object_path = [%s]", obj_path);
1366
1367                 /*Handle OPP_SERVER_CONNECTED_EVENT here */
1368                 /* TODO: MAP? see above */
1369                 if (strncmp(obj_path, BT_SESSION_BASEPATH_SERVER,
1370                                 strlen(BT_SESSION_BASEPATH_SERVER)) != 0) {
1371                         g_free(obj_path);
1372                         return;
1373                 }
1374
1375                 if (g_strrstr(obj_path, "session") && g_strrstr(obj_path, "transfer")) {
1376                         BT_DBG("Obex_Server_Session_Transfer connected");
1377                         _bt_obex_transfer_connected(obj_path);
1378                 }
1379                 g_free(obj_path);
1380         } else if (strcasecmp(member, "InterfacesRemoved") == 0) {
1381                 /*Handle OPP_SERVER_DISCONNECTED_EVENT here */
1382                 /* TODO: MAP? see above */
1383                 if (__bt_get_object_path(parameters, &obj_path)) {
1384                         BT_ERR("Fail to get the path");
1385                         return;
1386                 }
1387                 BT_INFO("object_path = [%s]", obj_path);
1388
1389                 if (strncmp(obj_path, BT_SESSION_BASEPATH_CLIENT,
1390                                 strlen(BT_SESSION_BASEPATH_CLIENT)) == 0) {
1391                         BT_DBG("Call PBAP Disconnected");
1392                         _bt_obex_pbap_client_disconnect(obj_path);
1393                 }
1394
1395                 if (strncmp(obj_path, BT_SESSION_BASEPATH_SERVER,
1396                                 strlen(BT_SESSION_BASEPATH_SERVER)) != 0) {
1397                         g_free(obj_path);
1398                         return;
1399                 }
1400
1401                 if (g_strrstr(obj_path, "session") && g_strrstr(obj_path, "transfer")) {
1402                         BT_DBG("Obex_Server_Session_Transfer disconnected %s",
1403                                                                 obj_path);
1404
1405                         _bt_obex_transfer_disconnected(obj_path);
1406                 }
1407                 g_free(obj_path);
1408         } else if (__bt_is_obexd_event(parameters, interface_name) == TRUE) {
1409                 const char *path = object_path;
1410
1411                 if (strncmp(path, BT_SESSION_BASEPATH_SERVER,
1412                                 strlen(BT_SESSION_BASEPATH_SERVER)) != 0 &&
1413                         strncmp(path, BT_SESSION_BASEPATH_CLIENT,
1414                                 strlen(BT_SESSION_BASEPATH_CLIENT)) != 0) {
1415                         BT_DBG("DBUS_HANDLER_RESULT_NOT_YET_HANDLED");
1416                         return;
1417                 }
1418
1419                 _bt_handle_property_changed_event(parameters, path);
1420         }
1421         BT_DBG("-");
1422         return;
1423 }
1424
1425 static gboolean __bt_is_obexd_client_event(GVariant *msg, const char *interface)
1426 {
1427         BT_DBG("+");
1428
1429         if (g_strcmp0(interface, BT_PROPERTIES_INTERFACE) == 0) {
1430                 char *interface_name = NULL;
1431
1432                 g_variant_get(msg, "(&s@a{sv}@as)", &interface_name, NULL, NULL);
1433
1434                 retv_if(interface_name == NULL, FALSE);
1435
1436                 if (strcasecmp(interface_name,
1437                                         BT_OBEX_TRANSFER_INTERFACE) == 0) {
1438                         BT_DBG("-");
1439                         return TRUE;
1440                 }
1441         }
1442
1443         BT_DBG("-");
1444
1445         return FALSE;
1446 }
1447
1448 static  void __bt_opc_event_filter(GDBusConnection *connection,
1449                                         const gchar *sender_name,
1450                                         const gchar *object_path,
1451                                         const gchar *interface_name,
1452                                         const gchar *signal_name,
1453                                         GVariant *parameters,
1454                                         gpointer user_data)
1455 {
1456         const char *member = signal_name;
1457         char *obj_path = NULL;
1458         if (strcasecmp(member, "InterfacesAdded") == 0) {
1459                 BT_DBG("InterfacesAdded");
1460         } else if (strcasecmp(member, "InterfacesRemoved") == 0) {
1461
1462                 if (__bt_get_object_path(parameters, &obj_path)) {
1463                         BT_ERR("Fail to get the path");
1464                         return;
1465                 }
1466
1467                 BT_DBG("object_path = %s", obj_path);
1468
1469                 if (strncmp(obj_path, BT_SESSION_BASEPATH_CLIENT,
1470                                 strlen(BT_SESSION_BASEPATH_CLIENT)) != 0
1471                                 || strstr(obj_path, "transfer") == NULL) {
1472                         g_free(obj_path);
1473                         return;
1474                 } else if (strncmp(obj_path, BT_SESSION_BASEPATH_CLIENT,
1475                                 strlen(BT_SESSION_BASEPATH_CLIENT)) == 0) {
1476                         BT_DBG("Going to call opc disconnected");
1477                         _bt_opc_disconnected(obj_path);
1478                 }
1479
1480                 _bt_sending_files();
1481                 g_free(obj_path);
1482         } else if (__bt_is_obexd_client_event(parameters, interface_name) == TRUE) {
1483                 char *path = (char *)object_path;
1484                 BT_INFO("object_path %s", path);
1485                 if (strncmp(path, BT_SESSION_BASEPATH_CLIENT,
1486                         strlen(BT_SESSION_BASEPATH_CLIENT)) != 0) {
1487                         BT_DBG("NOT BT_SESSION_BASEPATH_CLIENT");
1488                         return;
1489                 }
1490
1491                 _bt_opc_property_changed_event(parameters, path);
1492         }
1493
1494         return;
1495 }
1496
1497 int _bt_opp_client_event_init(void)
1498 {
1499         GError *error = NULL;
1500
1501         if (opc_obexd_conn == NULL) {
1502                 opc_obexd_conn = g_bus_get_sync(G_BUS_TYPE_SYSTEM, NULL, &error);
1503
1504                 if (!opc_obexd_conn) {
1505                         if (error) {
1506                                 BT_ERR("Unable to connect to dbus: %s", error->message);
1507                                 g_clear_error(&error);
1508                         }
1509                 return BLUETOOTH_ERROR_INTERNAL;
1510                 }
1511         }
1512
1513         if (_bt_register_service_event(opc_obexd_conn,
1514                         BT_OPP_CLIENT_EVENT) != BLUETOOTH_ERROR_NONE) {
1515                         g_object_unref(opc_obexd_conn);
1516                         opc_obexd_conn = NULL;
1517                         return BLUETOOTH_ERROR_INTERNAL;
1518         }
1519
1520         return BLUETOOTH_ERROR_NONE;
1521 }
1522
1523 void _bt_opp_client_event_deinit(void)
1524 {
1525         if (opc_obexd_conn) {
1526                 _bt_unregister_service_event(opc_obexd_conn,
1527                                                 BT_OPP_CLIENT_EVENT);
1528                  g_object_unref(opc_obexd_conn);
1529                  opc_obexd_conn = NULL;
1530         }
1531 }
1532
1533 static  void __bt_map_event_filter(GDBusConnection *connection,
1534                                         const gchar *sender_name,
1535                                         const gchar *object_path,
1536                                         const gchar *interface_name,
1537                                         const gchar *signal_name,
1538                                         GVariant *parameters,
1539                                         gpointer user_data)
1540 {
1541         BT_DBG("Entered __bt_map_event_filter");
1542         const char *member = signal_name;
1543
1544         if (strcasecmp(member, "InterfacesAdded") == 0) {
1545                 BT_DBG("------------------------------------ADDED------------------------------------");
1546                 // currently doing nothing
1547         } else if (strcasecmp(member, "InterfacesRemoved") == 0) {
1548                 BT_DBG("------------------------------------REMOVED------------------------------------");
1549                 // TODO check if something should be called here?
1550                 //_bt_map_on_transfer_finished(object_path, error);
1551         } else if (__bt_is_obexd_client_event(parameters, interface_name) == TRUE) {
1552                 BT_DBG("------------------------------------CLIENT EVENT------------------------------------");
1553                 _bt_map_property_changed_event(parameters, object_path);
1554         }
1555
1556         return;
1557 }
1558
1559 int _bt_map_client_event_init(void)
1560 {
1561         GError *error = NULL;
1562
1563         if (map_obexd_conn == NULL) {
1564                 map_obexd_conn = g_bus_get_sync(G_BUS_TYPE_SYSTEM, NULL, &error);
1565
1566                 if (!map_obexd_conn) {
1567                         if (error) {
1568                                 BT_ERR("Unable to connect to dbus: %s", error->message);
1569                                 g_clear_error(&error);
1570                         }
1571                 return BLUETOOTH_ERROR_INTERNAL;
1572                 }
1573         }
1574
1575         if (_bt_register_service_event(map_obexd_conn,
1576                         BT_MAP_CLIENT_EVENT) != BLUETOOTH_ERROR_NONE) {
1577                         g_object_unref(map_obexd_conn);
1578                         map_obexd_conn = NULL;
1579                         return BLUETOOTH_ERROR_INTERNAL;
1580         }
1581
1582         return BLUETOOTH_ERROR_NONE;
1583 }
1584
1585 void _bt_map_client_event_deinit(void)
1586 {
1587         if (map_obexd_conn) {
1588                 _bt_unregister_service_event(map_obexd_conn,
1589                                                 BT_MAP_CLIENT_EVENT);
1590                  g_object_unref(map_obexd_conn);
1591                  map_obexd_conn = NULL;
1592         }
1593 }
1594
1595 int _bt_register_manager_subscribe_signal(GDBusConnection *conn,
1596                 int subscribe)
1597 {
1598         if (conn == NULL)
1599                 return -1;
1600
1601         static int subs_interface_added_id = -1;
1602         static int subs_interface_removed_id = -1;
1603
1604         if (subscribe) {
1605                 if (subs_interface_added_id == -1) {
1606                         subs_interface_added_id = g_dbus_connection_signal_subscribe(conn,
1607                                 NULL, BT_MANAGER_INTERFACE,
1608                                 BT_INTERFACES_ADDED, NULL, NULL, 0,
1609                                 __bt_manager_event_filter,
1610                                 NULL, NULL);
1611                 }
1612                 if (subs_interface_removed_id == -1) {
1613                         subs_interface_removed_id = g_dbus_connection_signal_subscribe(conn,
1614                                 NULL, BT_MANAGER_INTERFACE,
1615                                 BT_INTERFACES_REMOVED, NULL, NULL, 0,
1616                                 __bt_manager_event_filter,
1617                                 NULL, NULL);
1618                 }
1619
1620         } else {
1621                 if (subs_interface_added_id != -1) {
1622                         g_dbus_connection_signal_unsubscribe(conn,
1623                                         subs_interface_added_id);
1624                         subs_interface_added_id = -1;
1625                 }
1626                 if (subs_interface_removed_id != -1) {
1627                         g_dbus_connection_signal_unsubscribe(conn,
1628                                         subs_interface_removed_id);
1629                         subs_interface_removed_id = -1;
1630                 }
1631         }
1632         return 0;
1633 }
1634
1635 int _bt_register_device_subscribe_signal(GDBusConnection *conn,
1636                 int subscribe)
1637 {
1638         if (conn == NULL)
1639                 return -1;
1640
1641         static int subs_device_id = -1;
1642
1643         if (subscribe) {
1644                 if (subs_device_id == -1) {
1645                         subs_device_id = g_dbus_connection_signal_subscribe(conn,
1646                                 NULL, BT_DEVICE_INTERFACE,
1647                                 NULL, NULL, NULL, 0,
1648                                 __bt_manager_event_filter,
1649                                 NULL, NULL);
1650                 }
1651         } else {
1652                 if (subs_device_id != -1) {
1653                         g_dbus_connection_signal_unsubscribe(conn,
1654                                         subs_device_id);
1655                         subs_device_id = -1;
1656                 }
1657         }
1658         return 0;
1659 }
1660
1661 int _bt_register_input_subscribe_signal(GDBusConnection *conn,
1662                 int subscribe)
1663 {
1664         if (conn == NULL)
1665                 return -1;
1666
1667         static int subs_input_id = -1;
1668
1669         if (subscribe) {
1670                 if (subs_input_id == -1) {
1671                         subs_input_id = g_dbus_connection_signal_subscribe(conn,
1672                                 NULL, BT_INPUT_INTERFACE,
1673                                 NULL, NULL, NULL, 0,
1674                                 __bt_manager_event_filter,
1675                                 NULL, NULL);
1676                 }
1677         } else {
1678                 if (subs_input_id != -1) {
1679                         g_dbus_connection_signal_unsubscribe(conn,
1680                                         subs_input_id);
1681                         subs_input_id = -1;
1682                 }
1683         }
1684         return 0;
1685 }
1686
1687
1688
1689 int _bt_register_opp_server_subscribe_signal(GDBusConnection *conn,
1690                 int subscribe)
1691 {
1692         if (conn == NULL)
1693                 return -1;
1694
1695         static int subs_opp_server_interface_added_id = -1;
1696         static int subs_opp_server_interface_removed_id = -1;
1697         static int subs_opp_server_property_id = -1;
1698
1699
1700         if (subscribe) {
1701                 if (subs_opp_server_interface_added_id == -1) {
1702                         subs_opp_server_interface_added_id = g_dbus_connection_signal_subscribe(conn,
1703                                 NULL, BT_MANAGER_INTERFACE,
1704                                 BT_INTERFACES_ADDED, NULL, NULL, 0,
1705                                 __bt_obexd_event_filter,
1706                                 NULL, NULL);
1707                 }
1708                 if (subs_opp_server_interface_removed_id == -1) {
1709                         subs_opp_server_interface_removed_id = g_dbus_connection_signal_subscribe(conn,
1710                                 NULL, BT_MANAGER_INTERFACE,
1711                                 BT_INTERFACES_REMOVED, NULL, NULL, 0,
1712                                 __bt_obexd_event_filter,
1713                                 NULL, NULL);
1714                 }
1715                 if (subs_opp_server_property_id == -1) {
1716                         subs_opp_server_property_id = g_dbus_connection_signal_subscribe(conn,
1717                                 NULL, BT_PROPERTIES_INTERFACE,
1718                                 BT_PROPERTIES_CHANGED, NULL, NULL, 0,
1719                                 __bt_obexd_event_filter,
1720                                 NULL, NULL);
1721                 }
1722         } else {
1723                 if (subs_opp_server_interface_added_id != -1) {
1724                         g_dbus_connection_signal_unsubscribe(conn,
1725                                         subs_opp_server_interface_added_id);
1726                         subs_opp_server_interface_added_id = -1;
1727                 }
1728                 if (subs_opp_server_interface_removed_id != -1) {
1729                         g_dbus_connection_signal_unsubscribe(conn,
1730                                         subs_opp_server_interface_removed_id);
1731                         subs_opp_server_interface_removed_id = -1;
1732                 }
1733                 if (subs_opp_server_property_id != -1) {
1734                         g_dbus_connection_signal_unsubscribe(conn,
1735                                         subs_opp_server_property_id);
1736                         subs_opp_server_property_id = -1;
1737                 }
1738         }
1739         return 0;
1740 }
1741
1742 int _bt_register_opp_client_subscribe_signal(GDBusConnection *conn,
1743                 int subscribe)
1744 {
1745         if (conn == NULL)
1746                 return -1;
1747
1748         static int subs_opp_client_interface_added_id = -1;
1749         static int subs_opp_client_interface_removed_id = -1;
1750         static int subs_opp_client_property_id = -1;
1751
1752
1753         if (subscribe) {
1754                 if (subs_opp_client_interface_added_id == -1) {
1755                         subs_opp_client_interface_added_id = g_dbus_connection_signal_subscribe(conn,
1756                                 NULL, BT_MANAGER_INTERFACE,
1757                                 BT_INTERFACES_ADDED, NULL, NULL, 0,
1758                                 __bt_opc_event_filter,
1759                                 NULL, NULL);
1760                 }
1761                 if (subs_opp_client_interface_removed_id == -1) {
1762                         subs_opp_client_interface_removed_id = g_dbus_connection_signal_subscribe(conn,
1763                                 NULL, BT_MANAGER_INTERFACE,
1764                                 BT_INTERFACES_REMOVED, NULL, NULL, 0,
1765                                 __bt_opc_event_filter,
1766                                 NULL, NULL);
1767                 }
1768                 if (subs_opp_client_property_id == -1) {
1769                         subs_opp_client_property_id = g_dbus_connection_signal_subscribe(conn,
1770                                 NULL, BT_PROPERTIES_INTERFACE,
1771                                 BT_PROPERTIES_CHANGED, NULL, NULL, 0,
1772                                 __bt_opc_event_filter,
1773                                 NULL, NULL);
1774                 }
1775         } else {
1776                 if (subs_opp_client_interface_added_id != -1) {
1777                         g_dbus_connection_signal_unsubscribe(conn,
1778                                         subs_opp_client_interface_added_id);
1779                         subs_opp_client_interface_added_id = -1;
1780                 }
1781                 if (subs_opp_client_interface_removed_id != -1) {
1782                         g_dbus_connection_signal_unsubscribe(conn,
1783                                         subs_opp_client_interface_removed_id);
1784                         subs_opp_client_interface_removed_id = -1;
1785                 }
1786                 if (subs_opp_client_property_id != -1) {
1787                         g_dbus_connection_signal_unsubscribe(conn,
1788                                         subs_opp_client_property_id);
1789                         subs_opp_client_property_id = -1;
1790                 }
1791         }
1792         return 0;
1793 }
1794
1795 int _bt_register_map_client_subscribe_signal(GDBusConnection *conn,
1796                 int subscribe)
1797 {
1798         if (conn == NULL)
1799                 return -1;
1800
1801         static int subs_map_client_interface_added_id = -1;
1802         static int subs_map_client_interface_removed_id = -1;
1803         static int subs_map_client_property_id = -1;
1804
1805
1806         if (subscribe) {
1807                 if (subs_map_client_interface_added_id == -1) {
1808                         subs_map_client_interface_added_id = g_dbus_connection_signal_subscribe(conn,
1809                                 NULL, BT_MANAGER_INTERFACE,
1810                                 BT_INTERFACES_ADDED, NULL, NULL, 0,
1811                                 __bt_map_event_filter,
1812                                 NULL, NULL);
1813                 }
1814                 if (subs_map_client_interface_removed_id == -1) {
1815                         subs_map_client_interface_removed_id = g_dbus_connection_signal_subscribe(conn,
1816                                 NULL, BT_MANAGER_INTERFACE,
1817                                 BT_INTERFACES_REMOVED, NULL, NULL, 0,
1818                                 __bt_map_event_filter,
1819                                 NULL, NULL);
1820                 }
1821                 if (subs_map_client_property_id == -1) {
1822                         subs_map_client_property_id = g_dbus_connection_signal_subscribe(conn,
1823                                 NULL, BT_PROPERTIES_INTERFACE,
1824                                 BT_PROPERTIES_CHANGED, NULL, NULL, 0,
1825                                 __bt_map_event_filter,
1826                                 NULL, NULL);
1827                 }
1828         } else {
1829                 if (subs_map_client_interface_added_id != -1) {
1830                         g_dbus_connection_signal_unsubscribe(conn,
1831                                         subs_map_client_interface_added_id);
1832                         subs_map_client_interface_added_id = -1;
1833                 }
1834                 if (subs_map_client_interface_removed_id != -1) {
1835                         g_dbus_connection_signal_unsubscribe(conn,
1836                                         subs_map_client_interface_removed_id);
1837                         subs_map_client_interface_removed_id = -1;
1838                 }
1839                 if (subs_map_client_property_id != -1) {
1840                         g_dbus_connection_signal_unsubscribe(conn,
1841                                         subs_map_client_property_id);
1842                         subs_map_client_property_id = -1;
1843                 }
1844         }
1845         return 0;
1846 }
1847
1848
1849 int _bt_register_service_event(GDBusConnection *g_conn, int event_type)
1850 {
1851         BT_DBG("+");
1852
1853         retv_if(g_conn == NULL, BLUETOOTH_ERROR_INTERNAL);
1854
1855         switch (event_type) {
1856         case BT_MANAGER_EVENT:
1857                 BT_DBG("BT_MANAGER_EVENT: register service event");
1858                 _bt_register_manager_subscribe_signal(g_conn, TRUE);
1859                 break;
1860         case BT_DEVICE_EVENT:
1861                 BT_DBG("BT_DEVICE_EVENT: register service event");
1862                 _bt_register_device_subscribe_signal(g_conn, TRUE);
1863                 break;
1864         case BT_OPP_SERVER_EVENT:
1865                 BT_DBG("BT_OPP_SERVER_EVENT: register service event");
1866                 _bt_register_opp_server_subscribe_signal(g_conn, TRUE);
1867                 break;
1868         case BT_OPP_CLIENT_EVENT:
1869                 BT_DBG("BT_OPP_CLIENT_EVENT: register service event");
1870                 _bt_register_opp_client_subscribe_signal(g_conn, TRUE);
1871                 break;
1872         case BT_MAP_CLIENT_EVENT:
1873                 BT_DBG("BT_MAP_CLIENT_EVENT: register service event");
1874                 _bt_register_map_client_subscribe_signal(g_conn, TRUE);
1875                 break;
1876         default:
1877                 BT_ERR("Unknown event");
1878                 return BLUETOOTH_ERROR_INTERNAL;
1879         }
1880
1881         return BLUETOOTH_ERROR_NONE;
1882 }
1883
1884 void _bt_unregister_service_event(GDBusConnection *g_conn, int event_type)
1885 {
1886         BT_DBG("+");
1887
1888         ret_if(g_conn == NULL);
1889
1890         switch (event_type) {
1891         case BT_MANAGER_EVENT:
1892                 _bt_register_manager_subscribe_signal(g_conn, FALSE);
1893                 _bt_register_device_subscribe_signal(g_conn, FALSE);
1894                 _bt_register_input_subscribe_signal(g_conn, FALSE);
1895                 break;
1896         case BT_OPP_SERVER_EVENT:
1897                 _bt_register_opp_server_subscribe_signal(g_conn, FALSE);
1898                 break;
1899         case BT_OPP_CLIENT_EVENT:
1900                 _bt_register_opp_client_subscribe_signal(g_conn, FALSE);
1901                 break;
1902         case BT_MAP_CLIENT_EVENT:
1903                 _bt_register_map_client_subscribe_signal(g_conn, FALSE);
1904                 break;
1905         default:
1906                 BT_ERR("Unknown event");
1907                 return;
1908         }
1909
1910         BT_DBG("-");
1911 }
1912
1913 static int __bt_init_manager_receiver(void)
1914 {
1915         BT_DBG("+");
1916
1917         GError *error = NULL;
1918
1919         if (manager_conn == NULL) {
1920                 manager_conn =  g_bus_get_sync(G_BUS_TYPE_SYSTEM, NULL, &error);
1921                 if (error != NULL) {
1922                         BT_ERR("ERROR: Can't get on system bus [%s]", error->message);
1923                         g_clear_error(&error);
1924                 }
1925                 retv_if(manager_conn == NULL, BLUETOOTH_ERROR_INTERNAL);
1926         }
1927
1928         if (_bt_register_service_event(manager_conn,
1929                                 BT_MANAGER_EVENT) != BLUETOOTH_ERROR_NONE)
1930                 goto fail;
1931
1932         if (_bt_register_service_event(manager_conn,
1933                                 BT_DEVICE_EVENT) != BLUETOOTH_ERROR_NONE)
1934                 goto fail;
1935
1936         return BLUETOOTH_ERROR_NONE;
1937 fail:
1938         if (manager_conn) {
1939                 g_object_unref(manager_conn);
1940                 manager_conn = NULL;
1941         }
1942
1943         BT_DBG("-");
1944
1945         return BLUETOOTH_ERROR_INTERNAL;
1946 }
1947
1948 static int __bt_init_obexd_receiver(void)
1949 {
1950         BT_DBG("+");
1951         if (!TIZEN_PROFILE_TV) { /* TODO: obexd doesn't work in TV profile. It should be resolved later. */
1952                 GError *error = NULL;
1953
1954                 if (obexd_conn == NULL) {
1955                         obexd_conn = g_bus_get_sync(G_BUS_TYPE_SYSTEM, NULL, &error);
1956                         if (error != NULL) {
1957                                 BT_ERR("ERROR: Can't get on session bus [%s]", error->message);
1958                                 g_clear_error(&error);
1959                         }
1960                         retv_if(obexd_conn == NULL, BLUETOOTH_ERROR_INTERNAL);
1961                 }
1962
1963                 if (_bt_register_service_event(obexd_conn,
1964                                         BT_OPP_SERVER_EVENT) != BLUETOOTH_ERROR_NONE) {
1965                         BT_ERR("Error while registering service event");
1966                         g_object_unref(obexd_conn);
1967                         obexd_conn = NULL;
1968                         return BLUETOOTH_ERROR_INTERNAL;
1969                 }
1970         }
1971
1972         BT_DBG("-");
1973
1974         return BLUETOOTH_ERROR_NONE;
1975 }
1976
1977 gboolean __bt_reinit_obexd_receiver(gpointer user_data)
1978 {
1979         static int retry_cnt = 0;
1980         int result = BLUETOOTH_ERROR_NONE;
1981
1982         BT_DBG("+");
1983
1984         result = __bt_init_obexd_receiver();
1985         if (result != BLUETOOTH_ERROR_NONE) {
1986                 /* 20 ms * 50 = 10 seconds. During 10 seconds fail to initialize,
1987                    then it is not the timing issue. Just can't use the session bus connection */
1988                 if (retry_cnt > 100) {
1989                         BT_ERR("Fail to init obexd receiver by 50 times.");
1990                         retry_cnt = 0;
1991                         session_reinit_timer = 0;
1992                         return FALSE;
1993                 }
1994                 retry_cnt++;
1995                 BT_DBG("Retry to initialize the obexd receiver");
1996                 return TRUE;
1997         }
1998
1999         retry_cnt = 0;
2000         session_reinit_timer = 0;
2001
2002         BT_DBG("-");
2003
2004         return FALSE;
2005 }
2006
2007 /* To receive the event from bluez */
2008 int _bt_init_obex_event_receiver(void)
2009 {
2010         BT_DBG("+");
2011
2012         int result;
2013
2014         result = __bt_init_manager_receiver();
2015         retv_if(result != BLUETOOTH_ERROR_NONE, result);
2016
2017         result = __bt_init_obexd_receiver();
2018         if (result != BLUETOOTH_ERROR_NONE) {
2019                 BT_ERR("Fail to init obexd receiver");
2020
2021                 /* Try to re-initialize obexd receiver in the timer */
2022                 if (session_reinit_timer > 0)
2023                         g_source_remove(session_reinit_timer);
2024
2025                 session_reinit_timer = g_timeout_add(200,
2026                                                         (GSourceFunc)__bt_reinit_obexd_receiver, NULL);
2027         }
2028
2029         BT_DBG("-");
2030
2031         return BLUETOOTH_ERROR_NONE;
2032 }
2033
2034 void _bt_deinit_obex_event_receiver(void)
2035 {
2036         BT_DBG("+");
2037
2038         _bt_unregister_service_event(manager_conn, BT_MANAGER_EVENT);
2039
2040         _bt_unregister_service_event(obexd_conn, BT_OPP_SERVER_EVENT);
2041
2042         if (manager_conn) {
2043                 g_object_unref(manager_conn);
2044                 manager_conn = NULL;
2045         }
2046
2047         if (obexd_conn) {
2048                 g_object_unref(obexd_conn);
2049                 obexd_conn = NULL;
2050         }
2051
2052         if (event_id > 0)
2053                 g_source_remove(event_id);
2054         event_id = 0;
2055
2056         BT_DBG("-");
2057 }
2058