bt-core/bt-core-adapter.c

   1 /*
   2  * Bluetooth-frwk
   3  *
   4  * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
   5  *
   6  * Contact:  Hocheol Seo <hocheol.seo@samsung.com>
   7  *               Girishashok Joshi <girish.joshi@samsung.com>
   8  *               Chanyeol Park <chanyeol.park@samsung.com>
   9  *
  10  * Licensed under the Apache License, Version 2.0 (the "License");
  11  * you may not use this file except in compliance with the License.
  12  * You may obtain a copy of the License at
  13  *
  14  *              http://www.apache.org/licenses/LICENSE-2.0
  15  *
  16  * Unless required by applicable law or agreed to in writing, software
  17  * distributed under the License is distributed on an "AS IS" BASIS,
  18  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  19  * See the License for the specific language governing permissions and
  20  * limitations under the License.
  21  *
  22  */
  23
  24 #include <vconf.h>
  25 #include <vconf-keys.h>
  26
  27 #include "bt-core-main.h"
  28 #include "bt-core-adapter.h"
  29 #include "bt-core-common.h"
  30 #include "bt-core-dbus-handler.h"
  31 #include "bt-core-noti-handler.h"
  32
  33 static bt_status_t adapter_status = BT_DEACTIVATED;
  34 static bt_le_status_t adapter_le_status = BT_LE_DEACTIVATED;
  35 static gboolean is_recovery_mode = FALSE;
  36
  37 static int bt_status_before[BT_MODE_MAX] = { VCONFKEY_BT_STATUS_OFF, };
  38 static int bt_le_status_before[BT_MODE_MAX] = { 0, };
  39
  40 static DBusGConnection *conn = NULL;
  41
  42 static void __bt_core_set_status(bt_status_t status)
  43 {
  44         adapter_status = status;
  45 }
  46
  47 bt_status_t _bt_core_get_status(void)
  48 {
  49         return adapter_status;
  50 }
  51
  52 static void __bt_core_set_le_status(bt_le_status_t status)
  53 {
  54         adapter_le_status = status;
  55 }
  56
  57 bt_le_status_t _bt_core_get_le_status(void)
  58 {
  59         return adapter_le_status;
  60 }
  61
  62 int _bt_core_get_bt_status(bt_mode_e mode)
  63 {
  64         return bt_status_before[mode];
  65 }
  66
  67 int _bt_core_get_bt_le_status(bt_mode_e mode)
  68 {
  69         return bt_le_status_before[mode];
  70 }
  71
  72 void _bt_core_set_bt_status(bt_mode_e mode, int status)
  73 {
  74         bt_status_before[mode] = status;
  75 }
  76
  77 void _bt_core_set_bt_le_status(bt_mode_e mode, int status)
  78 {
  79         bt_le_status_before[mode] = status;
  80 }
  81
  82 gboolean _bt_core_is_recovery_mode(void)
  83 {
  84         return is_recovery_mode;
  85 }
  86
  87 gboolean _bt_core_is_flight_mode_enabled(void)
  88 {
  89 #ifdef TIZEN_TELEPHONY_ENABLED
  90         int isFlightMode = 0;
  91         int ret = -1;
  92
  93         ret = vconf_get_bool(VCONFKEY_TELEPHONY_FLIGHT_MODE, &isFlightMode);
  94         if (ret != 0) {
  95                 BT_ERR("vconf_get_bool failed");
  96         }
  97         return isFlightMode;
  98 #else
  99         return FALSE;
 100 #endif
 101 }
 102
 103 static gboolean bt_core_enable_adapter(BtCore *agent,
 104                                                 DBusGMethodInvocation *context);
 105
 106 static gboolean bt_core_disable_adapter(BtCore *agent,
 107                                                 DBusGMethodInvocation *context);
 108
 109 static gboolean bt_core_recover_adapter(BtCore *agent,
 110                                                 DBusGMethodInvocation *context);
 111
 112 static gboolean bt_core_enable_adapter_le(BtCore *agent,
 113                                                 DBusGMethodInvocation *context);
 114
 115 static gboolean bt_core_disable_adapter_le(BtCore *agent,
 116                                                 DBusGMethodInvocation *context);
 117
 118 static gboolean bt_core_reset_adapter(BtCore *agent,
 119                                                 DBusGMethodInvocation *context);
 120
 121 static gboolean bt_core_enable_core(BtCore *agent,
 122                                                 DBusGMethodInvocation *context);
 123
 124 static int __execute_command(const char *cmd, char *const arg_list[]);
 125
 126 #include "bt-core-adapter-method.h"
 127
 128
 129 G_DEFINE_TYPE(BtCore, bt_core, G_TYPE_OBJECT);
 130
 131 /*This is part of platform provided code skeleton for client server model*/
 132 static void bt_core_class_init (BtCoreClass *bt_core_class)
 133 {
 134         dbus_g_object_type_install_info(G_TYPE_FROM_CLASS(bt_core_class),
 135                                         &dbus_glib_bt_core_object_info);
 136 }
 137
 138 /*This is part of platform provided code skeleton for client server model*/
 139 static void bt_core_init (BtCore *core)
 140 {
 141 }
 142
 143 typedef enum {
 144         BT_CORE_ERROR_REJECT,
 145         BT_CORE_ERROR_CANCEL,
 146         BT_CORE_ERROR_TIMEOUT,
 147 } BtCoreError;
 148
 149 #define BT_CORE_ERROR (bt_core_error_quark())
 150
 151 static GQuark bt_core_error_quark(void)
 152 {
 153         static GQuark quark = 0;
 154         if (!quark)
 155                 quark = g_quark_from_static_string("BtCore");
 156
 157         return quark;
 158 }
 159
 160 #define ENUM_ENTRY(NAME, DESC) { NAME, "" #NAME "", DESC }
 161
 162 static GError *bt_core_error(BtCoreError error, const char *err_msg)
 163 {
 164         return g_error_new(BT_CORE_ERROR, error, err_msg, NULL);
 165 }
 166
 167 static int __execute_command(const char *cmd, char *const arg_list[])
 168 {
 169         int pid;
 170         int pid2;
 171         int status = 0;
 172         BT_DBG("+");
 173
 174         pid = fork();
 175         switch (pid) {
 176         case -1:
 177                 BT_ERR("fork failed");
 178                 return -1;
 179
 180         case 0:
 181                 pid2 = fork();
 182                 if (pid2 == -1) {
 183                         BT_ERR("fork failed");
 184                 } else if (pid2 == 0) {
 185                         execv(cmd, arg_list);
 186                         exit(256);
 187                 }
 188                 exit(0);
 189                 break;
 190
 191         default:
 192                 BT_DBG("parent : forked[%d]", pid);
 193                 waitpid(pid, &status, 0);
 194                 BT_DBG("child is terminated : %d", status);
 195                 break;
 196         }
 197         BT_DBG("-");
 198         return 0;
 199 }
 200
 201 static DBusGProxy *_bt_get_connman_proxy(void)
 202 {
 203         DBusGProxy *proxy;
 204
 205         if (conn == NULL) {
 206                 conn = dbus_g_bus_get(DBUS_BUS_SYSTEM, NULL);
 207                 retv_if(conn == NULL, NULL);
 208         }
 209
 210         proxy = dbus_g_proxy_new_for_name(conn,
 211                         CONNMAN_DBUS_NAME,
 212                         CONNMAN_BLUETOOTH_TECHNOLOGY_PATH,
 213                         CONNMAN_BLUETOTOH_TECHNOLOGY_INTERFACE);
 214         retv_if(proxy == NULL, NULL);
 215
 216         return proxy;
 217 }
 218
 219 static int _bt_power_adapter(gboolean powered)
 220 {
 221         GValue state = { 0 };
 222         GError *error = NULL;
 223         DBusGProxy *proxy;
 224
 225         proxy = _bt_get_connman_proxy();
 226         retv_if(proxy == NULL, BLUETOOTH_ERROR_INTERNAL);
 227
 228         g_value_init(&state, G_TYPE_BOOLEAN);
 229         g_value_set_boolean(&state, powered);
 230
 231         BT_DBG("set power property state: %d to connman", powered);
 232
 233         dbus_g_proxy_call(proxy, "SetProperty", &error,
 234                                 G_TYPE_STRING, "Powered",
 235                                 G_TYPE_VALUE, &state,
 236                                 G_TYPE_INVALID, G_TYPE_INVALID);
 237
 238         if (error != NULL) {
 239                 BT_ERR("Powered set err: \n [%s]", error->message);
 240                 g_error_free(error);
 241                 g_value_unset(&state);
 242                 return BLUETOOTH_ERROR_INTERNAL;
 243         }
 244         return BLUETOOTH_ERROR_NONE;
 245 }
 246
 247 int _bt_enable_adapter(void)
 248 {
 249         int ret;
 250         bt_status_t status;
 251         bt_le_status_t le_status;
 252 #ifdef __TIZEN_MOBILE__
 253         __bt_core_set_status(BT_ACTIVATING);
 254
 255         ret = __execute_command("/usr/etc/bluetooth/bt-stack-up.sh", NULL);
 256         if (ret < 0) {
 257                 BT_ERR("running script failed");
 258                 ret = __execute_command("/usr/etc/bluetooth/bt-dev-end.sh", NULL);
 259                 __bt_core_set_status(BT_DEACTIVATED);
 260                 return -1;
 261         }
 262 #else
 263         _bt_power_adapter(TRUE);
 264 #endif
 265
 266         return 0;
 267 }
 268
 269 int _bt_disable_adapter(void)
 270 {
 271         BT_INFO_C("Disable adapter");
 272 #ifdef __TIZEN_MOBILE__
 273         __bt_core_set_status(BT_DEACTIVATING);
 274
 275         if (__execute_command("/usr/etc/bluetooth/bt-stack-down.sh", NULL) < 0) {
 276                 BT_ERR("running script failed");
 277                 __bt_core_set_status(BT_ACTIVATED);
 278                 return -1;
 279         }
 280 #else
 281         _bt_power_adapter(FALSE);
 282 #endif
 283         return 0;
 284 }
 285
 286 int _bt_enable_adapter_le(void)
 287 {
 288         BT_DBG("");
 289 #ifdef __TIZEN_MOBILE__
 290         int ret;
 291         bt_status_t status;
 292
 293         status = _bt_core_get_status();
 294         if (status == BT_DEACTIVATED) {
 295                 __bt_core_set_le_status(BT_LE_ACTIVATING);
 296                 BT_DBG("Activate BT");
 297                 ret = system("/usr/etc/bluetooth/bt-stack-up.sh &");
 298                 if (ret < 0) {
 299                         BT_ERR("running script failed");
 300                         ret = __execute_command("/usr/etc/bluetooth/bt-dev-end.sh &", NULL);
 301                         __bt_core_set_status(BT_DEACTIVATED);
 302                         __bt_core_set_le_status(BT_LE_DEACTIVATED);
 303                         return -1;
 304                 }
 305         } else {
 306                 __bt_core_set_le_status(BT_LE_ACTIVATED);
 307         }
 308 #else
 309         _bt_power_adapter(TRUE);
 310 #endif
 311         return 0;
 312 }
 313
 314 int _bt_disable_adapter_le(void)
 315 {
 316         BT_DBG("+");
 317
 318 #ifdef __TIZEN_MOBILE__
 319         bt_status_t status;
 320
 321         status = _bt_core_get_status();
 322         BT_DBG("status : %d", status);
 323
 324         if (status == BT_DEACTIVATED) {
 325                 __bt_core_set_le_status(BT_LE_DEACTIVATING);
 326
 327                 if (__execute_command("/usr/etc/bluetooth/bt-stack-down.sh", NULL) < 0) {
 328                         BT_ERR("running script failed");
 329                         __bt_core_set_le_status(BT_LE_ACTIVATED);
 330                         return -1;
 331                 }
 332         }
 333         __bt_core_set_le_status(BT_LE_DEACTIVATED);
 334 #else
 335         _bt_power_adapter(FALSE);
 336 #endif
 337
 338         BT_DBG("-");
 339         return 0;
 340 }
 341
 342 int _bt_core_service_request_adapter(int service_function)
 343 {
 344         int ret = -1;
 345
 346         GArray *in_param1 = NULL;
 347         GArray *in_param2 = NULL;
 348         GArray *in_param3 = NULL;
 349         GArray *in_param4 = NULL;
 350         GArray *out_param = NULL;
 351
 352         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 353
 354         ret = _bt_core_service_request(BT_CORE_SERVICE, service_function,
 355                         in_param1, in_param2, in_param3, in_param4, &out_param);
 356         if (ret < 0)
 357                 BT_ERR("_bt_core_service_request_adapter() failed");
 358
 359         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 360
 361         return ret;
 362 }
 363
 364 static void __bt_core_update_status(void)
 365 {
 366         int bt_status = VCONFKEY_BT_STATUS_OFF;
 367         int bt_le_status = 0;
 368
 369         if (vconf_get_int(VCONFKEY_BT_STATUS, &bt_status) < 0)
 370                 BT_ERR("no bluetooth device info, so BT was disabled at previous session");
 371 #ifdef ENABLE_TIZEN_2_4
 372         if (vconf_get_int(VCONFKEY_BT_LE_STATUS, &bt_le_status) < 0)
 373                 BT_ERR("no bluetooth le info, so BT LE was disabled at previous session");
 374 #endif
 375
 376         BT_INFO("bt_status = %d, bt_le_status = %d", bt_status, bt_le_status);
 377
 378         if (bt_status == VCONFKEY_BT_STATUS_OFF)
 379                 __bt_core_set_status(BT_DEACTIVATED);
 380         else
 381                 __bt_core_set_status(BT_ACTIVATED);
 382
 383         if (bt_le_status == 0)
 384                 __bt_core_set_le_status(BT_LE_DEACTIVATED);
 385         else
 386                 __bt_core_set_le_status(BT_LE_ACTIVATED);
 387 }
 388
 389 static gboolean bt_core_enable_adapter(BtCore *agent,
 390                                                 DBusGMethodInvocation *context)
 391 {
 392         char *sender = dbus_g_method_get_sender(context);
 393         int ret;
 394
 395         if (sender == NULL)
 396                 return FALSE;
 397
 398         _bt_set_flightmode_request(FALSE);
 399         if (vconf_set_int(BT_OFF_DUE_TO_FLIGHT_MODE, 0) != 0)
 400                 BT_ERR("Set vconf failed");
 401
 402         ret = _bt_enable_adapter();
 403         if (ret < 0) {
 404                 GError *error = bt_core_error(BT_CORE_ERROR_REJECT,
 405                                                         "Activation failed");
 406                 dbus_g_method_return_error(context, error);
 407                 g_error_free(error);
 408                 g_free(sender);
 409                 return FALSE;
 410         } else {
 411                 dbus_g_method_return(context);
 412         }
 413
 414         g_free(sender);
 415         return TRUE;
 416 }
 417
 418 static gboolean bt_core_disable_adapter(BtCore *agent,
 419                                                 DBusGMethodInvocation *context)
 420 {
 421         char *sender = dbus_g_method_get_sender(context);
 422         int ret;
 423
 424         if (sender == NULL)
 425                 return FALSE;
 426
 427         _bt_set_flightmode_request(FALSE);
 428         if (vconf_set_int(BT_OFF_DUE_TO_FLIGHT_MODE, 0) != 0)
 429                 BT_ERR("Set vconf failed");
 430
 431         ret = _bt_disable_adapter();
 432         if (ret < 0) {
 433                 GError *error = bt_core_error(BT_CORE_ERROR_REJECT,
 434                                                         "Deactivation failed");
 435                 dbus_g_method_return_error(context, error);
 436                 g_error_free(error);
 437                 g_free(sender);
 438                 return FALSE;
 439         } else {
 440                 dbus_g_method_return(context);
 441         }
 442
 443         g_free(sender);
 444         return TRUE;
 445 }
 446
 447 static gboolean bt_core_recover_adapter(BtCore *agent,
 448                                                 DBusGMethodInvocation *context)
 449 {
 450         int ret;
 451         int ret_le;
 452
 453         BT_INFO_C("Recover bt adapter");
 454
 455         dbus_g_method_return(context);
 456
 457         _bt_set_flightmode_request(FALSE);
 458         if (vconf_set_int(BT_OFF_DUE_TO_FLIGHT_MODE, 0) != 0)
 459                 BT_ERR("Set vconf failed");
 460
 461         is_recovery_mode = TRUE;
 462
 463         __bt_core_update_status();
 464
 465         if (_bt_core_get_status() == BT_ACTIVATED) {
 466                 _bt_core_set_bt_status(BT_RECOVERY_MODE, 1);
 467                 _bt_core_service_request_adapter(BT_DISABLE_ADAPTER);
 468         }
 469         if (_bt_core_get_le_status() == BT_LE_ACTIVATED) {
 470                 _bt_core_set_bt_le_status(BT_RECOVERY_MODE, 1);
 471                 _bt_core_service_request_adapter(BT_DISABLE_ADAPTER_LE);
 472         }
 473
 474         ret = _bt_disable_adapter();
 475         if (ret < 0)
 476                 BT_ERR("_bt_disable_adapter() failed");
 477         ret_le = _bt_disable_adapter_le();
 478         if (ret_le < 0)
 479                 BT_ERR("_bt_disable_adapter_le() failed");
 480
 481         return TRUE;
 482 }
 483
 484 static gboolean bt_core_enable_adapter_le(BtCore *agent,
 485                                                 DBusGMethodInvocation *context)
 486 {
 487         char *sender = dbus_g_method_get_sender(context);
 488         int ret;
 489
 490         if (sender == NULL)
 491                 return FALSE;
 492
 493         ret = _bt_enable_adapter_le();
 494         if (ret < 0) {
 495                 GError *error = bt_core_error(BT_CORE_ERROR_REJECT,
 496                                                         "LE Activation failed");
 497                 dbus_g_method_return_error(context, error);
 498                 g_error_free(error);
 499                 g_free(sender);
 500                 BT_DBG("-");
 501                 return FALSE;
 502         } else {
 503                 dbus_g_method_return(context);
 504         }
 505
 506         g_free(sender);
 507         BT_DBG("-");
 508         return TRUE;
 509 }
 510
 511 static gboolean bt_core_disable_adapter_le(BtCore *agent,
 512                                                 DBusGMethodInvocation *context)
 513 {
 514         BT_DBG("+");
 515
 516         char *sender = dbus_g_method_get_sender(context);
 517         BT_DBG("sender : %s", sender);
 518         int ret;
 519
 520         if (sender == NULL)
 521                 return FALSE;
 522
 523         ret = _bt_disable_adapter_le();
 524         if (ret < 0) {
 525                 GError *error = bt_core_error(BT_CORE_ERROR_REJECT,
 526                                                         "LE Deactivation failed");
 527                 dbus_g_method_return_error(context, error);
 528                 g_error_free(error);
 529                 g_free(sender);
 530                 return FALSE;
 531         } else {
 532                 dbus_g_method_return(context);
 533         }
 534
 535         g_free(sender);
 536         BT_DBG("-");
 537         return TRUE;
 538 }
 539
 540 static int __bt_reset_adapter(void)
 541 {
 542         /* Forcely terminate */
 543         if (__execute_command("/usr/etc/bluetooth/bt-reset-env.sh", NULL) < 0) {
 544                 BT_ERR("running script failed");
 545         }
 546         _bt_core_terminate();
 547         return 0;
 548 }
 549
 550 static gboolean bt_core_reset_adapter(BtCore *agent,
 551                                                 DBusGMethodInvocation *context)
 552 {
 553         char *sender = dbus_g_method_get_sender(context);
 554         int ret;
 555
 556         if (sender == NULL)
 557                 return FALSE;
 558
 559         ret = __bt_reset_adapter();
 560         if (ret < 0) {
 561                 GError *error = bt_core_error(BT_CORE_ERROR_REJECT,
 562                                                         "Deactivation failed");
 563                 dbus_g_method_return_error(context, error);
 564                 g_error_free(error);
 565                 g_free(sender);
 566                 return FALSE;
 567         } else {
 568                 dbus_g_method_return(context);
 569         }
 570
 571         g_free(sender);
 572         return TRUE;
 573 }
 574
 575 static gboolean __bt_core_enable_core_timeout_cb(gpointer data)
 576 {
 577         BT_DBG("+");
 578
 579         _bt_core_init_vconf_value();
 580
 581         return FALSE;
 582 }
 583
 584 static gboolean bt_core_enable_core(BtCore *agent,
 585                                                 DBusGMethodInvocation *context)
 586 {
 587         char *sender = dbus_g_method_get_sender(context);
 588
 589         if (sender == NULL)
 590                 return FALSE;
 591
 592         BT_DBG("+");
 593
 594         __bt_core_update_status();
 595
 596         g_timeout_add(200, (GSourceFunc)__bt_core_enable_core_timeout_cb, NULL);
 597
 598         dbus_g_method_return(context);
 599
 600         g_free(sender);
 601
 602         BT_DBG("-");
 603         return TRUE;
 604 }
 605
 606 static gboolean __bt_core_recovery_cb(gpointer data)
 607 {
 608         int ret = 0;
 609         gboolean is_request_failed = FALSE;
 610         static gboolean is_first_failure = TRUE;
 611
 612         BT_DBG("+");
 613
 614         if (_bt_core_get_bt_status(BT_RECOVERY_MODE) == 1) {
 615                 ret = _bt_core_service_request_adapter(BT_ENABLE_ADAPTER);
 616                 if (ret < 0)
 617                         is_request_failed = TRUE;
 618         }
 619
 620         if (_bt_core_get_bt_le_status(BT_RECOVERY_MODE) == 1) {
 621                 ret = _bt_core_service_request_adapter(BT_ENABLE_ADAPTER_LE);
 622                 if (ret < 0)
 623                         is_request_failed = TRUE;
 624         }
 625
 626         if (is_request_failed == TRUE) {
 627                 BT_ERR("Recovery is failed.");
 628                 if (is_first_failure == TRUE) {
 629                         g_timeout_add(2000, (GSourceFunc)__bt_core_recovery_cb, NULL);
 630                         is_first_failure = FALSE;
 631                         return FALSE;
 632                 } else {
 633                         is_first_failure = TRUE;
 634                         return FALSE;
 635                 }
 636         } else
 637                 is_first_failure = TRUE;
 638
 639         if (_bt_core_get_bt_status(BT_RECOVERY_MODE) == 1) {
 640                 _bt_core_set_bt_status(BT_RECOVERY_MODE, 0);
 641                 ret = _bt_enable_adapter();
 642                 if (ret < 0)
 643                         BT_ERR("_bt_enable_adapter() failed");
 644         }
 645         if (_bt_core_get_bt_le_status(BT_RECOVERY_MODE) == 1) {
 646                 _bt_core_set_bt_le_status(BT_RECOVERY_MODE, 0);
 647                 ret = _bt_enable_adapter_le();
 648                 if (ret < 0)
 649                         BT_ERR("_bt_enable_adapter_le() failed");
 650         }
 651
 652         is_recovery_mode = FALSE;
 653
 654         BT_DBG("-");
 655
 656         return FALSE;
 657 }
 658
 659 static gboolean __bt_core_enable_timeout_cb(gpointer data)
 660 {
 661         bt_status_t adapter_status;
 662         bt_le_status_t adapter_status_le;
 663
 664         BT_DBG("");
 665
 666         if (vconf_set_int(BT_OFF_DUE_TO_FLIGHT_MODE, 0) != 0)
 667                 BT_ERR("Set vconf failed");
 668
 669         adapter_status = _bt_core_get_status();
 670         adapter_status_le = _bt_core_get_le_status();
 671
 672         if (adapter_status == BT_DEACTIVATED &&
 673                         _bt_core_get_bt_status(BT_FLIGHT_MODE) != 0) {
 674                 _bt_core_set_bt_status(BT_FLIGHT_MODE, 0);
 675                 _bt_core_service_request_adapter(BT_ENABLE_ADAPTER);
 676                 _bt_enable_adapter();
 677         }
 678
 679         if (adapter_status_le == BT_LE_DEACTIVATED &&
 680                         _bt_core_get_bt_le_status(BT_FLIGHT_MODE) != 0) {
 681                 _bt_core_set_bt_le_status(BT_FLIGHT_MODE, 0);
 682                 _bt_core_service_request_adapter(BT_ENABLE_ADAPTER_LE);
 683                 _bt_enable_adapter_le();
 684         }
 685
 686         return FALSE;
 687 }
 688
 689 static gboolean __bt_core_disable_timeout_cb(gpointer data)
 690 {
 691         bt_status_t adapter_status;
 692         bt_le_status_t adapter_status_le;
 693
 694         BT_DBG("");
 695
 696         if (vconf_set_int(BT_OFF_DUE_TO_FLIGHT_MODE, 1) != 0)
 697                 BT_ERR("Set vconf failed");
 698
 699         adapter_status = _bt_core_get_status();
 700         adapter_status_le = _bt_core_get_le_status();
 701
 702         if (adapter_status == BT_ACTIVATED) {
 703                 int bt_status_before_mode = 0;
 704
 705                 if (vconf_get_int(VCONFKEY_BT_STATUS, &bt_status_before_mode) == 0)
 706                         _bt_core_set_bt_status(BT_FLIGHT_MODE, bt_status_before_mode);
 707
 708                 _bt_core_service_request_adapter(BT_DISABLE_ADAPTER);
 709                 _bt_disable_adapter();
 710         }
 711
 712         if (adapter_status_le == BT_LE_ACTIVATED) {
 713                 int bt_le_status_before_mode = 0;
 714
 715 #ifdef ENABLE_TIZEN_2_4
 716                 if (vconf_get_int(VCONFKEY_BT_LE_STATUS, &bt_le_status_before_mode) == 0)
 717                         _bt_core_set_bt_le_status(BT_FLIGHT_MODE, bt_le_status_before_mode);
 718 #endif
 719
 720                 _bt_core_service_request_adapter(BT_DISABLE_ADAPTER_LE);
 721                 _bt_disable_adapter_le();
 722         }
 723
 724         return FALSE;
 725 }
 726
 727 void _bt_core_adapter_added_cb(void)
 728 {
 729         bt_status_t status;
 730         bt_le_status_t le_status;
 731         gboolean flight_mode_status;
 732
 733         BT_DBG("");
 734
 735         status = _bt_core_get_status();
 736         BT_DBG("status : %d", status);
 737         le_status = _bt_core_get_le_status();
 738         BT_DBG("le_status : %d", le_status);
 739
 740         if (status == BT_ACTIVATING)
 741                 __bt_core_set_status(BT_ACTIVATED);
 742         if (le_status == BT_LE_ACTIVATING)
 743                 __bt_core_set_le_status(BT_LE_ACTIVATED);
 744
 745         flight_mode_status = _bt_core_is_flight_mode_enabled();
 746
 747         if (flight_mode_status == TRUE && _bt_is_flightmode_request() == TRUE) {
 748                 _bt_set_flightmode_request(FALSE);
 749                 g_timeout_add(2000, (GSourceFunc)__bt_core_disable_timeout_cb, NULL);
 750                 return;
 751         }
 752         _bt_set_flightmode_request(FALSE);
 753
 754         _bt_core_terminate();
 755 }
 756
 757 void _bt_core_adapter_removed_cb(void)
 758 {
 759         int flight_mode_value = 0;
 760         int power_saving_mode = 0;
 761         gboolean flight_mode_status;
 762         static int timer_id = -1;
 763
 764         BT_DBG("");
 765
 766         __bt_core_set_status(BT_DEACTIVATED);
 767         __bt_core_set_le_status(BT_LE_DEACTIVATED);
 768         if (vconf_set_int(VCONFKEY_BT_STATUS, VCONFKEY_BT_STATUS_OFF) != 0)
 769                 BT_ERR("Set vconf failed");
 770 #ifdef ENABLE_TIZEN_2_4
 771         if (vconf_set_int(VCONFKEY_BT_LE_STATUS, VCONFKEY_BT_LE_STATUS_OFF) != 0)
 772                 BT_ERR("Set vconf failed");
 773 #endif
 774
 775         if (is_recovery_mode == TRUE)
 776         {
 777                 if (timer_id < 0)
 778                         timer_id = g_timeout_add(2000, (GSourceFunc)__bt_core_recovery_cb, NULL);
 779                 return;
 780         }
 781
 782         if (vconf_get_int(BT_OFF_DUE_TO_FLIGHT_MODE, &flight_mode_value) != 0)
 783                 BT_ERR("Fail to get the flight_mode_deactivated value");
 784
 785         if (vconf_get_int(BT_OFF_DUE_TO_POWER_SAVING_MODE, &power_saving_mode) != 0)
 786                 BT_ERR("Fail to get the ps_mode_deactivated value");
 787
 788         flight_mode_status = _bt_core_is_flight_mode_enabled();
 789
 790         if (flight_mode_status == FALSE && _bt_is_flightmode_request() == TRUE) {
 791                 _bt_set_flightmode_request(FALSE);
 792                 if (timer_id < 0)
 793                         timer_id = g_timeout_add(2000, (GSourceFunc)__bt_core_enable_timeout_cb, NULL);
 794                 return;
 795         }
 796         _bt_set_flightmode_request(FALSE);
 797
 798         if (flight_mode_value == 1 || power_saving_mode == 1){
 799                 BT_DBG("Bt Core not terminated");
 800                 return;
 801         }
 802
 803         _bt_core_terminate();
 804 }
 805