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 guint event_id;
  49
  50 static guint session_reinit_timer;
  51
  52 /**
  53  * obexd connection type
  54  */
  55 typedef enum {
  56         OBEX_OPP = (1 << 1),
  57         OBEX_FTP = (1 << 2),
  58         OBEX_BIP = (1 << 3),
  59         OBEX_PBAP = (1 << 4),
  60         OBEX_IRMC = (1 << 5),
  61         OBEX_PCSUITE = (1 << 6),
  62         OBEX_SYNCEVOLUTION = (1 << 7),
  63         OBEX_MAS = (1 << 8),
  64         OBEX_MAP = (1 << 9),
  65 } bluetooth_obex_connection_type_t;
  66
  67
  68 void _bt_handle_property_changed_event(GVariant *msg, const char *object_path);
  69 void _bt_opc_property_changed_event(GVariant *msg, char *path);
  70 void _bt_map_property_changed_event(GVariant *msg, const char *path);
  71 int _bt_register_service_event(GDBusConnection *g_conn, int event_type);
  72 void _bt_unregister_service_event(GDBusConnection *g_conn, int event_type);
  73 void _bt_opp_client_event_deinit(void);
  74 void _bt_map_client_event_deinit(void);
  75 void _bt_map_on_transfer_finished(const char *transfer_object_path, const int error);
  76
  77 /* Temp Adapter changes required to make OBEX work for handling device events here ,
  78    This code will be removed and moved to OAL Event Handling part .
  79 */
  80
  81 #if 0
  82 static void __bt_get_uuids(GVariant *value, bt_remote_dev_info_t *info)
  83 {
  84         ret_if(value == NULL);
  85         ret_if(info == NULL);
  86
  87         gsize uuid_count = 0;
  88
  89         info->uuids = g_variant_dup_strv(value, &uuid_count);
  90         info->uuid_count = (unsigned int)uuid_count;
  91
  92         BT_DBG("uuid count : %d", uuid_count);
  93 }
  94 #endif
  95
  96 void _bt_convert_addr_string_to_secure_string(char *addr,
  97                                         const char *address)
  98 {
  99         int len;
 100
 101         ret_if(address == NULL);
 102         ret_if(addr == NULL);
 103
 104         len = strlen(address);
 105         ret_if(len != BT_ADDRESS_STRING_SIZE - 1);
 106
 107         strncpy(addr, address, len);
 108         addr[len] = '\0';
 109
 110         addr[len-7] = 'X';
 111         addr[len-8] = 'X';
 112         addr[len-10] = 'X';
 113         addr[len-11] = 'X';
 114         addr[len-13] = 'X';
 115         addr[len-14] = 'X';
 116         addr[len-16] = 'X';
 117         addr[len-17] = 'X';
 118
 119         return;
 120 }
 121
 122 bt_status_t _bt_adapter_get_status_for_Obex(void)
 123 {
 124         int value = VCONFKEY_BT_STATUS_OFF;
 125
 126         /* check VCONFKEY_BT_STATUS */
 127         if (vconf_get_int(VCONFKEY_BT_STATUS, &value) != 0) {
 128                 BT_ERR("fail to get vconf key!");
 129                 return BLUETOOTH_ADAPTER_DISABLED;
 130         }
 131
 132         return value;
 133 }
 134
 135 static int __bt_get_owner_info(GVariant *msg, char **name,
 136                                 char **previous, char **current)
 137 {
 138         g_variant_get(msg, "(&s&s&s)", name, previous, current);
 139         return BLUETOOTH_ERROR_NONE;
 140 }
 141
 142 static int __bt_get_agent_signal_info(GVariant *msg, char **address,
 143                                 char **name, char **uuid)
 144 {
 145         g_variant_get(msg, "(&s&s&s)", address, name, uuid);
 146         return BLUETOOTH_ERROR_NONE;
 147 }
 148
 149 gboolean __bt_handle_is_flight_mode_enabled(void)
 150 {
 151         if (TIZEN_FEATURE_FLIGHTMODE_ENABLED) {
 152                 int is_flight_mode = 0;
 153                 int ret = -1;
 154                 ret = vconf_get_bool(VCONFKEY_TELEPHONY_FLIGHT_MODE, &is_flight_mode);
 155                 if (ret != 0)
 156                         BT_ERR("vconf_get_bool failed");
 157
 158                 return (is_flight_mode == 0) ? FALSE : TRUE;
 159         } else {
 160                 return FALSE;
 161         }
 162 }
 163
 164 void _bt_handle_adapter_event(GVariant *msg, const char *member)
 165 {
 166         BT_DBG("+");
 167         ret_if(member == NULL);
 168
 169         if (strcasecmp(member, "DeviceCreated") == 0) {
 170                 char *object_path = NULL;
 171                 char *address;
 172                 ret_if(_bt_is_device_creating() == FALSE);
 173
 174                 /* Bonding from remote device */
 175                 address = g_malloc0(BT_ADDRESS_STRING_SIZE);
 176
 177                 g_variant_get(msg, "(&o)", &object_path);
 178                 _bt_convert_device_path_to_address((const char*)object_path, address);
 179
 180                 g_free(address);
 181         } else if (strcasecmp(member, BT_HARDWARE_ERROR) == 0) {
 182                 BT_ERR_C("### Hardware error received from BLUEZ");
 183         } else if (strcasecmp(member, BT_TX_TIMEOUT_ERROR) == 0) {
 184                 BT_ERR_C("### Tx timeout error received from BLUEZ");
 185         }
 186         BT_DBG("-");
 187 }
 188
 189 static void __bt_obex_property_changed_event(GVariant *msg, const char *path)
 190 {
 191         BT_DBG("+");
 192
 193         GVariantIter value_iter;
 194         GVariant *child = NULL, *val = NULL;
 195         char *property = NULL;
 196         g_variant_iter_init(&value_iter, msg);
 197         while ((child = g_variant_iter_next_value(&value_iter))) {
 198                 g_variant_get(child, "{sv}", &property, &val);
 199
 200                 ret_if(property == NULL);
 201
 202                 BT_DBG("property :%s", property);
 203
 204                 if (strcasecmp(property, "Status") == 0) {
 205                         char  *status;
 206                         g_variant_get(val, "s", &status);
 207
 208                         if (strcasecmp(status, "active") == 0) {
 209                                 _bt_obex_transfer_started(path);
 210                         } else if (strcasecmp(status, "complete") == 0) {
 211                                 _bt_obex_transfer_completed(path, TRUE);
 212                                 _bt_pbap_obex_transfer_completed(path, TRUE);
 213                         } else if (strcasecmp(status, "error") == 0) {
 214                                 _bt_obex_transfer_completed(path, FALSE);
 215                                 _bt_pbap_obex_transfer_completed(path, FALSE);
 216                         }
 217                         g_free(status);
 218                 } else if (strcasecmp(property, "Transferred") == 0) {
 219                         guint64 transferred  = 0;
 220                         /* As Transferred is expected guint64 so change int to guint64 and
 221                          * eariler transferred is static because of it can overwrite data
 222                          * on present on opc_obex_conn or obexd_conn as these are
 223                          * static memory are in sequential */
 224                         g_variant_get(val, "t", &transferred);
 225
 226                         _bt_obex_transfer_progress(path, transferred);
 227                 }
 228                 /* TODO: MAP, "Complete"? see above */
 229                 g_free(property);
 230                 g_variant_unref(val);
 231                 g_variant_unref(child);
 232         }
 233         BT_DBG("-");
 234 }
 235
 236 void _bt_handle_property_changed_event(GVariant *msg, const char *object_path)
 237 {
 238         char *interface_name = NULL;
 239         GVariant *val = NULL;
 240
 241         g_variant_get(msg, "(&s@a{sv}@as)", &interface_name, &val, NULL);
 242         BT_DBG("_bt_handle_property_changed_event");
 243
 244         if (strcasecmp(interface_name, BT_ADAPTER_INTERFACE) == 0) {
 245                 gboolean ret = FALSE;
 246                 gboolean powered = FALSE;
 247
 248                 /* Check if Adapter is disabled, cancle queued transfers if any */
 249                 ret = g_variant_lookup(msg, "Powered", "b", &powered);
 250                 if (ret && !powered)
 251                         _bt_cancel_queued_transfers();
 252         } else if (strcasecmp(interface_name, BT_OBEX_TRANSFER_INTERFACE) == 0) {
 253                 BT_DBG("BT_OBEX_TRANSFER_INTERFACE");
 254                 __bt_obex_property_changed_event(val,
 255                                         object_path);
 256         }
 257         g_variant_unref(val);
 258 }
 259
 260 void __bt_opc_property_changed_event(GVariant *msg,
 261                                                 const char *path)
 262 {
 263         GVariantIter value_iter;
 264         char *property = NULL;
 265         GVariant *val = NULL;
 266         GVariant *child = NULL;
 267
 268         g_variant_iter_init(&value_iter, msg);
 269         if ((child = g_variant_iter_next_value(&value_iter))) {
 270                 g_variant_get(child, "{sv}", &property, &val);
 271                 ret_if(property == NULL);
 272
 273                 if (strcasecmp(property, "Status") == 0) {
 274                         char *status = NULL;
 275                         g_variant_get(val, "s", &status);
 276                         BT_DBG("Status is %s", status);
 277
 278                         if (strcasecmp(status, "active") == 0)
 279                                 _bt_obex_client_started(path);
 280                         else if (strcasecmp(status, "complete") == 0)
 281                                 _bt_obex_client_completed(path, TRUE);
 282                         else if (strcasecmp(status, "error") == 0)
 283                                 _bt_obex_client_completed(path, FALSE);
 284
 285                         g_free(status);
 286                 } else if (strcasecmp(property, "Transferred") == 0) {
 287                         guint64 transferred  = 0;
 288                         g_variant_get(val, "t", &transferred);
 289
 290                         _bt_obex_client_progress(path, transferred);
 291                 } else {
 292                         BT_DBG("property : [%s]", property);
 293                 }
 294                 g_free(property);
 295                 g_variant_unref(child);
 296                 g_variant_unref(val);
 297         }
 298 }
 299
 300 void _bt_opc_property_changed_event(GVariant *msg, char *path)
 301 {
 302         char *interface_name = NULL;
 303         GVariant *value = NULL;
 304         g_variant_get(msg, "(&s@a{sv}@as)", &interface_name, &value, NULL);
 305         BT_INFO("interface_name = %s", interface_name);
 306         if (strcasecmp(interface_name, BT_OBEX_TRANSFER_INTERFACE) == 0) {
 307                 __bt_opc_property_changed_event(value,
 308                                         path);
 309         } else {
 310                 BT_DBG("interface_name : [%s]", interface_name);
 311         }
 312         g_variant_unref(value);
 313 }
 314
 315
 316 void __bt_map_property_changed_event(GVariant *msg,
 317                                                 const char *path)
 318 {
 319         BT_DBG("Entered");
 320         GVariantIter value_iter;
 321         char *property = NULL;
 322         GVariant *val = NULL;
 323         GVariant *child = NULL;
 324
 325         g_variant_iter_init(&value_iter, msg);
 326         while ((child = g_variant_iter_next_value(&value_iter))) {
 327                 g_variant_get(child, "{sv}", &property, &val);
 328                 ret_if(property == NULL);
 329
 330                 if (strcasecmp(property, "Status") == 0) {
 331                         char *status = NULL;
 332                         g_variant_get(val, "s", &status);
 333                         BT_DBG("Status is %s", status);
 334
 335                         if (strcasecmp(status, "active") == 0) {
 336                                 BT_DBG("EVENT : STARTED");
 337                                 // currently doing nothing
 338                         } else if (strcasecmp(status, "complete") == 0) {
 339                                 BT_DBG("EVENT : COMPLETED");
 340                                 _bt_map_on_transfer_finished(path, BLUETOOTH_ERROR_NONE);
 341                         } else if (strcasecmp(status, "error") == 0) {
 342                                 BT_DBG("EVENT : FAILED");
 343                                 _bt_map_on_transfer_finished(path, BLUETOOTH_ERROR_INTERNAL);
 344                         }
 345                         g_free(status);
 346                 } else if (strcasecmp(property, "Transferred") == 0) {
 347                         guint64 transferred  = 0;
 348                         g_variant_get(val, "t", &transferred);
 349
 350                         BT_DBG("EVENT : PROGRESS CALLBACK");
 351                         // currently doing nothing - progress callback type is not used
 352                 } else {
 353                         BT_DBG("OTHER EVENT : property : [%s]", property);
 354                 }
 355                 g_free(property);
 356                 g_variant_unref(child);
 357                 g_variant_unref(val);
 358         }
 359 }
 360
 361 void _bt_map_property_changed_event(GVariant *msg, const char *path)
 362 {
 363         BT_DBG("Entered _bt_map_property_changed_event");
 364         char *interface_name = NULL;
 365         GVariant *value = NULL;
 366         g_variant_get(msg, "(&s@a{sv}@as)", &interface_name, &value, NULL);
 367         BT_INFO("interface_name = %s", interface_name);
 368         if (strcasecmp(interface_name, BT_OBEX_TRANSFER_INTERFACE) == 0) {
 369                 __bt_map_property_changed_event(value,
 370                                 path);
 371         } else {
 372                 BT_DBG("interface_name : [%s]", interface_name);
 373         }
 374         g_variant_unref(value);
 375 }
 376
 377
 378 void _bt_handle_agent_event(GVariant *msg, const char *member)
 379 {
 380         int result = BLUETOOTH_ERROR_NONE;
 381         char *address = NULL;
 382         char *name = NULL;
 383         char *uuid = NULL;
 384         GVariant *param = NULL;
 385         ret_if(member == NULL);
 386
 387         if (strcasecmp(member, "ObexAuthorize") == 0) {
 388                 __bt_get_agent_signal_info(msg, &address, &name, &uuid);
 389                 param = g_variant_new("(iss)", result, address, name);
 390                 _bt_send_event(BT_OPP_SERVER_EVENT,
 391                         BLUETOOTH_EVENT_OBEX_SERVER_CONNECTION_AUTHORIZE,
 392                         param);
 393                 /* TODO: MAP? see above */
 394         }
 395 }
 396
 397 static int __bt_get_object_path(GVariant *msg, char **path)
 398 {
 399         g_variant_get(msg, "(o*)", path, NULL);
 400         if (*path == NULL)
 401                 return BLUETOOTH_ERROR_INTERNAL;
 402
 403         return BLUETOOTH_ERROR_NONE;
 404 }
 405
 406 char *_bt_get_bonded_device_name(char *address)
 407 {
 408         bt_remote_dev_info_t *dev_info;
 409
 410         retv_if(address == NULL, strdup(""));
 411
 412         dev_info = _bt_service_get_remote_dev_info(address);
 413         retv_if(dev_info == NULL, strdup(""));
 414         retv_if(dev_info->name == NULL, strdup(""));
 415
 416         return g_strdup(dev_info->name);
 417 }
 418 /* Temp Adapter Util changes to make OBEX work.
 419 */
 420
 421 void _bt_handle_device_event(GVariant *msg, const char *member, const char *path)
 422 {
 423         char *address;
 424         ret_if(path == NULL);
 425
 426         if (strcasecmp(member, "Disconnected") == 0) {
 427                 unsigned char disc_reason = 0;
 428                 unsigned char addr_type = 0;
 429                 char *dev_name = NULL;
 430                 gboolean sending = FALSE;
 431
 432                 g_variant_get(msg, "(yys)", &addr_type, &disc_reason, &dev_name);
 433
 434                 address = g_malloc0(BT_ADDRESS_STRING_SIZE);
 435
 436                 _bt_convert_device_path_to_address(path, address);
 437
 438                 if (!addr_type) {
 439                         /*Check for any OPP transfer on the device and cancel
 440                          * the transfer
 441                          */
 442                         _bt_obex_check_pending_transfer(address);
 443                         _bt_opp_client_is_sending(&sending);
 444                         if (sending == TRUE)
 445                                 _bt_opp_client_check_pending_transfer(address);
 446                         /* TODO: MAP? see above */
 447                 }
 448                 g_free(address);
 449                 g_free(dev_name);
 450         }
 451 }
 452
 453 static  void __bt_manager_event_filter(GDBusConnection *connection,
 454                                         const gchar *sender_name,
 455                                         const gchar *object_path,
 456                                         const gchar *interface_name,
 457                                         const gchar *signal_name,
 458                                         GVariant *parameters,
 459                                         gpointer user_data)
 460 {
 461
 462         GVariant *value;
 463         char *obj_path = NULL;
 464
 465         if (signal_name == NULL)
 466                 return;
 467
 468         if (strcasecmp(signal_name, "InterfacesAdded") == 0) {
 469                 g_variant_get(parameters, "(&o@a{sa{sv}})", &obj_path, &value);
 470
 471                 if (strcasecmp(obj_path, BT_BLUEZ_HCI_PATH) == 0)
 472                         if (TIZEN_FEATURE_OPP_SUPPORTED) {
 473                                 if (_bt_register_obex_server() != BLUETOOTH_ERROR_NONE)
 474                                         BT_ERR("Fail to init obex server");
 475                         }
 476                 g_variant_unref(value);
 477         } else if (strcasecmp(signal_name, "InterfacesRemoved") == 0) {
 478                         if (TIZEN_FEATURE_OPP_SUPPORTED) {
 479                                 if (_bt_unregister_obex_server() != BLUETOOTH_ERROR_NONE)
 480                                         BT_ERR("Fail to unregister obex server");
 481                         }
 482         } else if (strcasecmp(signal_name, "NameOwnerChanged") == 0) {
 483                 gboolean value;
 484                 char *name = NULL;
 485                 char *previous = NULL;
 486                 char *current = NULL;
 487
 488                 if (g_strcmp0(g_variant_get_type_string(parameters), "(sss)") != 0) {
 489                         BT_ERR("Invalid variant format");
 490                         return;
 491                 }
 492
 493                 if (__bt_get_owner_info(parameters, &name, &previous, &current)) {
 494                         BT_ERR("Fail to get the owner info");
 495                         return;
 496                 }
 497
 498                 if (*current != '\0')
 499                         return;
 500
 501                 if (name == NULL)
 502                         return;
 503
 504                 if (strcasecmp(name, BT_BLUEZ_NAME) == 0) {
 505                         BT_INFO_C("### Bluetoothd is terminated");
 506
 507                         if (_bt_unregister_obex_server() != BLUETOOTH_ERROR_NONE)
 508                                 BT_ERR("Fail to unregister obex server");
 509
 510                 }
 511
 512                 _bt_obex_server_check_allocation(&value);
 513
 514                 if (value == TRUE) {
 515                         /* Check if the obex server was terminated abnormally */
 516                         _bt_obex_server_check_termination(name);
 517                 }
 518         } else if (g_strcmp0(interface_name, BT_AGENT_INTERFACE) == 0) {
 519                 _bt_handle_agent_event(parameters, signal_name);
 520         } else if (g_strcmp0(interface_name, BT_DEVICE_INTERFACE) == 0) {
 521                 _bt_handle_device_event(parameters, signal_name, object_path);
 522         }
 523
 524         return;
 525 }
 526
 527 static gboolean __bt_is_obexd_event(GVariant *msg, const char *interface)
 528 {
 529
 530         if (g_strcmp0(interface, BT_PROPERTIES_INTERFACE) == 0) {
 531                 char *interface_name = NULL;
 532
 533                 g_variant_get(msg, "(&s@a{sv}@as)", &interface_name, NULL, NULL);
 534                 retv_if(interface_name == NULL, FALSE);
 535
 536                 if (strcasecmp(interface_name, BT_OBEX_TRANSFER_INTERFACE) == 0) {
 537                         BT_DBG("BT_OBEX_TRANSFER_INTERFACE");
 538                         return TRUE;
 539                 }
 540         }
 541
 542         return FALSE;
 543 }
 544
 545 static  void __bt_obexd_event_filter(GDBusConnection *connection,
 546                                         const gchar *sender_name,
 547                                         const gchar *object_path,
 548                                         const gchar *interface_name,
 549                                         const gchar *signal_name,
 550                                         GVariant *parameters,
 551                                         gpointer user_data)
 552 {
 553         const char *member = signal_name;
 554         char *obj_path = NULL;
 555         ret_if(member == NULL);
 556
 557         if (strcasecmp(member, "InterfacesAdded") == 0) {
 558                 if (__bt_get_object_path(parameters, &obj_path)) {
 559                         BT_ERR("Fail to get the path");
 560                         return;
 561                 }
 562
 563                 /*Handle OPP_SERVER_CONNECTED_EVENT here */
 564                 /* TODO: MAP? see above */
 565                 if (strncmp(obj_path, BT_SESSION_BASEPATH_SERVER,
 566                                 strlen(BT_SESSION_BASEPATH_SERVER)) != 0) {
 567                         g_free(obj_path);
 568                         return;
 569                 }
 570
 571                 if (g_strrstr(obj_path, "session") && g_strrstr(obj_path, "transfer")) {
 572                         BT_DBG("Obex_Server_Session_Transfer connected");
 573                         _bt_obex_transfer_connected(obj_path);
 574                 }
 575                 g_free(obj_path);
 576         } else if (strcasecmp(member, "InterfacesRemoved") == 0) {
 577                 /*Handle OPP_SERVER_DISCONNECTED_EVENT here */
 578                 /* TODO: MAP? see above */
 579                 if (__bt_get_object_path(parameters, &obj_path)) {
 580                         BT_ERR("Fail to get the path");
 581                         return;
 582                 }
 583
 584                 if (strncmp(obj_path, BT_SESSION_BASEPATH_CLIENT,
 585                                 strlen(BT_SESSION_BASEPATH_CLIENT)) == 0) {
 586                         BT_DBG("Call PBAP Disconnected");
 587                         _bt_obex_pbap_client_disconnect(obj_path);
 588                 }
 589
 590                 if (strncmp(obj_path, BT_SESSION_BASEPATH_SERVER,
 591                                 strlen(BT_SESSION_BASEPATH_SERVER)) != 0) {
 592                         g_free(obj_path);
 593                         return;
 594                 }
 595
 596                 if (g_strrstr(obj_path, "session") && g_strrstr(obj_path, "transfer")) {
 597                         BT_DBG("Obex_Server_Session_Transfer disconnected %s",
 598                                                                 obj_path);
 599
 600                         _bt_obex_transfer_disconnected(obj_path);
 601                 }
 602                 g_free(obj_path);
 603         } else if (__bt_is_obexd_event(parameters, interface_name) == TRUE) {
 604                 const char *path = object_path;
 605
 606                 if (strncmp(path, BT_SESSION_BASEPATH_SERVER,
 607                                 strlen(BT_SESSION_BASEPATH_SERVER)) != 0 &&
 608                         strncmp(path, BT_SESSION_BASEPATH_CLIENT,
 609                                 strlen(BT_SESSION_BASEPATH_CLIENT)) != 0) {
 610                         BT_DBG("DBUS_HANDLER_RESULT_NOT_YET_HANDLED");
 611                         return;
 612                 }
 613
 614                 _bt_handle_property_changed_event(parameters, path);
 615         }
 616         return;
 617 }
 618
 619 static gboolean __bt_is_obexd_client_event(GVariant *msg, const char *interface)
 620 {
 621         BT_DBG("+");
 622
 623         if (g_strcmp0(interface, BT_PROPERTIES_INTERFACE) == 0) {
 624                 char *interface_name = NULL;
 625
 626                 g_variant_get(msg, "(&s@a{sv}@as)", &interface_name, NULL, NULL);
 627
 628                 retv_if(interface_name == NULL, FALSE);
 629
 630                 if (strcasecmp(interface_name,
 631                                         BT_OBEX_TRANSFER_INTERFACE) == 0) {
 632                         BT_DBG("-");
 633                         return TRUE;
 634                 }
 635         }
 636
 637         BT_DBG("-");
 638
 639         return FALSE;
 640 }
 641
 642 static  void __bt_opc_event_filter(GDBusConnection *connection,
 643                                         const gchar *sender_name,
 644                                         const gchar *object_path,
 645                                         const gchar *interface_name,
 646                                         const gchar *signal_name,
 647                                         GVariant *parameters,
 648                                         gpointer user_data)
 649 {
 650         const char *member = signal_name;
 651         char *obj_path = NULL;
 652         if (strcasecmp(member, "InterfacesAdded") == 0) {
 653                 BT_DBG("InterfacesAdded");
 654         } else if (strcasecmp(member, "InterfacesRemoved") == 0) {
 655
 656                 if (__bt_get_object_path(parameters, &obj_path)) {
 657                         BT_ERR("Fail to get the path");
 658                         return;
 659                 }
 660
 661                 BT_DBG("object_path = %s", obj_path);
 662
 663                 if (strncmp(obj_path, BT_SESSION_BASEPATH_CLIENT,
 664                                 strlen(BT_SESSION_BASEPATH_CLIENT)) != 0
 665                                 || strstr(obj_path, "transfer") == NULL) {
 666                         g_free(obj_path);
 667                         return;
 668                 } else if (strncmp(obj_path, BT_SESSION_BASEPATH_CLIENT,
 669                                 strlen(BT_SESSION_BASEPATH_CLIENT)) == 0) {
 670                         BT_DBG("Going to call opc disconnected");
 671                         _bt_opc_disconnected(obj_path);
 672                 }
 673
 674                 _bt_sending_files();
 675                 g_free(obj_path);
 676         } else if (__bt_is_obexd_client_event(parameters, interface_name) == TRUE) {
 677                 char *path = (char *)object_path;
 678                 BT_INFO("object_path %s", path);
 679                 if (strncmp(path, BT_SESSION_BASEPATH_CLIENT,
 680                         strlen(BT_SESSION_BASEPATH_CLIENT)) != 0) {
 681                         BT_DBG("NOT BT_SESSION_BASEPATH_CLIENT");
 682                         return;
 683                 }
 684
 685                 _bt_opc_property_changed_event(parameters, path);
 686         }
 687
 688         return;
 689 }
 690
 691 int _bt_opp_client_event_init(void)
 692 {
 693         GError *error = NULL;
 694
 695         if (opc_obexd_conn == NULL) {
 696                 opc_obexd_conn = g_bus_get_sync(G_BUS_TYPE_SYSTEM, NULL, &error);
 697
 698                 if (!opc_obexd_conn) {
 699                         if (error) {
 700                                 BT_ERR("Unable to connect to dbus: %s", error->message);
 701                                 g_clear_error(&error);
 702                         }
 703                 return BLUETOOTH_ERROR_INTERNAL;
 704                 }
 705         }
 706
 707         if (_bt_register_service_event(opc_obexd_conn,
 708                         BT_OPP_CLIENT_EVENT) != BLUETOOTH_ERROR_NONE) {
 709                         g_object_unref(opc_obexd_conn);
 710                         opc_obexd_conn = NULL;
 711                         return BLUETOOTH_ERROR_INTERNAL;
 712         }
 713
 714         return BLUETOOTH_ERROR_NONE;
 715 }
 716
 717 void _bt_opp_client_event_deinit(void)
 718 {
 719         if (opc_obexd_conn) {
 720                 _bt_unregister_service_event(opc_obexd_conn,
 721                                                 BT_OPP_CLIENT_EVENT);
 722                  g_object_unref(opc_obexd_conn);
 723                  opc_obexd_conn = NULL;
 724         }
 725 }
 726
 727 static  void __bt_map_event_filter(GDBusConnection *connection,
 728                                         const gchar *sender_name,
 729                                         const gchar *object_path,
 730                                         const gchar *interface_name,
 731                                         const gchar *signal_name,
 732                                         GVariant *parameters,
 733                                         gpointer user_data)
 734 {
 735         BT_DBG("Entered __bt_map_event_filter");
 736         const char *member = signal_name;
 737
 738         if (strcasecmp(member, "InterfacesAdded") == 0) {
 739                 BT_DBG("------------------------------------ADDED------------------------------------");
 740                 // currently doing nothing
 741         } else if (strcasecmp(member, "InterfacesRemoved") == 0) {
 742                 BT_DBG("------------------------------------REMOVED------------------------------------");
 743                 // TODO check if something should be called here?
 744                 //_bt_map_on_transfer_finished(object_path, error);
 745         } else if (__bt_is_obexd_client_event(parameters, interface_name) == TRUE) {
 746                 BT_DBG("------------------------------------CLIENT EVENT------------------------------------");
 747                 _bt_map_property_changed_event(parameters, object_path);
 748         }
 749
 750         return;
 751 }
 752
 753 int _bt_map_client_event_init(void)
 754 {
 755         GError *error = NULL;
 756
 757         if (map_obexd_conn == NULL) {
 758                 map_obexd_conn = g_bus_get_sync(G_BUS_TYPE_SYSTEM, NULL, &error);
 759
 760                 if (!map_obexd_conn) {
 761                         if (error) {
 762                                 BT_ERR("Unable to connect to dbus: %s", error->message);
 763                                 g_clear_error(&error);
 764                         }
 765                 return BLUETOOTH_ERROR_INTERNAL;
 766                 }
 767         }
 768
 769         if (_bt_register_service_event(map_obexd_conn,
 770                         BT_MAP_CLIENT_EVENT) != BLUETOOTH_ERROR_NONE) {
 771                         g_object_unref(map_obexd_conn);
 772                         map_obexd_conn = NULL;
 773                         return BLUETOOTH_ERROR_INTERNAL;
 774         }
 775
 776         return BLUETOOTH_ERROR_NONE;
 777 }
 778
 779 void _bt_map_client_event_deinit(void)
 780 {
 781         if (map_obexd_conn) {
 782                 _bt_unregister_service_event(map_obexd_conn,
 783                                                 BT_MAP_CLIENT_EVENT);
 784                  g_object_unref(map_obexd_conn);
 785                  map_obexd_conn = NULL;
 786         }
 787 }
 788
 789 #ifdef TIZEN_FEATURE_BT_PERMANENT_LOG
 790 static void __bt_dump_event_filter(GDBusConnection *connection,
 791                                         const gchar *sender_name,
 792                                         const gchar *object_path,
 793                                         const gchar *interface_name,
 794                                         const gchar *signal_name,
 795                                         GVariant *parameters,
 796                                         gpointer user_data)
 797 {
 798         if (strcasecmp(signal_name, BT_DUMP_SERVICE_SIGNAL) == 0) {
 799                 gchar *path = NULL;
 800                 int mode = 0;
 801
 802                 g_variant_get(parameters, "(i&s)", &mode, &path);
 803                 _bt_start_log_dump(path);
 804         }
 805
 806         return;
 807 }
 808
 809 static int __bt_register_dump_subscribe_signal(GDBusConnection *conn,
 810                 gboolean subscribe)
 811 {
 812         if (conn == NULL)
 813                 return -1;
 814
 815         static guint subs_source_id = 0;
 816
 817         if (subscribe) {
 818                 if (subs_source_id == 0) {
 819                         subs_source_id = g_dbus_connection_signal_subscribe(conn,
 820                                 NULL, BT_DUMP_SERVICE_INTERFACE,
 821                                 BT_DUMP_SERVICE_SIGNAL, BT_DUMP_SERVICE_PATH, NULL, 0,
 822                                 __bt_dump_event_filter,
 823                                 NULL, NULL);
 824                 }
 825         } else {
 826                 if (subs_source_id > 0) {
 827                         g_dbus_connection_signal_unsubscribe(conn,
 828                                         subs_source_id);
 829                         subs_source_id = 0;
 830                 }
 831         }
 832         return 0;
 833 }
 834 #endif
 835
 836 int _bt_register_manager_subscribe_signal(GDBusConnection *conn,
 837                 int subscribe)
 838 {
 839         if (conn == NULL)
 840                 return -1;
 841
 842         static int subs_interface_added_id = -1;
 843         static int subs_interface_removed_id = -1;
 844         static int subs_name_owner_changed = -1;
 845
 846         if (subscribe) {
 847                 if (subs_interface_added_id == -1) {
 848                         subs_interface_added_id = g_dbus_connection_signal_subscribe(conn,
 849                                 NULL, BT_MANAGER_INTERFACE,
 850                                 BT_INTERFACES_ADDED, NULL, NULL, 0,
 851                                 __bt_manager_event_filter,
 852                                 NULL, NULL);
 853                 }
 854                 if (subs_interface_removed_id == -1) {
 855                         subs_interface_removed_id = g_dbus_connection_signal_subscribe(conn,
 856                                 NULL, BT_MANAGER_INTERFACE,
 857                                 BT_INTERFACES_REMOVED, NULL, NULL, 0,
 858                                 __bt_manager_event_filter,
 859                                 NULL, NULL);
 860                 }
 861                 if (subs_name_owner_changed == -1) {
 862                         subs_name_owner_changed = g_dbus_connection_signal_subscribe(conn,
 863                                 NULL, BT_EVENT_FREEDESKTOP,
 864                                 BT_NAME_OWNER_CHANGED, NULL, NULL, 0,
 865                                 __bt_manager_event_filter, NULL, NULL);
 866                 }
 867
 868         } else {
 869                 if (subs_interface_added_id != -1) {
 870                         g_dbus_connection_signal_unsubscribe(conn,
 871                                         subs_interface_added_id);
 872                         subs_interface_added_id = -1;
 873                 }
 874                 if (subs_interface_removed_id != -1) {
 875                         g_dbus_connection_signal_unsubscribe(conn,
 876                                         subs_interface_removed_id);
 877                         subs_interface_removed_id = -1;
 878                 }
 879                 if (subs_name_owner_changed != -1) {
 880                         g_dbus_connection_signal_unsubscribe(conn,
 881                                         subs_name_owner_changed);
 882                         subs_name_owner_changed = -1;
 883                 }
 884
 885         }
 886         return 0;
 887 }
 888
 889 int _bt_register_device_subscribe_signal(GDBusConnection *conn,
 890                 int subscribe)
 891 {
 892         if (conn == NULL)
 893                 return -1;
 894
 895         static int subs_device_id = -1;
 896
 897         if (subscribe) {
 898                 if (subs_device_id == -1) {
 899                         subs_device_id = g_dbus_connection_signal_subscribe(conn,
 900                                 NULL, BT_DEVICE_INTERFACE,
 901                                 NULL, NULL, NULL, 0,
 902                                 __bt_manager_event_filter,
 903                                 NULL, NULL);
 904                 }
 905         } else {
 906                 if (subs_device_id != -1) {
 907                         g_dbus_connection_signal_unsubscribe(conn,
 908                                         subs_device_id);
 909                         subs_device_id = -1;
 910                 }
 911         }
 912         return 0;
 913 }
 914
 915 int _bt_register_input_subscribe_signal(GDBusConnection *conn,
 916                 int subscribe)
 917 {
 918         if (conn == NULL)
 919                 return -1;
 920
 921         static int subs_input_id = -1;
 922
 923         if (subscribe) {
 924                 if (subs_input_id == -1) {
 925                         subs_input_id = g_dbus_connection_signal_subscribe(conn,
 926                                 NULL, BT_INPUT_INTERFACE,
 927                                 NULL, NULL, NULL, 0,
 928                                 __bt_manager_event_filter,
 929                                 NULL, NULL);
 930                 }
 931         } else {
 932                 if (subs_input_id != -1) {
 933                         g_dbus_connection_signal_unsubscribe(conn,
 934                                         subs_input_id);
 935                         subs_input_id = -1;
 936                 }
 937         }
 938         return 0;
 939 }
 940
 941
 942
 943 int _bt_register_opp_server_subscribe_signal(GDBusConnection *conn,
 944                 int subscribe)
 945 {
 946         if (conn == NULL)
 947                 return -1;
 948
 949         static int subs_opp_server_interface_added_id = -1;
 950         static int subs_opp_server_interface_removed_id = -1;
 951         static int subs_opp_server_property_id = -1;
 952
 953
 954         if (subscribe) {
 955                 if (subs_opp_server_interface_added_id == -1) {
 956                         subs_opp_server_interface_added_id = g_dbus_connection_signal_subscribe(conn,
 957                                 NULL, BT_MANAGER_INTERFACE,
 958                                 BT_INTERFACES_ADDED, NULL, NULL, 0,
 959                                 __bt_obexd_event_filter,
 960                                 NULL, NULL);
 961                 }
 962                 if (subs_opp_server_interface_removed_id == -1) {
 963                         subs_opp_server_interface_removed_id = g_dbus_connection_signal_subscribe(conn,
 964                                 NULL, BT_MANAGER_INTERFACE,
 965                                 BT_INTERFACES_REMOVED, NULL, NULL, 0,
 966                                 __bt_obexd_event_filter,
 967                                 NULL, NULL);
 968                 }
 969                 if (subs_opp_server_property_id == -1) {
 970                         subs_opp_server_property_id = g_dbus_connection_signal_subscribe(conn,
 971                                 BT_OBEX_SERVICE_NAME, BT_PROPERTIES_INTERFACE,
 972                                 BT_PROPERTIES_CHANGED, NULL, NULL, 0,
 973                                 __bt_obexd_event_filter,
 974                                 NULL, NULL);
 975                 }
 976         } else {
 977                 if (subs_opp_server_interface_added_id != -1) {
 978                         g_dbus_connection_signal_unsubscribe(conn,
 979                                         subs_opp_server_interface_added_id);
 980                         subs_opp_server_interface_added_id = -1;
 981                 }
 982                 if (subs_opp_server_interface_removed_id != -1) {
 983                         g_dbus_connection_signal_unsubscribe(conn,
 984                                         subs_opp_server_interface_removed_id);
 985                         subs_opp_server_interface_removed_id = -1;
 986                 }
 987                 if (subs_opp_server_property_id != -1) {
 988                         g_dbus_connection_signal_unsubscribe(conn,
 989                                         subs_opp_server_property_id);
 990                         subs_opp_server_property_id = -1;
 991                 }
 992         }
 993         return 0;
 994 }
 995
 996 int _bt_register_opp_client_subscribe_signal(GDBusConnection *conn,
 997                 int subscribe)
 998 {
 999         if (conn == NULL)
1000                 return -1;
1001
1002         static int subs_opp_client_interface_added_id = -1;
1003         static int subs_opp_client_interface_removed_id = -1;
1004         static int subs_opp_client_property_id = -1;
1005
1006
1007         if (subscribe) {
1008                 if (subs_opp_client_interface_added_id == -1) {
1009                         subs_opp_client_interface_added_id = g_dbus_connection_signal_subscribe(conn,
1010                                 NULL, BT_MANAGER_INTERFACE,
1011                                 BT_INTERFACES_ADDED, NULL, NULL, 0,
1012                                 __bt_opc_event_filter,
1013                                 NULL, NULL);
1014                 }
1015                 if (subs_opp_client_interface_removed_id == -1) {
1016                         subs_opp_client_interface_removed_id = g_dbus_connection_signal_subscribe(conn,
1017                                 NULL, BT_MANAGER_INTERFACE,
1018                                 BT_INTERFACES_REMOVED, NULL, NULL, 0,
1019                                 __bt_opc_event_filter,
1020                                 NULL, NULL);
1021                 }
1022                 if (subs_opp_client_property_id == -1) {
1023                         subs_opp_client_property_id = g_dbus_connection_signal_subscribe(conn,
1024                                 BT_OBEX_SERVICE_NAME, BT_PROPERTIES_INTERFACE,
1025                                 BT_PROPERTIES_CHANGED, NULL, NULL, 0,
1026                                 __bt_opc_event_filter,
1027                                 NULL, NULL);
1028                 }
1029         } else {
1030                 if (subs_opp_client_interface_added_id != -1) {
1031                         g_dbus_connection_signal_unsubscribe(conn,
1032                                         subs_opp_client_interface_added_id);
1033                         subs_opp_client_interface_added_id = -1;
1034                 }
1035                 if (subs_opp_client_interface_removed_id != -1) {
1036                         g_dbus_connection_signal_unsubscribe(conn,
1037                                         subs_opp_client_interface_removed_id);
1038                         subs_opp_client_interface_removed_id = -1;
1039                 }
1040                 if (subs_opp_client_property_id != -1) {
1041                         g_dbus_connection_signal_unsubscribe(conn,
1042                                         subs_opp_client_property_id);
1043                         subs_opp_client_property_id = -1;
1044                 }
1045         }
1046         return 0;
1047 }
1048
1049 int _bt_register_map_client_subscribe_signal(GDBusConnection *conn,
1050                 int subscribe)
1051 {
1052         if (conn == NULL)
1053                 return -1;
1054
1055         static int subs_map_client_interface_added_id = -1;
1056         static int subs_map_client_interface_removed_id = -1;
1057         static int subs_map_client_property_id = -1;
1058
1059
1060         if (subscribe) {
1061                 if (subs_map_client_interface_added_id == -1) {
1062                         subs_map_client_interface_added_id = g_dbus_connection_signal_subscribe(conn,
1063                                 NULL, BT_MANAGER_INTERFACE,
1064                                 BT_INTERFACES_ADDED, NULL, NULL, 0,
1065                                 __bt_map_event_filter,
1066                                 NULL, NULL);
1067                 }
1068                 if (subs_map_client_interface_removed_id == -1) {
1069                         subs_map_client_interface_removed_id = g_dbus_connection_signal_subscribe(conn,
1070                                 NULL, BT_MANAGER_INTERFACE,
1071                                 BT_INTERFACES_REMOVED, NULL, NULL, 0,
1072                                 __bt_map_event_filter,
1073                                 NULL, NULL);
1074                 }
1075                 if (subs_map_client_property_id == -1) {
1076                         subs_map_client_property_id = g_dbus_connection_signal_subscribe(conn,
1077                                 BT_OBEX_SERVICE_NAME, BT_PROPERTIES_INTERFACE,
1078                                 BT_PROPERTIES_CHANGED, NULL, NULL, 0,
1079                                 __bt_map_event_filter,
1080                                 NULL, NULL);
1081                 }
1082         } else {
1083                 if (subs_map_client_interface_added_id != -1) {
1084                         g_dbus_connection_signal_unsubscribe(conn,
1085                                         subs_map_client_interface_added_id);
1086                         subs_map_client_interface_added_id = -1;
1087                 }
1088                 if (subs_map_client_interface_removed_id != -1) {
1089                         g_dbus_connection_signal_unsubscribe(conn,
1090                                         subs_map_client_interface_removed_id);
1091                         subs_map_client_interface_removed_id = -1;
1092                 }
1093                 if (subs_map_client_property_id != -1) {
1094                         g_dbus_connection_signal_unsubscribe(conn,
1095                                         subs_map_client_property_id);
1096                         subs_map_client_property_id = -1;
1097                 }
1098         }
1099         return 0;
1100 }
1101
1102
1103 int _bt_register_service_event(GDBusConnection *g_conn, int event_type)
1104 {
1105         retv_if(g_conn == NULL, BLUETOOTH_ERROR_INTERNAL);
1106
1107         switch (event_type) {
1108         case BT_MANAGER_EVENT:
1109                 _bt_register_manager_subscribe_signal(g_conn, TRUE);
1110                 break;
1111         case BT_DEVICE_EVENT:
1112                 _bt_register_device_subscribe_signal(g_conn, TRUE);
1113                 break;
1114         case BT_OPP_SERVER_EVENT:
1115                 _bt_register_opp_server_subscribe_signal(g_conn, TRUE);
1116                 break;
1117         case BT_OPP_CLIENT_EVENT:
1118                 _bt_register_opp_client_subscribe_signal(g_conn, TRUE);
1119                 break;
1120         case BT_MAP_CLIENT_EVENT:
1121                 _bt_register_map_client_subscribe_signal(g_conn, TRUE);
1122                 break;
1123         default:
1124                 BT_ERR("Unknown event");
1125                 return BLUETOOTH_ERROR_INTERNAL;
1126         }
1127
1128         return BLUETOOTH_ERROR_NONE;
1129 }
1130
1131 void _bt_unregister_service_event(GDBusConnection *g_conn, int event_type)
1132 {
1133         BT_DBG("+");
1134
1135         ret_if(g_conn == NULL);
1136
1137         switch (event_type) {
1138         case BT_MANAGER_EVENT:
1139                 _bt_register_manager_subscribe_signal(g_conn, FALSE);
1140                 _bt_register_device_subscribe_signal(g_conn, FALSE);
1141                 _bt_register_input_subscribe_signal(g_conn, FALSE);
1142                 break;
1143         case BT_OPP_SERVER_EVENT:
1144                 _bt_register_opp_server_subscribe_signal(g_conn, FALSE);
1145                 break;
1146         case BT_OPP_CLIENT_EVENT:
1147                 _bt_register_opp_client_subscribe_signal(g_conn, FALSE);
1148                 break;
1149         case BT_MAP_CLIENT_EVENT:
1150                 _bt_register_map_client_subscribe_signal(g_conn, FALSE);
1151                 break;
1152         default:
1153                 BT_ERR("Unknown event");
1154                 return;
1155         }
1156
1157         BT_DBG("-");
1158 }
1159
1160 static int __bt_init_manager_receiver(void)
1161 {
1162         BT_DBG("+");
1163
1164         GError *error = NULL;
1165
1166         if (manager_conn == NULL) {
1167                 manager_conn =  g_bus_get_sync(G_BUS_TYPE_SYSTEM, NULL, &error);
1168                 if (error != NULL) {
1169                         BT_ERR("ERROR: Can't get on system bus [%s]", error->message);
1170                         g_clear_error(&error);
1171                 }
1172                 retv_if(manager_conn == NULL, BLUETOOTH_ERROR_INTERNAL);
1173         }
1174
1175         if (_bt_register_service_event(manager_conn,
1176                                 BT_MANAGER_EVENT) != BLUETOOTH_ERROR_NONE)
1177                 goto fail;
1178
1179         if (_bt_register_service_event(manager_conn,
1180                                 BT_DEVICE_EVENT) != BLUETOOTH_ERROR_NONE)
1181                 goto fail;
1182
1183 #ifdef TIZEN_FEATURE_BT_PERMANENT_LOG
1184         __bt_register_dump_subscribe_signal(manager_conn, TRUE);
1185 #endif
1186
1187         return BLUETOOTH_ERROR_NONE;
1188 fail:
1189         if (manager_conn) {
1190                 g_object_unref(manager_conn);
1191                 manager_conn = NULL;
1192         }
1193
1194         BT_DBG("-");
1195
1196         return BLUETOOTH_ERROR_INTERNAL;
1197 }
1198
1199 static int __bt_init_obexd_receiver(void)
1200 {
1201         BT_DBG("+");
1202         if (!TIZEN_PROFILE_TV) { /* TODO: obexd doesn't work in TV profile. It should be resolved later. */
1203                 GError *error = NULL;
1204
1205                 if (obexd_conn == NULL) {
1206                         obexd_conn = g_bus_get_sync(G_BUS_TYPE_SYSTEM, NULL, &error);
1207                         if (error != NULL) {
1208                                 BT_ERR("ERROR: Can't get on session bus [%s]", error->message);
1209                                 g_clear_error(&error);
1210                         }
1211                         retv_if(obexd_conn == NULL, BLUETOOTH_ERROR_INTERNAL);
1212                 }
1213
1214                 if (_bt_register_service_event(obexd_conn,
1215                                         BT_OPP_SERVER_EVENT) != BLUETOOTH_ERROR_NONE) {
1216                         BT_ERR("Error while registering service event");
1217                         g_object_unref(obexd_conn);
1218                         obexd_conn = NULL;
1219                         return BLUETOOTH_ERROR_INTERNAL;
1220                 }
1221         }
1222
1223         BT_DBG("-");
1224
1225         return BLUETOOTH_ERROR_NONE;
1226 }
1227
1228 gboolean __bt_reinit_obexd_receiver(gpointer user_data)
1229 {
1230         static int retry_cnt = 0;
1231         int result = BLUETOOTH_ERROR_NONE;
1232
1233         BT_DBG("+");
1234
1235         result = __bt_init_obexd_receiver();
1236         if (result != BLUETOOTH_ERROR_NONE) {
1237                 /* 20 ms * 50 = 10 seconds. During 10 seconds fail to initialize,
1238                    then it is not the timing issue. Just can't use the session bus connection */
1239                 if (retry_cnt > 100) {
1240                         BT_ERR("Fail to init obexd receiver by 50 times.");
1241                         retry_cnt = 0;
1242                         session_reinit_timer = 0;
1243                         return FALSE;
1244                 }
1245                 retry_cnt++;
1246                 BT_DBG("Retry to initialize the obexd receiver");
1247                 return TRUE;
1248         }
1249
1250         retry_cnt = 0;
1251         session_reinit_timer = 0;
1252
1253         BT_DBG("-");
1254
1255         return FALSE;
1256 }
1257
1258 /* To receive the event from bluez */
1259 int _bt_init_obex_event_receiver(void)
1260 {
1261         BT_DBG("+");
1262
1263         int result;
1264
1265         result = __bt_init_manager_receiver();
1266         retv_if(result != BLUETOOTH_ERROR_NONE, result);
1267
1268         result = __bt_init_obexd_receiver();
1269         if (result != BLUETOOTH_ERROR_NONE) {
1270                 BT_ERR("Fail to init obexd receiver");
1271
1272                 /* Try to re-initialize obexd receiver in the timer */
1273                 if (session_reinit_timer > 0)
1274                         g_source_remove(session_reinit_timer);
1275
1276                 session_reinit_timer = g_timeout_add(200,
1277                                                         (GSourceFunc)__bt_reinit_obexd_receiver, NULL);
1278         }
1279
1280         BT_DBG("-");
1281
1282         return BLUETOOTH_ERROR_NONE;
1283 }
1284
1285 void _bt_deinit_obex_event_receiver(void)
1286 {
1287         BT_DBG("+");
1288
1289         _bt_unregister_service_event(manager_conn, BT_MANAGER_EVENT);
1290
1291         _bt_unregister_service_event(obexd_conn, BT_OPP_SERVER_EVENT);
1292
1293 #ifdef TIZEN_FEATURE_BT_PERMANENT_LOG
1294         __bt_register_dump_subscribe_signal(manager_conn, FALSE);
1295 #endif
1296
1297         if (manager_conn) {
1298                 g_object_unref(manager_conn);
1299                 manager_conn = NULL;
1300         }
1301
1302         if (obexd_conn) {
1303                 g_object_unref(obexd_conn);
1304                 obexd_conn = NULL;
1305         }
1306
1307         if (event_id > 0)
1308                 g_source_remove(event_id);
1309         event_id = 0;
1310
1311         BT_DBG("-");
1312 }
1313