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