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, "(sss)", 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("(i&s&s)", 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         char secure_address[BT_ADDRESS_STRING_SIZE] = { 0 };
 425         ret_if(path == NULL);
 426
 427         if (strcasecmp(member, "Disconnected") == 0) {
 428                 unsigned char disc_reason = 0;
 429                 unsigned char addr_type = 0;
 430                 char *dev_name = NULL;
 431                 gboolean sending = FALSE;
 432
 433                 g_variant_get(msg, "(yys)", &addr_type, &disc_reason, &dev_name);
 434
 435                 address = g_malloc0(BT_ADDRESS_STRING_SIZE);
 436
 437                 _bt_convert_device_path_to_address(path, address);
 438
 439                 if (!addr_type) {
 440                         /*Check for any OPP transfer on the device and cancel
 441                          * the transfer
 442                          */
 443                         _bt_obex_check_pending_transfer(address);
 444                         _bt_opp_client_is_sending(&sending);
 445                         if (sending == TRUE)
 446                                 _bt_opp_client_check_pending_transfer(address);
 447                         /* TODO: MAP? see above */
 448                 }
 449                 g_free(address);
 450                 g_free(dev_name);
 451         } else if (strcasecmp(member, "ProfileStateChanged") == 0) {
 452                 int state = 0;
 453                 char *profile_uuid = NULL;
 454                 bluetooth_device_address_t bd_addr;
 455
 456                 g_variant_get(msg, "(si)", &profile_uuid, &state);
 457
 458                 address = g_malloc0(BT_ADDRESS_STRING_SIZE);
 459
 460                 _bt_convert_device_path_to_address(path, address);
 461                 _bt_convert_addr_string_to_type(bd_addr.addr, address);
 462
 463                 _bt_convert_addr_string_to_secure_string(secure_address, address);
 464                 BT_DBG("[%s] [%s] [%d]", secure_address, profile_uuid, state);
 465                 g_free(address);
 466         }
 467 }
 468
 469 static  void __bt_manager_event_filter(GDBusConnection *connection,
 470                                         const gchar *sender_name,
 471                                         const gchar *object_path,
 472                                         const gchar *interface_name,
 473                                         const gchar *signal_name,
 474                                         GVariant *parameters,
 475                                         gpointer user_data)
 476 {
 477
 478         GVariant *value;
 479         char *obj_path = NULL;
 480
 481         if (signal_name == NULL)
 482                 return;
 483
 484         if (strcasecmp(signal_name, "InterfacesAdded") == 0) {
 485                 g_variant_get(parameters, "(&o@a{sa{sv}})", &obj_path, &value);
 486
 487                 if (strcasecmp(obj_path, BT_BLUEZ_HCI_PATH) == 0)
 488                         if (!TIZEN_FEATURE_BT_USB_DONGLE) {
 489                                 if (_bt_register_obex_server() != BLUETOOTH_ERROR_NONE)
 490                                         BT_ERR("Fail to init obex server");
 491                         }
 492                 g_variant_unref(value);
 493         } else if (strcasecmp(signal_name, "InterfacesRemoved") == 0) {
 494                         if (TIZEN_FEATURE_BT_USB_DONGLE) {
 495                                 if (_bt_unregister_obex_server() != BLUETOOTH_ERROR_NONE)
 496                                         BT_ERR("Fail to unregister obex server");
 497                         }
 498         } else if (strcasecmp(signal_name, "NameOwnerChanged") == 0) {
 499                 gboolean value;
 500                 char *name = NULL;
 501                 char *previous = NULL;
 502                 char *current = NULL;
 503
 504                 if (g_strcmp0(g_variant_get_type_string(parameters), "(sss)") != 0) {
 505                         BT_ERR("Invalid variant format");
 506                         return;
 507                 }
 508
 509                 if (__bt_get_owner_info(parameters, &name, &previous, &current)) {
 510                         BT_ERR("Fail to get the owner info");
 511                         return;
 512                 }
 513
 514                 if (*current != '\0')
 515                         return;
 516
 517                 if (name == NULL)
 518                         return;
 519
 520                 if (strcasecmp(name, BT_BLUEZ_NAME) == 0) {
 521                         BT_INFO_C("### Bluetoothd is terminated");
 522
 523                         if (_bt_unregister_obex_server() != BLUETOOTH_ERROR_NONE)
 524                                 BT_ERR("Fail to unregister obex server");
 525
 526                 }
 527
 528                 _bt_obex_server_check_allocation(&value);
 529
 530                 if (value == TRUE) {
 531                         /* Check if the obex server was terminated abnormally */
 532                         _bt_obex_server_check_termination(name);
 533                 }
 534         } else if (g_strcmp0(interface_name, BT_AGENT_INTERFACE) == 0) {
 535                 _bt_handle_agent_event(parameters, signal_name);
 536         } else if (g_strcmp0(interface_name, BT_DEVICE_INTERFACE) == 0) {
 537                 _bt_handle_device_event(parameters, signal_name, object_path);
 538         }
 539
 540         return;
 541 }
 542
 543 static gboolean __bt_is_obexd_event(GVariant *msg, const char *interface)
 544 {
 545
 546         if (g_strcmp0(interface, BT_PROPERTIES_INTERFACE) == 0) {
 547                 char *interface_name = NULL;
 548
 549                 g_variant_get(msg, "(&s@a{sv}@as)", &interface_name, NULL, NULL);
 550                 retv_if(interface_name == NULL, FALSE);
 551
 552                 if (strcasecmp(interface_name, BT_OBEX_TRANSFER_INTERFACE) == 0) {
 553                         BT_DBG("BT_OBEX_TRANSFER_INTERFACE");
 554                         return TRUE;
 555                 }
 556         }
 557
 558         return FALSE;
 559 }
 560
 561 static  void __bt_obexd_event_filter(GDBusConnection *connection,
 562                                         const gchar *sender_name,
 563                                         const gchar *object_path,
 564                                         const gchar *interface_name,
 565                                         const gchar *signal_name,
 566                                         GVariant *parameters,
 567                                         gpointer user_data)
 568 {
 569         const char *member = signal_name;
 570         char *obj_path = NULL;
 571         ret_if(member == NULL);
 572
 573         if (strcasecmp(member, "InterfacesAdded") == 0) {
 574                 if (__bt_get_object_path(parameters, &obj_path)) {
 575                         BT_ERR("Fail to get the path");
 576                         return;
 577                 }
 578
 579                 /*Handle OPP_SERVER_CONNECTED_EVENT here */
 580                 /* TODO: MAP? see above */
 581                 if (strncmp(obj_path, BT_SESSION_BASEPATH_SERVER,
 582                                 strlen(BT_SESSION_BASEPATH_SERVER)) != 0) {
 583                         g_free(obj_path);
 584                         return;
 585                 }
 586
 587                 if (g_strrstr(obj_path, "session") && g_strrstr(obj_path, "transfer")) {
 588                         BT_DBG("Obex_Server_Session_Transfer connected");
 589                         _bt_obex_transfer_connected(obj_path);
 590                 }
 591                 g_free(obj_path);
 592         } else if (strcasecmp(member, "InterfacesRemoved") == 0) {
 593                 /*Handle OPP_SERVER_DISCONNECTED_EVENT here */
 594                 /* TODO: MAP? see above */
 595                 if (__bt_get_object_path(parameters, &obj_path)) {
 596                         BT_ERR("Fail to get the path");
 597                         return;
 598                 }
 599
 600                 if (strncmp(obj_path, BT_SESSION_BASEPATH_CLIENT,
 601                                 strlen(BT_SESSION_BASEPATH_CLIENT)) == 0) {
 602                         BT_DBG("Call PBAP Disconnected");
 603                         _bt_obex_pbap_client_disconnect(obj_path);
 604                 }
 605
 606                 if (strncmp(obj_path, BT_SESSION_BASEPATH_SERVER,
 607                                 strlen(BT_SESSION_BASEPATH_SERVER)) != 0) {
 608                         g_free(obj_path);
 609                         return;
 610                 }
 611
 612                 if (g_strrstr(obj_path, "session") && g_strrstr(obj_path, "transfer")) {
 613                         BT_DBG("Obex_Server_Session_Transfer disconnected %s",
 614                                                                 obj_path);
 615
 616                         _bt_obex_transfer_disconnected(obj_path);
 617                 }
 618                 g_free(obj_path);
 619         } else if (__bt_is_obexd_event(parameters, interface_name) == TRUE) {
 620                 const char *path = object_path;
 621
 622                 if (strncmp(path, BT_SESSION_BASEPATH_SERVER,
 623                                 strlen(BT_SESSION_BASEPATH_SERVER)) != 0 &&
 624                         strncmp(path, BT_SESSION_BASEPATH_CLIENT,
 625                                 strlen(BT_SESSION_BASEPATH_CLIENT)) != 0) {
 626                         BT_DBG("DBUS_HANDLER_RESULT_NOT_YET_HANDLED");
 627                         return;
 628                 }
 629
 630                 _bt_handle_property_changed_event(parameters, path);
 631         }
 632         return;
 633 }
 634
 635 static gboolean __bt_is_obexd_client_event(GVariant *msg, const char *interface)
 636 {
 637         BT_DBG("+");
 638
 639         if (g_strcmp0(interface, BT_PROPERTIES_INTERFACE) == 0) {
 640                 char *interface_name = NULL;
 641
 642                 g_variant_get(msg, "(&s@a{sv}@as)", &interface_name, NULL, NULL);
 643
 644                 retv_if(interface_name == NULL, FALSE);
 645
 646                 if (strcasecmp(interface_name,
 647                                         BT_OBEX_TRANSFER_INTERFACE) == 0) {
 648                         BT_DBG("-");
 649                         return TRUE;
 650                 }
 651         }
 652
 653         BT_DBG("-");
 654
 655         return FALSE;
 656 }
 657
 658 static  void __bt_opc_event_filter(GDBusConnection *connection,
 659                                         const gchar *sender_name,
 660                                         const gchar *object_path,
 661                                         const gchar *interface_name,
 662                                         const gchar *signal_name,
 663                                         GVariant *parameters,
 664                                         gpointer user_data)
 665 {
 666         const char *member = signal_name;
 667         char *obj_path = NULL;
 668         if (strcasecmp(member, "InterfacesAdded") == 0) {
 669                 BT_DBG("InterfacesAdded");
 670         } else if (strcasecmp(member, "InterfacesRemoved") == 0) {
 671
 672                 if (__bt_get_object_path(parameters, &obj_path)) {
 673                         BT_ERR("Fail to get the path");
 674                         return;
 675                 }
 676
 677                 BT_DBG("object_path = %s", obj_path);
 678
 679                 if (strncmp(obj_path, BT_SESSION_BASEPATH_CLIENT,
 680                                 strlen(BT_SESSION_BASEPATH_CLIENT)) != 0
 681                                 || strstr(obj_path, "transfer") == NULL) {
 682                         g_free(obj_path);
 683                         return;
 684                 } else if (strncmp(obj_path, BT_SESSION_BASEPATH_CLIENT,
 685                                 strlen(BT_SESSION_BASEPATH_CLIENT)) == 0) {
 686                         BT_DBG("Going to call opc disconnected");
 687                         _bt_opc_disconnected(obj_path);
 688                 }
 689
 690                 _bt_sending_files();
 691                 g_free(obj_path);
 692         } else if (__bt_is_obexd_client_event(parameters, interface_name) == TRUE) {
 693                 char *path = (char *)object_path;
 694                 BT_INFO("object_path %s", path);
 695                 if (strncmp(path, BT_SESSION_BASEPATH_CLIENT,
 696                         strlen(BT_SESSION_BASEPATH_CLIENT)) != 0) {
 697                         BT_DBG("NOT BT_SESSION_BASEPATH_CLIENT");
 698                         return;
 699                 }
 700
 701                 _bt_opc_property_changed_event(parameters, path);
 702         }
 703
 704         return;
 705 }
 706
 707 int _bt_opp_client_event_init(void)
 708 {
 709         GError *error = NULL;
 710
 711         if (opc_obexd_conn == NULL) {
 712                 opc_obexd_conn = g_bus_get_sync(G_BUS_TYPE_SYSTEM, NULL, &error);
 713
 714                 if (!opc_obexd_conn) {
 715                         if (error) {
 716                                 BT_ERR("Unable to connect to dbus: %s", error->message);
 717                                 g_clear_error(&error);
 718                         }
 719                 return BLUETOOTH_ERROR_INTERNAL;
 720                 }
 721         }
 722
 723         if (_bt_register_service_event(opc_obexd_conn,
 724                         BT_OPP_CLIENT_EVENT) != BLUETOOTH_ERROR_NONE) {
 725                         g_object_unref(opc_obexd_conn);
 726                         opc_obexd_conn = NULL;
 727                         return BLUETOOTH_ERROR_INTERNAL;
 728         }
 729
 730         return BLUETOOTH_ERROR_NONE;
 731 }
 732
 733 void _bt_opp_client_event_deinit(void)
 734 {
 735         if (opc_obexd_conn) {
 736                 _bt_unregister_service_event(opc_obexd_conn,
 737                                                 BT_OPP_CLIENT_EVENT);
 738                  g_object_unref(opc_obexd_conn);
 739                  opc_obexd_conn = NULL;
 740         }
 741 }
 742
 743 static  void __bt_map_event_filter(GDBusConnection *connection,
 744                                         const gchar *sender_name,
 745                                         const gchar *object_path,
 746                                         const gchar *interface_name,
 747                                         const gchar *signal_name,
 748                                         GVariant *parameters,
 749                                         gpointer user_data)
 750 {
 751         BT_DBG("Entered __bt_map_event_filter");
 752         const char *member = signal_name;
 753
 754         if (strcasecmp(member, "InterfacesAdded") == 0) {
 755                 BT_DBG("------------------------------------ADDED------------------------------------");
 756                 // currently doing nothing
 757         } else if (strcasecmp(member, "InterfacesRemoved") == 0) {
 758                 BT_DBG("------------------------------------REMOVED------------------------------------");
 759                 // TODO check if something should be called here?
 760                 //_bt_map_on_transfer_finished(object_path, error);
 761         } else if (__bt_is_obexd_client_event(parameters, interface_name) == TRUE) {
 762                 BT_DBG("------------------------------------CLIENT EVENT------------------------------------");
 763                 _bt_map_property_changed_event(parameters, object_path);
 764         }
 765
 766         return;
 767 }
 768
 769 int _bt_map_client_event_init(void)
 770 {
 771         GError *error = NULL;
 772
 773         if (map_obexd_conn == NULL) {
 774                 map_obexd_conn = g_bus_get_sync(G_BUS_TYPE_SYSTEM, NULL, &error);
 775
 776                 if (!map_obexd_conn) {
 777                         if (error) {
 778                                 BT_ERR("Unable to connect to dbus: %s", error->message);
 779                                 g_clear_error(&error);
 780                         }
 781                 return BLUETOOTH_ERROR_INTERNAL;
 782                 }
 783         }
 784
 785         if (_bt_register_service_event(map_obexd_conn,
 786                         BT_MAP_CLIENT_EVENT) != BLUETOOTH_ERROR_NONE) {
 787                         g_object_unref(map_obexd_conn);
 788                         map_obexd_conn = NULL;
 789                         return BLUETOOTH_ERROR_INTERNAL;
 790         }
 791
 792         return BLUETOOTH_ERROR_NONE;
 793 }
 794
 795 void _bt_map_client_event_deinit(void)
 796 {
 797         if (map_obexd_conn) {
 798                 _bt_unregister_service_event(map_obexd_conn,
 799                                                 BT_MAP_CLIENT_EVENT);
 800                  g_object_unref(map_obexd_conn);
 801                  map_obexd_conn = NULL;
 802         }
 803 }
 804
 805 int _bt_register_manager_subscribe_signal(GDBusConnection *conn,
 806                 int subscribe)
 807 {
 808         if (conn == NULL)
 809                 return -1;
 810
 811         static int subs_interface_added_id = -1;
 812         static int subs_interface_removed_id = -1;
 813         static int subs_name_owner_changed = -1;
 814
 815         if (subscribe) {
 816                 if (subs_interface_added_id == -1) {
 817                         subs_interface_added_id = g_dbus_connection_signal_subscribe(conn,
 818                                 NULL, BT_MANAGER_INTERFACE,
 819                                 BT_INTERFACES_ADDED, NULL, NULL, 0,
 820                                 __bt_manager_event_filter,
 821                                 NULL, NULL);
 822                 }
 823                 if (subs_interface_removed_id == -1) {
 824                         subs_interface_removed_id = g_dbus_connection_signal_subscribe(conn,
 825                                 NULL, BT_MANAGER_INTERFACE,
 826                                 BT_INTERFACES_REMOVED, NULL, NULL, 0,
 827                                 __bt_manager_event_filter,
 828                                 NULL, NULL);
 829                 }
 830                 if (subs_name_owner_changed == -1) {
 831                         subs_name_owner_changed = g_dbus_connection_signal_subscribe(conn,
 832                                 NULL, BT_EVENT_FREEDESKTOP,
 833                                 BT_NAME_OWNER_CHANGED, NULL, NULL, 0,
 834                                 __bt_manager_event_filter, NULL, NULL);
 835                 }
 836
 837         } else {
 838                 if (subs_interface_added_id != -1) {
 839                         g_dbus_connection_signal_unsubscribe(conn,
 840                                         subs_interface_added_id);
 841                         subs_interface_added_id = -1;
 842                 }
 843                 if (subs_interface_removed_id != -1) {
 844                         g_dbus_connection_signal_unsubscribe(conn,
 845                                         subs_interface_removed_id);
 846                         subs_interface_removed_id = -1;
 847                 }
 848                 if (subs_name_owner_changed != -1) {
 849                         g_dbus_connection_signal_unsubscribe(conn,
 850                                         subs_name_owner_changed);
 851                         subs_name_owner_changed = -1;
 852                 }
 853
 854         }
 855         return 0;
 856 }
 857
 858 int _bt_register_device_subscribe_signal(GDBusConnection *conn,
 859                 int subscribe)
 860 {
 861         if (conn == NULL)
 862                 return -1;
 863
 864         static int subs_device_id = -1;
 865
 866         if (subscribe) {
 867                 if (subs_device_id == -1) {
 868                         subs_device_id = g_dbus_connection_signal_subscribe(conn,
 869                                 NULL, BT_DEVICE_INTERFACE,
 870                                 NULL, NULL, NULL, 0,
 871                                 __bt_manager_event_filter,
 872                                 NULL, NULL);
 873                 }
 874         } else {
 875                 if (subs_device_id != -1) {
 876                         g_dbus_connection_signal_unsubscribe(conn,
 877                                         subs_device_id);
 878                         subs_device_id = -1;
 879                 }
 880         }
 881         return 0;
 882 }
 883
 884 int _bt_register_input_subscribe_signal(GDBusConnection *conn,
 885                 int subscribe)
 886 {
 887         if (conn == NULL)
 888                 return -1;
 889
 890         static int subs_input_id = -1;
 891
 892         if (subscribe) {
 893                 if (subs_input_id == -1) {
 894                         subs_input_id = g_dbus_connection_signal_subscribe(conn,
 895                                 NULL, BT_INPUT_INTERFACE,
 896                                 NULL, NULL, NULL, 0,
 897                                 __bt_manager_event_filter,
 898                                 NULL, NULL);
 899                 }
 900         } else {
 901                 if (subs_input_id != -1) {
 902                         g_dbus_connection_signal_unsubscribe(conn,
 903                                         subs_input_id);
 904                         subs_input_id = -1;
 905                 }
 906         }
 907         return 0;
 908 }
 909
 910
 911
 912 int _bt_register_opp_server_subscribe_signal(GDBusConnection *conn,
 913                 int subscribe)
 914 {
 915         if (conn == NULL)
 916                 return -1;
 917
 918         static int subs_opp_server_interface_added_id = -1;
 919         static int subs_opp_server_interface_removed_id = -1;
 920         static int subs_opp_server_property_id = -1;
 921
 922
 923         if (subscribe) {
 924                 if (subs_opp_server_interface_added_id == -1) {
 925                         subs_opp_server_interface_added_id = g_dbus_connection_signal_subscribe(conn,
 926                                 NULL, BT_MANAGER_INTERFACE,
 927                                 BT_INTERFACES_ADDED, NULL, NULL, 0,
 928                                 __bt_obexd_event_filter,
 929                                 NULL, NULL);
 930                 }
 931                 if (subs_opp_server_interface_removed_id == -1) {
 932                         subs_opp_server_interface_removed_id = g_dbus_connection_signal_subscribe(conn,
 933                                 NULL, BT_MANAGER_INTERFACE,
 934                                 BT_INTERFACES_REMOVED, NULL, NULL, 0,
 935                                 __bt_obexd_event_filter,
 936                                 NULL, NULL);
 937                 }
 938                 if (subs_opp_server_property_id == -1) {
 939                         subs_opp_server_property_id = g_dbus_connection_signal_subscribe(conn,
 940                                 NULL, BT_PROPERTIES_INTERFACE,
 941                                 BT_PROPERTIES_CHANGED, NULL, NULL, 0,
 942                                 __bt_obexd_event_filter,
 943                                 NULL, NULL);
 944                 }
 945         } else {
 946                 if (subs_opp_server_interface_added_id != -1) {
 947                         g_dbus_connection_signal_unsubscribe(conn,
 948                                         subs_opp_server_interface_added_id);
 949                         subs_opp_server_interface_added_id = -1;
 950                 }
 951                 if (subs_opp_server_interface_removed_id != -1) {
 952                         g_dbus_connection_signal_unsubscribe(conn,
 953                                         subs_opp_server_interface_removed_id);
 954                         subs_opp_server_interface_removed_id = -1;
 955                 }
 956                 if (subs_opp_server_property_id != -1) {
 957                         g_dbus_connection_signal_unsubscribe(conn,
 958                                         subs_opp_server_property_id);
 959                         subs_opp_server_property_id = -1;
 960                 }
 961         }
 962         return 0;
 963 }
 964
 965 int _bt_register_opp_client_subscribe_signal(GDBusConnection *conn,
 966                 int subscribe)
 967 {
 968         if (conn == NULL)
 969                 return -1;
 970
 971         static int subs_opp_client_interface_added_id = -1;
 972         static int subs_opp_client_interface_removed_id = -1;
 973         static int subs_opp_client_property_id = -1;
 974
 975
 976         if (subscribe) {
 977                 if (subs_opp_client_interface_added_id == -1) {
 978                         subs_opp_client_interface_added_id = g_dbus_connection_signal_subscribe(conn,
 979                                 NULL, BT_MANAGER_INTERFACE,
 980                                 BT_INTERFACES_ADDED, NULL, NULL, 0,
 981                                 __bt_opc_event_filter,
 982                                 NULL, NULL);
 983                 }
 984                 if (subs_opp_client_interface_removed_id == -1) {
 985                         subs_opp_client_interface_removed_id = g_dbus_connection_signal_subscribe(conn,
 986                                 NULL, BT_MANAGER_INTERFACE,
 987                                 BT_INTERFACES_REMOVED, NULL, NULL, 0,
 988                                 __bt_opc_event_filter,
 989                                 NULL, NULL);
 990                 }
 991                 if (subs_opp_client_property_id == -1) {
 992                         subs_opp_client_property_id = g_dbus_connection_signal_subscribe(conn,
 993                                 NULL, BT_PROPERTIES_INTERFACE,
 994                                 BT_PROPERTIES_CHANGED, NULL, NULL, 0,
 995                                 __bt_opc_event_filter,
 996                                 NULL, NULL);
 997                 }
 998         } else {
 999                 if (subs_opp_client_interface_added_id != -1) {
1000                         g_dbus_connection_signal_unsubscribe(conn,
1001                                         subs_opp_client_interface_added_id);
1002                         subs_opp_client_interface_added_id = -1;
1003                 }
1004                 if (subs_opp_client_interface_removed_id != -1) {
1005                         g_dbus_connection_signal_unsubscribe(conn,
1006                                         subs_opp_client_interface_removed_id);
1007                         subs_opp_client_interface_removed_id = -1;
1008                 }
1009                 if (subs_opp_client_property_id != -1) {
1010                         g_dbus_connection_signal_unsubscribe(conn,
1011                                         subs_opp_client_property_id);
1012                         subs_opp_client_property_id = -1;
1013                 }
1014         }
1015         return 0;
1016 }
1017
1018 int _bt_register_map_client_subscribe_signal(GDBusConnection *conn,
1019                 int subscribe)
1020 {
1021         if (conn == NULL)
1022                 return -1;
1023
1024         static int subs_map_client_interface_added_id = -1;
1025         static int subs_map_client_interface_removed_id = -1;
1026         static int subs_map_client_property_id = -1;
1027
1028
1029         if (subscribe) {
1030                 if (subs_map_client_interface_added_id == -1) {
1031                         subs_map_client_interface_added_id = g_dbus_connection_signal_subscribe(conn,
1032                                 NULL, BT_MANAGER_INTERFACE,
1033                                 BT_INTERFACES_ADDED, NULL, NULL, 0,
1034                                 __bt_map_event_filter,
1035                                 NULL, NULL);
1036                 }
1037                 if (subs_map_client_interface_removed_id == -1) {
1038                         subs_map_client_interface_removed_id = g_dbus_connection_signal_subscribe(conn,
1039                                 NULL, BT_MANAGER_INTERFACE,
1040                                 BT_INTERFACES_REMOVED, NULL, NULL, 0,
1041                                 __bt_map_event_filter,
1042                                 NULL, NULL);
1043                 }
1044                 if (subs_map_client_property_id == -1) {
1045                         subs_map_client_property_id = g_dbus_connection_signal_subscribe(conn,
1046                                 NULL, BT_PROPERTIES_INTERFACE,
1047                                 BT_PROPERTIES_CHANGED, NULL, NULL, 0,
1048                                 __bt_map_event_filter,
1049                                 NULL, NULL);
1050                 }
1051         } else {
1052                 if (subs_map_client_interface_added_id != -1) {
1053                         g_dbus_connection_signal_unsubscribe(conn,
1054                                         subs_map_client_interface_added_id);
1055                         subs_map_client_interface_added_id = -1;
1056                 }
1057                 if (subs_map_client_interface_removed_id != -1) {
1058                         g_dbus_connection_signal_unsubscribe(conn,
1059                                         subs_map_client_interface_removed_id);
1060                         subs_map_client_interface_removed_id = -1;
1061                 }
1062                 if (subs_map_client_property_id != -1) {
1063                         g_dbus_connection_signal_unsubscribe(conn,
1064                                         subs_map_client_property_id);
1065                         subs_map_client_property_id = -1;
1066                 }
1067         }
1068         return 0;
1069 }
1070
1071
1072 int _bt_register_service_event(GDBusConnection *g_conn, int event_type)
1073 {
1074         retv_if(g_conn == NULL, BLUETOOTH_ERROR_INTERNAL);
1075
1076         switch (event_type) {
1077         case BT_MANAGER_EVENT:
1078                 _bt_register_manager_subscribe_signal(g_conn, TRUE);
1079                 break;
1080         case BT_DEVICE_EVENT:
1081                 _bt_register_device_subscribe_signal(g_conn, TRUE);
1082                 break;
1083         case BT_OPP_SERVER_EVENT:
1084                 _bt_register_opp_server_subscribe_signal(g_conn, TRUE);
1085                 break;
1086         case BT_OPP_CLIENT_EVENT:
1087                 _bt_register_opp_client_subscribe_signal(g_conn, TRUE);
1088                 break;
1089         case BT_MAP_CLIENT_EVENT:
1090                 _bt_register_map_client_subscribe_signal(g_conn, TRUE);
1091                 break;
1092         default:
1093                 BT_ERR("Unknown event");
1094                 return BLUETOOTH_ERROR_INTERNAL;
1095         }
1096
1097         return BLUETOOTH_ERROR_NONE;
1098 }
1099
1100 void _bt_unregister_service_event(GDBusConnection *g_conn, int event_type)
1101 {
1102         BT_DBG("+");
1103
1104         ret_if(g_conn == NULL);
1105
1106         switch (event_type) {
1107         case BT_MANAGER_EVENT:
1108                 _bt_register_manager_subscribe_signal(g_conn, FALSE);
1109                 _bt_register_device_subscribe_signal(g_conn, FALSE);
1110                 _bt_register_input_subscribe_signal(g_conn, FALSE);
1111                 break;
1112         case BT_OPP_SERVER_EVENT:
1113                 _bt_register_opp_server_subscribe_signal(g_conn, FALSE);
1114                 break;
1115         case BT_OPP_CLIENT_EVENT:
1116                 _bt_register_opp_client_subscribe_signal(g_conn, FALSE);
1117                 break;
1118         case BT_MAP_CLIENT_EVENT:
1119                 _bt_register_map_client_subscribe_signal(g_conn, FALSE);
1120                 break;
1121         default:
1122                 BT_ERR("Unknown event");
1123                 return;
1124         }
1125
1126         BT_DBG("-");
1127 }
1128
1129 static int __bt_init_manager_receiver(void)
1130 {
1131         BT_DBG("+");
1132
1133         GError *error = NULL;
1134
1135         if (manager_conn == NULL) {
1136                 manager_conn =  g_bus_get_sync(G_BUS_TYPE_SYSTEM, NULL, &error);
1137                 if (error != NULL) {
1138                         BT_ERR("ERROR: Can't get on system bus [%s]", error->message);
1139                         g_clear_error(&error);
1140                 }
1141                 retv_if(manager_conn == NULL, BLUETOOTH_ERROR_INTERNAL);
1142         }
1143
1144         if (_bt_register_service_event(manager_conn,
1145                                 BT_MANAGER_EVENT) != BLUETOOTH_ERROR_NONE)
1146                 goto fail;
1147
1148         if (_bt_register_service_event(manager_conn,
1149                                 BT_DEVICE_EVENT) != BLUETOOTH_ERROR_NONE)
1150                 goto fail;
1151
1152         return BLUETOOTH_ERROR_NONE;
1153 fail:
1154         if (manager_conn) {
1155                 g_object_unref(manager_conn);
1156                 manager_conn = NULL;
1157         }
1158
1159         BT_DBG("-");
1160
1161         return BLUETOOTH_ERROR_INTERNAL;
1162 }
1163
1164 static int __bt_init_obexd_receiver(void)
1165 {
1166         BT_DBG("+");
1167         if (!TIZEN_PROFILE_TV) { /* TODO: obexd doesn't work in TV profile. It should be resolved later. */
1168                 GError *error = NULL;
1169
1170                 if (obexd_conn == NULL) {
1171                         obexd_conn = g_bus_get_sync(G_BUS_TYPE_SYSTEM, NULL, &error);
1172                         if (error != NULL) {
1173                                 BT_ERR("ERROR: Can't get on session bus [%s]", error->message);
1174                                 g_clear_error(&error);
1175                         }
1176                         retv_if(obexd_conn == NULL, BLUETOOTH_ERROR_INTERNAL);
1177                 }
1178
1179                 if (_bt_register_service_event(obexd_conn,
1180                                         BT_OPP_SERVER_EVENT) != BLUETOOTH_ERROR_NONE) {
1181                         BT_ERR("Error while registering service event");
1182                         g_object_unref(obexd_conn);
1183                         obexd_conn = NULL;
1184                         return BLUETOOTH_ERROR_INTERNAL;
1185                 }
1186         }
1187
1188         BT_DBG("-");
1189
1190         return BLUETOOTH_ERROR_NONE;
1191 }
1192
1193 gboolean __bt_reinit_obexd_receiver(gpointer user_data)
1194 {
1195         static int retry_cnt = 0;
1196         int result = BLUETOOTH_ERROR_NONE;
1197
1198         BT_DBG("+");
1199
1200         result = __bt_init_obexd_receiver();
1201         if (result != BLUETOOTH_ERROR_NONE) {
1202                 /* 20 ms * 50 = 10 seconds. During 10 seconds fail to initialize,
1203                    then it is not the timing issue. Just can't use the session bus connection */
1204                 if (retry_cnt > 100) {
1205                         BT_ERR("Fail to init obexd receiver by 50 times.");
1206                         retry_cnt = 0;
1207                         session_reinit_timer = 0;
1208                         return FALSE;
1209                 }
1210                 retry_cnt++;
1211                 BT_DBG("Retry to initialize the obexd receiver");
1212                 return TRUE;
1213         }
1214
1215         retry_cnt = 0;
1216         session_reinit_timer = 0;
1217
1218         BT_DBG("-");
1219
1220         return FALSE;
1221 }
1222
1223 /* To receive the event from bluez */
1224 int _bt_init_obex_event_receiver(void)
1225 {
1226         BT_DBG("+");
1227
1228         int result;
1229
1230         result = __bt_init_manager_receiver();
1231         retv_if(result != BLUETOOTH_ERROR_NONE, result);
1232
1233         result = __bt_init_obexd_receiver();
1234         if (result != BLUETOOTH_ERROR_NONE) {
1235                 BT_ERR("Fail to init obexd receiver");
1236
1237                 /* Try to re-initialize obexd receiver in the timer */
1238                 if (session_reinit_timer > 0)
1239                         g_source_remove(session_reinit_timer);
1240
1241                 session_reinit_timer = g_timeout_add(200,
1242                                                         (GSourceFunc)__bt_reinit_obexd_receiver, NULL);
1243         }
1244
1245         BT_DBG("-");
1246
1247         return BLUETOOTH_ERROR_NONE;
1248 }
1249
1250 void _bt_deinit_obex_event_receiver(void)
1251 {
1252         BT_DBG("+");
1253
1254         _bt_unregister_service_event(manager_conn, BT_MANAGER_EVENT);
1255
1256         _bt_unregister_service_event(obexd_conn, BT_OPP_SERVER_EVENT);
1257
1258         if (manager_conn) {
1259                 g_object_unref(manager_conn);
1260                 manager_conn = NULL;
1261         }
1262
1263         if (obexd_conn) {
1264                 g_object_unref(obexd_conn);
1265                 obexd_conn = NULL;
1266         }
1267
1268         if (event_id > 0)
1269                 g_source_remove(event_id);
1270         event_id = 0;
1271
1272         BT_DBG("-");
1273 }
1274