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