bt-core/bt-core-adapter.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 <vconf.h>
  19 #include <vconf-keys.h>
  20 #include <vconf-internal-radio-keys.h>
  21 #include <bundle.h>
  22 #include <eventsystem.h>
  23
  24 #include "bt-core-main.h"
  25 #include "bt-core-adapter.h"
  26 #include "bt-core-common.h"
  27 #include "bt-core-dbus-handler.h"
  28 #include "bt-core-noti-handler.h"
  29
  30 #define BT_CORE_IDLE_TERM_TIME 200 /* 200ms */
  31 #define BT_CORE_CHECK_ADAPTER_OBJECT_PATH_MAX 50
  32
  33
  34 static bt_status_t adapter_status = BT_DEACTIVATED;
  35 static bt_le_status_t adapter_le_status = BT_LE_DEACTIVATED;
  36 static gboolean is_recovery_mode = FALSE;
  37 static guint core_enable_timer_id;
  38
  39
  40 static int bt_status_before[BT_MODE_MAX] = { VCONFKEY_BT_STATUS_OFF, };
  41 static int bt_le_status_before[BT_MODE_MAX] = { VCONFKEY_BT_LE_STATUS_OFF, };
  42
  43 static int __bt_eventsystem_set_value(const char *event, const char *key, const char *value);
  44
  45 static void __bt_core_set_status(bt_status_t status)
  46 {
  47         adapter_status = status;
  48 }
  49
  50 bt_status_t _bt_core_get_status(void)
  51 {
  52         return adapter_status;
  53 }
  54
  55 static void __bt_core_set_le_status(bt_le_status_t status)
  56 {
  57         adapter_le_status = status;
  58 }
  59
  60 bt_le_status_t _bt_core_get_le_status(void)
  61 {
  62         return adapter_le_status;
  63 }
  64
  65 int _bt_core_get_bt_status(bt_mode_e mode)
  66 {
  67         return bt_status_before[mode];
  68 }
  69
  70 int _bt_core_get_bt_le_status(bt_mode_e mode)
  71 {
  72         return bt_le_status_before[mode];
  73 }
  74
  75 void _bt_core_set_bt_status(bt_mode_e mode, int status)
  76 {
  77         bt_status_before[mode] = status;
  78 }
  79
  80 void _bt_core_set_bt_le_status(bt_mode_e mode, int status)
  81 {
  82         bt_le_status_before[mode] = status;
  83 }
  84
  85 gboolean _bt_core_is_recovery_mode(void)
  86 {
  87         return is_recovery_mode;
  88 }
  89
  90 static gboolean __bt_core_idle_terminate(gpointer data)
  91 {
  92         BT_DBG("+");
  93         _bt_core_terminate();
  94         return FALSE;
  95 }
  96
  97 gboolean _bt_core_is_flight_mode_enabled(void)
  98 {
  99         int isFlightMode = 0;
 100         int ret = -1;
 101
 102         if (TIZEN_FEATURE_FLIGHTMODE_ENABLED) {
 103                 ret = vconf_get_bool(VCONFKEY_TELEPHONY_FLIGHT_MODE, &isFlightMode);
 104                 if (ret != 0)
 105                         BT_ERR("vconf_get_bool failed");
 106
 107                 return isFlightMode;
 108         } else {
 109                 return FALSE;
 110         }
 111 }
 112
 113 static int __execute_command(const char *cmd, char *const arg_list[])
 114 {
 115         int pid;
 116         int pid2;
 117         int status = 0;
 118         BT_DBG("+");
 119
 120         pid = fork();
 121         switch (pid) {
 122         case -1:
 123                 BT_ERR("fork failed");
 124                 return -1;
 125
 126         case 0:
 127                 pid2 = fork();
 128                 if (pid2 == -1) {
 129                         BT_ERR("fork failed");
 130                 } else if (pid2 == 0) {
 131                         execv(cmd, arg_list);
 132                         exit(256);
 133                 }
 134                 exit(0);
 135                 break;
 136
 137         default:
 138                 BT_DBG("parent : forked[%d]", pid);
 139                 waitpid(pid, &status, 0);
 140                 BT_DBG("child is terminated : %d", status);
 141                 break;
 142         }
 143         BT_DBG("-");
 144         return 0;
 145 }
 146
 147 int _bt_enable_adapter(void)
 148 {
 149         int ret;
 150         bt_status_t status;
 151 #if 0
 152         bt_le_status_t le_status;
 153 #endif
 154         BT_INFO("");
 155
 156         status = _bt_core_get_status();
 157         if (status != BT_DEACTIVATED) {
 158                 BT_ERR("Invalid state %d", status);
 159                 g_timeout_add(BT_CORE_IDLE_TERM_TIME, __bt_core_idle_terminate, NULL);
 160                 return -1;
 161         }
 162
 163 #if 0 /* only the concept of private */
 164         le_status = _bt_core_get_le_status();
 165         if (le_status == BT_LE_ACTIVATED) {
 166                 /* Turn on PSCAN, (ISCAN if needed) */
 167                 /* Return with 0 for the Enabled response. */
 168                 __bt_core_set_status(BT_ACTIVATED);
 169                 BT_INFO("BR/EDR is enabled.");
 170                 g_timeout_add(BT_CORE_IDLE_TERM_TIME, __bt_core_idle_terminate, NULL);
 171                 return 0;
 172         }
 173 #endif
 174
 175         __bt_core_set_status(BT_ACTIVATING);
 176         if (TIZEN_FEATURE_BT_USB_DONGLE) {
 177                 char *argv_up[] = {"/usr/bin/hciconfig", "/usr/bin/hciconfig", "hci0", "up", NULL};
 178                 ret = __execute_command("/usr/bin/hciconfig", argv_up);
 179         } else {
 180                 ret = __execute_command("/usr/etc/bluetooth/bt-stack-up.sh", NULL);
 181         }
 182         if (ret < 0) {
 183                 BT_ERR("running script failed");
 184                 if (TIZEN_FEATURE_BT_USB_DONGLE) {
 185                         char *argv_down[] = {"/usr/bin/hciconfig", "/usr/bin/hciconfig", "hci0", "down", NULL};
 186                         ret = __execute_command("/usr/bin/hciconfig", argv_down);
 187                 } else {
 188                         ret = __execute_command("/usr/etc/bluetooth/bt-dev-end.sh", NULL);
 189                 }
 190                 __bt_core_set_status(BT_DEACTIVATED);
 191                 return -1;
 192         }
 193
 194         return 0;
 195 }
 196
 197 int _bt_disable_adapter(void)
 198 {
 199         bt_status_t status;
 200 #if 0
 201         bt_le_status_t le_status;
 202 #endif
 203
 204         BT_INFO_C("Disable adapter");
 205
 206 #if 0 /* only the concept of private */
 207         le_status = _bt_core_get_le_status();
 208         BT_DBG("le_status : %d", le_status);
 209         if (le_status == BT_LE_ACTIVATED) {
 210                 /* Turn off PSCAN, (ISCAN if needed) */
 211                 /* Return with 0 for the Disabled response. */
 212                 __bt_core_set_status(BT_DEACTIVATED);
 213                 BT_INFO("BR/EDR is disabled. now LE only mode");
 214                 g_timeout_add(BT_CORE_IDLE_TERM_TIME, __bt_core_idle_terminate, NULL);
 215                 return 0;
 216         }
 217 #endif
 218
 219         status = _bt_core_get_status();
 220         if (status == BT_ACTIVATING) {
 221                 /* Forcely terminate */
 222                 if (TIZEN_FEATURE_BT_USB_DONGLE) {
 223                         char *argv_down[] = {"/usr/bin/hciconfig", "/usr/bin/hciconfig", "hci0", "down", NULL};
 224                         if (__execute_command("/usr/bin/hciconfig", argv_down) < 0)
 225                                 BT_ERR("running script failed");
 226                 } else {
 227
 228 #ifdef TIZEN_FEATURE_RADIO
 229                         int radio_status = VCONFKEY_RADIO_STATUS_OFF;
 230
 231                         /* Check if radio status on or off */
 232                         if (vconf_get_int(VCONFKEY_RADIO_STATUS, &radio_status) < 0)
 233                                 BT_ERR("Fail to get radio status");
 234
 235                         BT_DBG("Radio status: %d", radio_status);
 236
 237                         if (radio_status == VCONFKEY_RADIO_STATUS_ON) {
 238                                 if (__execute_command("/usr/etc/bluetooth/bt-stack-down-with-radio.sh", NULL) < 0)
 239                                         BT_ERR("running script failed");
 240                         } else {
 241                                 if (__execute_command("/usr/etc/bluetooth/bt-stack-down.sh", NULL) < 0)
 242                                         BT_ERR("running script failed");
 243                         }
 244 #else
 245                         if (__execute_command("/usr/etc/bluetooth/bt-stack-down.sh", NULL) < 0)
 246                                 BT_ERR("running script failed");
 247 #endif
 248                 }
 249                 _bt_core_terminate();
 250                 return 0;
 251         } else if (status != BT_ACTIVATED) {
 252                 BT_ERR("Invalid state %d", status);
 253                 g_timeout_add(BT_CORE_IDLE_TERM_TIME, __bt_core_idle_terminate, NULL);
 254         }
 255
 256         __bt_core_set_status(BT_DEACTIVATING);
 257         if (TIZEN_FEATURE_BT_USB_DONGLE) {
 258                 char *argv_down[] = {"/usr/bin/hciconfig", "/usr/bin/hciconfig", "hci0", "down", NULL};
 259                 if (__execute_command("/usr/bin/hciconfig", argv_down) < 0) {
 260                         BT_ERR("running script failed");
 261                         __bt_core_set_status(BT_ACTIVATED);
 262                         return -1;
 263                 }
 264         } else {
 265 #ifdef TIZEN_FEATURE_RADIO
 266                 int radio_status = VCONFKEY_RADIO_STATUS_OFF;
 267
 268                 /* Check if radio status on or off */
 269                 if (vconf_get_int(VCONFKEY_RADIO_STATUS, &radio_status) < 0)
 270                         BT_ERR("Fail to get radio status");
 271
 272                 BT_DBG("Radio status: %d", radio_status);
 273
 274                 if (radio_status == VCONFKEY_RADIO_STATUS_ON) {
 275                         if (__execute_command("/usr/etc/bluetooth/bt-stack-down-with-radio.sh", NULL) < 0) {
 276                                 BT_ERR("running script failed");
 277                                 __bt_core_set_status(BT_ACTIVATED);
 278                                 return -1;
 279                         }
 280                 } else {
 281                         if (__execute_command("/usr/etc/bluetooth/bt-stack-down.sh", NULL) < 0) {
 282                                 BT_ERR("running script failed");
 283                                 __bt_core_set_status(BT_ACTIVATED);
 284                                 return -1;
 285                         }
 286                 }
 287 #else
 288                 if (__execute_command("/usr/etc/bluetooth/bt-stack-down.sh", NULL) < 0) {
 289                                 BT_ERR("running script failed");
 290                                 __bt_core_set_status(BT_ACTIVATED);
 291                                 return -1;
 292                 }
 293 #endif
 294         }
 295
 296         return 0;
 297 }
 298
 299 int _bt_enable_adapter_le(void)
 300 {
 301         BT_DBG("");
 302
 303         int ret;
 304         bt_status_t status;
 305         bt_le_status_t le_status;
 306         le_status = _bt_core_get_le_status();
 307         retv_if(le_status != BT_LE_DEACTIVATED, -1);
 308
 309         status = _bt_core_get_status();
 310         if (status == BT_DEACTIVATED) {
 311                 __bt_core_set_le_status(BT_LE_ACTIVATING);
 312                 BT_DBG("Activate BT");
 313                 if (TIZEN_FEATURE_BT_USB_DONGLE) {
 314                         char *argv_up[] = {"/usr/bin/hciconfig", "/usr/bin/hciconfig", "hci0", "up", NULL};
 315                         ret = __execute_command("/usr/bin/hciconfig", argv_up);
 316                 } else {
 317                         ret = __execute_command("/usr/etc/bluetooth/bt-stack-up.sh", NULL);
 318                 }
 319                 if (ret < 0) {
 320                         BT_ERR("running script failed");
 321                         if (TIZEN_FEATURE_BT_USB_DONGLE) {
 322                                 char *argv_down[] = {"/usr/bin/hciconfig", "/usr/bin/hciconfig", "hci0", "down", NULL};
 323                                 ret = __execute_command("/usr/bin/hciconfig", argv_down);
 324                         } else {
 325                                 ret = __execute_command("/usr/etc/bluetooth/bt-dev-end.sh &", NULL);
 326                         }
 327                         __bt_core_set_status(BT_DEACTIVATED);
 328                         __bt_core_set_le_status(BT_LE_DEACTIVATED);
 329                         return -1;
 330                 }
 331         } else {
 332                 __bt_core_set_le_status(BT_LE_ACTIVATED);
 333                 g_timeout_add(BT_CORE_IDLE_TERM_TIME, __bt_core_idle_terminate, NULL);
 334         }
 335 #ifdef TIZEN_FEATURE_BT_HPS
 336         ret = _bt_core_start_httpproxy();
 337         if (ret < 0)
 338                 BT_ERR("_bt_core_start_httpproxy() failed");
 339 #endif
 340
 341         return 0;
 342 }
 343
 344 int _bt_disable_adapter_le(void)
 345 {
 346         BT_DBG("+");
 347
 348         bt_status_t status;
 349         bt_le_status_t le_status;
 350
 351         le_status = _bt_core_get_le_status();
 352         retv_if(le_status == BT_LE_DEACTIVATED, 0);
 353         retv_if(le_status == BT_LE_DEACTIVATING, -1);
 354
 355 #ifdef TIZEN_FEATURE_BT_HPS
 356         _bt_core_stop_httpproxy();
 357 #endif
 358
 359         status = _bt_core_get_status();
 360         BT_DBG("status : %d", status);
 361
 362         if (status == BT_DEACTIVATED) {
 363                 __bt_core_set_le_status(BT_LE_DEACTIVATING);
 364                 int ret;
 365                 if (TIZEN_FEATURE_BT_USB_DONGLE) {
 366                         char *argv_down[] = {"/usr/bin/hciconfig", "/usr/bin/hciconfig", "hci0", "down", NULL};
 367                         ret = __execute_command("/usr/bin/hciconfig", argv_down);
 368                 } else {
 369                         ret = __execute_command("/usr/etc/bluetooth/bt-stack-down.sh", NULL);
 370                 }
 371                 if (ret < 0) {
 372                         BT_ERR("running script failed");
 373                         __bt_core_set_le_status(BT_LE_ACTIVATED);
 374                         return -1;
 375                 }
 376         } else {
 377                         g_timeout_add(BT_CORE_IDLE_TERM_TIME, __bt_core_idle_terminate, NULL);
 378         }
 379
 380         __bt_core_set_le_status(BT_LE_DEACTIVATED);
 381
 382         BT_DBG("-");
 383         return 0;
 384 }
 385
 386 int _bt_core_service_request_adapter(int service_function)
 387 {
 388         int ret = -1;
 389
 390         GArray *in_param1 = NULL;
 391         GArray *in_param2 = NULL;
 392         GArray *in_param3 = NULL;
 393         GArray *in_param4 = NULL;
 394         GArray *out_param = NULL;
 395
 396         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 397
 398         ret = _bt_core_service_request(BT_CORE_SERVICE, service_function,
 399                         in_param1, in_param2, in_param3, in_param4, &out_param);
 400         if (ret < 0)
 401                 BT_ERR("_bt_core_service_request_adapter() failed");
 402
 403         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 404
 405         return ret;
 406 }
 407
 408 static gboolean __bt_core_check_the_adapter_path(GDBusConnection *conn)
 409 {
 410         GError *err = NULL;
 411         GDBusProxy *manager_proxy = NULL;
 412         GVariant *result = NULL;
 413         char *adapter_path = NULL;
 414
 415         if (conn == NULL)
 416                 return FALSE;
 417
 418         manager_proxy =  g_dbus_proxy_new_sync(conn,
 419                         G_DBUS_PROXY_FLAGS_NONE, NULL,
 420                         "org.bluez",
 421                         "/",
 422                         "org.freedesktop.DBus.ObjectManager",
 423                         NULL, &err);
 424
 425         if (!manager_proxy) {
 426                 if (err != NULL) {
 427                         BT_ERR("Unable to create proxy: %s", err->message);
 428                         g_clear_error(&err);
 429                 } else {
 430                         BT_ERR("Fail to create proxy");
 431                 }
 432                 goto fail;
 433         }
 434
 435         result = g_dbus_proxy_call_sync(manager_proxy, "DefaultAdapter", NULL,
 436                         G_DBUS_CALL_FLAGS_NONE, -1, NULL, &err);
 437         if (!result) {
 438                 if (err != NULL) {
 439                         BT_ERR("Fail to get DefaultAdapter (Error: %s)", err->message);
 440                         g_clear_error(&err);
 441                 } else{
 442                         BT_ERR("Fail to get DefaultAdapter");
 443                 }
 444                 goto fail;
 445         }
 446
 447         if (g_strcmp0(g_variant_get_type_string(result), "(o)")) {
 448                 BT_ERR("Incorrect result\n");
 449                 goto fail;
 450         }
 451
 452         g_variant_get(result, "(&o)", &adapter_path);
 453
 454         if (adapter_path == NULL ||
 455                 strlen(adapter_path) >= BT_CORE_CHECK_ADAPTER_OBJECT_PATH_MAX) {
 456                 BT_ERR("Adapter path is inproper\n");
 457                 goto fail;
 458         }
 459
 460         g_variant_unref(result);
 461         g_object_unref(manager_proxy);
 462
 463         return TRUE;
 464
 465 fail:
 466         if (result)
 467                 g_variant_unref(result);
 468
 469         if (manager_proxy)
 470                 g_object_unref(manager_proxy);
 471
 472         return FALSE;
 473 }
 474
 475 void _bt_core_update_status(void)
 476 {
 477         int bt_status = VCONFKEY_BT_STATUS_OFF;
 478         int bt_le_status = VCONFKEY_BT_LE_STATUS_OFF;
 479         gboolean ret = FALSE;
 480
 481         ret = __bt_core_check_the_adapter_path(_bt_core_get_gdbus_connection());
 482         BT_INFO("check the real status of bt_adapter");
 483
 484         if (ret != TRUE) {
 485                 __bt_core_set_status(BT_DEACTIVATED);
 486                 __bt_core_set_le_status(BT_DEACTIVATED);
 487         } else {
 488                 if (vconf_get_int(VCONFKEY_BT_STATUS, &bt_status) < 0)
 489                         BT_ERR("no bluetooth device info, so BT was disabled at previous session");
 490                 if (vconf_get_int(VCONFKEY_BT_LE_STATUS, &bt_le_status) < 0)
 491                         BT_ERR("no bluetooth le info, so BT LE was disabled at previous session");
 492
 493                 BT_INFO("bt_status = %d, bt_le_status = %d", bt_status, bt_le_status);
 494
 495                 if (bt_status & VCONFKEY_BT_STATUS_ON)
 496                         __bt_core_set_status(BT_ACTIVATED);
 497                 if (bt_le_status & VCONFKEY_BT_LE_STATUS_ON)
 498                         __bt_core_set_le_status(BT_ACTIVATED);
 499         }
 500 }
 501
 502 gboolean _bt_core_enable_adapter(void)
 503 {
 504         int ret;
 505
 506         _bt_set_flightmode_request(FALSE);
 507         if (vconf_set_int(BT_OFF_DUE_TO_FLIGHT_MODE, 0) != 0)
 508                 BT_ERR("Set vconf failed");
 509
 510         ret = _bt_enable_adapter();
 511         if (ret < 0)
 512                 return FALSE;
 513         else
 514                 return TRUE;
 515 }
 516
 517 gboolean _bt_core_disable_adapter(void)
 518 {
 519         int ret;
 520
 521         _bt_set_flightmode_request(FALSE);
 522         if (vconf_set_int(BT_OFF_DUE_TO_FLIGHT_MODE, 0) != 0)
 523                 BT_ERR("Set vconf failed");
 524
 525         ret = _bt_disable_adapter();
 526         if (ret < 0)
 527                 return FALSE;
 528         else
 529                 return TRUE;
 530 }
 531
 532 gboolean _bt_core_recover_adapter(void)
 533 {
 534         int ret;
 535 #if 0
 536         int ret_le;
 537 #endif
 538         BT_INFO_C("Recover bt adapter");
 539
 540         _bt_set_flightmode_request(FALSE);
 541         if (vconf_set_int(BT_OFF_DUE_TO_FLIGHT_MODE, 0) != 0)
 542                 BT_ERR("Set vconf failed");
 543
 544         is_recovery_mode = TRUE;
 545
 546         _bt_core_update_status();
 547
 548         if (_bt_core_get_status() == BT_ACTIVATED) {
 549                 _bt_core_set_bt_status(BT_RECOVERY_MODE, 1);
 550 #ifdef TIZEN_FEATURE_BUSACT
 551                 _bt_core_service_request_adapter(BT_DISABLE_ADAPTER);
 552 #endif
 553         }
 554         if (_bt_core_get_le_status() == BT_LE_ACTIVATED) {
 555                 _bt_core_set_bt_le_status(BT_RECOVERY_MODE, 1);
 556 #ifdef TIZEN_FEATURE_BUSACT
 557                 _bt_core_service_request_adapter(BT_DISABLE_ADAPTER_LE);
 558 #endif
 559         }
 560
 561         ret = _bt_disable_adapter();
 562         if (ret < 0)
 563                 BT_ERR("_bt_disable_adapter() failed");
 564
 565 /* In platform, don't seperate BR/EDR and LE status */
 566 #if 0
 567         ret_le = _bt_disable_adapter_le();
 568         if (ret_le < 0)
 569                 BT_ERR("_bt_disable_adapter_le() failed");
 570 #endif
 571         return TRUE;
 572 }
 573
 574 gboolean _bt_core_enable_adapter_le(void)
 575 {
 576         int ret;
 577
 578         ret = _bt_enable_adapter_le();
 579         if (ret < 0)
 580                 return FALSE;
 581         else
 582                 return TRUE;
 583 }
 584
 585 gboolean _bt_core_disable_adapter_le(void)
 586 {
 587         BT_DBG("+");
 588
 589         int ret;
 590
 591         ret = _bt_disable_adapter_le();
 592         if (ret < 0)
 593                 return FALSE;
 594         else
 595                 return TRUE;
 596 }
 597
 598 gboolean __bt_core_reset_adapter(void)
 599 {
 600         /* Forcely terminate */
 601         if (__execute_command("/usr/etc/bluetooth/bt-reset-env.sh", NULL) < 0)
 602                 BT_ERR("running script failed");
 603
 604         _bt_core_terminate();
 605
 606         return TRUE;
 607 }
 608
 609 static gboolean __bt_core_enable_core_timeout_cb(gpointer data)
 610 {
 611         BT_DBG("+");
 612
 613         core_enable_timer_id = 0;
 614
 615         _bt_core_init_vconf_value();
 616
 617         return FALSE;
 618 }
 619
 620 gboolean _bt_core_enable_core(void)
 621 {
 622         BT_DBG("+");
 623
 624         _bt_core_update_status();
 625
 626         if (core_enable_timer_id > 0)
 627                 g_source_remove(core_enable_timer_id);
 628
 629         core_enable_timer_id = g_timeout_add(200, (GSourceFunc)__bt_core_enable_core_timeout_cb, NULL);
 630
 631         BT_DBG("-");
 632         return TRUE;
 633 }
 634
 635 gboolean _bt_core_set_transfer_value(gboolean value)
 636 {
 637         const char *event_val = NULL;
 638         gboolean ret = TRUE;
 639
 640         BT_DBG("value: %d", value);
 641
 642         event_val = value ? EVT_VAL_BT_TRANSFERING : EVT_VAL_BT_NON_TRANSFERING;
 643
 644         if (__bt_eventsystem_set_value(SYS_EVENT_BT_STATE, EVT_KEY_BT_TRANSFERING_STATE,
 645                                                 event_val) != ES_R_OK) {
 646                 BT_ERR("Fail to set BT state value");
 647                 ret = FALSE;
 648         }
 649
 650         if (ret == FALSE || value == FALSE) {
 651                 BT_DBG("Terminate bt-core process");
 652                 g_timeout_add(BT_CORE_IDLE_TERM_TIME, __bt_core_idle_terminate, NULL);
 653         }
 654
 655         BT_DBG("-");
 656         return ret;
 657 }
 658
 659 gboolean _bt_core_factory_test_mode(const char *type, const char *arg)
 660 {
 661
 662         char *cmd = NULL;
 663         char *arg_list[3] = { NULL, NULL, NULL };
 664
 665         BT_DBG("Test item : %s", type);
 666
 667         if (g_strcmp0(type, "Enable_RF_Test") == 0) {
 668                 cmd = "/usr/etc/bluetooth/bt-edutm-on.sh";
 669                 arg_list[0] = "bt-edutm-on.sh";
 670         } else if (g_strcmp0(type, "Disable_RF_Test") == 0) {
 671                 cmd = "/usr/etc/bluetooth/bt-edutm-off.sh";
 672                 arg_list[0] = "bt-edutm-off.sh";
 673         } else if (g_strcmp0(type, "Slave_Mode") == 0) {
 674                 cmd = "/usr/etc/bluetooth/bt-mode-slave.sh";
 675                 arg_list[0] = "bt-mode-slave.sh";
 676         } else if (g_strcmp0(type, "Master_Mode") == 0) {
 677                 cmd = "/usr/etc/bluetooth/bt-mode-master.sh";
 678                 arg_list[0] = "bt-mode-master.sh";
 679         } else if (g_strcmp0(type, "SSP_Debug_Mode") == 0) {
 680                 cmd = "/usr/etc/bluetooth/bt-set-ssp-debug-mode.sh";
 681                 arg_list[0] = "bt-set-ssp-debug-mode.sh";
 682                 arg_list[1] = (char *)arg;
 683         } else if (g_strcmp0(type, "RF_Channel") == 0) {
 684                 cmd = "/usr/etc/bluetooth/bt-enable-rf-channel.sh";
 685                 arg_list[0] = "bt-enable-rf-channel.sh";
 686                 arg_list[1] = (char *)arg;
 687         } else {
 688                 _bt_core_terminate();
 689                 return FALSE;
 690         }
 691
 692         BT_DBG("Run %s", cmd);
 693         if (__execute_command(cmd, arg_list) < 0)
 694                 BT_ERR("running script failed");
 695
 696         _bt_core_terminate();
 697         return TRUE;
 698 }
 699
 700 static gboolean __bt_core_recovery_cb(gpointer data)
 701 {
 702         int ret = 0;
 703 #ifdef TIZEN_FEATURE_BUSACT
 704         gboolean is_request_failed = FALSE;
 705         static gboolean is_first_failure = TRUE;
 706 #endif
 707
 708         BT_DBG("+");
 709
 710 #ifdef TIZEN_FEATURE_BUSACT
 711         if (_bt_core_get_bt_status(BT_RECOVERY_MODE) == 1) {
 712                 ret = _bt_core_service_request_adapter(BT_ENABLE_ADAPTER);
 713                 if (ret < 0)
 714                         is_request_failed = TRUE;
 715         }
 716
 717         if (_bt_core_get_bt_le_status(BT_RECOVERY_MODE) == 1) {
 718                 ret = _bt_core_service_request_adapter(BT_ENABLE_ADAPTER_LE);
 719                 if (ret < 0)
 720                         is_request_failed = TRUE;
 721         }
 722
 723         if (is_request_failed == TRUE) {
 724                 BT_ERR("Recovery is failed.");
 725                 if (is_first_failure == TRUE) {
 726                         g_timeout_add(2000, (GSourceFunc)__bt_core_recovery_cb, NULL);
 727                         is_first_failure = FALSE;
 728                         return FALSE;
 729                 } else {
 730                         is_first_failure = TRUE;
 731                         return FALSE;
 732                 }
 733         } else
 734                 is_first_failure = TRUE;
 735 #endif
 736
 737         if (_bt_core_get_bt_status(BT_RECOVERY_MODE) == 1) {
 738                 _bt_core_set_bt_status(BT_RECOVERY_MODE, 0);
 739                 ret = _bt_enable_adapter();
 740                 if (ret < 0)
 741                         BT_ERR("_bt_enable_adapter() failed");
 742         }
 743
 744 #if 0
 745         if (_bt_core_get_bt_le_status(BT_RECOVERY_MODE) == 1) {
 746                 _bt_core_set_bt_le_status(BT_RECOVERY_MODE, 0);
 747                 ret = _bt_enable_adapter_le();
 748                 if (ret < 0)
 749                         BT_ERR("_bt_enable_adapter_le() failed");
 750         }
 751 #endif
 752         is_recovery_mode = FALSE;
 753
 754         BT_DBG("-");
 755
 756         return FALSE;
 757 }
 758
 759 static gboolean __bt_core_enable_timeout_cb(gpointer data)
 760 {
 761         bt_status_t adapter_status;
 762         bt_le_status_t adapter_status_le;
 763
 764         BT_DBG("");
 765
 766         if (vconf_set_int(BT_OFF_DUE_TO_FLIGHT_MODE, 0) != 0)
 767                 BT_ERR("Set vconf failed");
 768
 769         adapter_status = _bt_core_get_status();
 770         adapter_status_le = _bt_core_get_le_status();
 771
 772         if (adapter_status == BT_DEACTIVATED &&
 773                         _bt_core_get_bt_status(BT_FLIGHT_MODE) != 0) {
 774                 _bt_core_set_bt_status(BT_FLIGHT_MODE, 0);
 775                 _bt_core_service_request_adapter(BT_ENABLE_ADAPTER);
 776                 _bt_enable_adapter();
 777         }
 778
 779         if (adapter_status_le == BT_LE_DEACTIVATED &&
 780                         _bt_core_get_bt_le_status(BT_FLIGHT_MODE) != 0) {
 781                 _bt_core_set_bt_le_status(BT_FLIGHT_MODE, 0);
 782                 _bt_core_service_request_adapter(BT_ENABLE_ADAPTER_LE);
 783                 _bt_enable_adapter_le();
 784         }
 785
 786         return FALSE;
 787 }
 788
 789 static gboolean __bt_core_disable_timeout_cb(gpointer data)
 790 {
 791         bt_status_t adapter_status;
 792         bt_le_status_t adapter_status_le;
 793
 794         BT_DBG("");
 795
 796         if (vconf_set_int(BT_OFF_DUE_TO_FLIGHT_MODE, 1) != 0)
 797                 BT_ERR("Set vconf failed");
 798
 799         adapter_status = _bt_core_get_status();
 800         adapter_status_le = _bt_core_get_le_status();
 801
 802         if (adapter_status == BT_ACTIVATED) {
 803                 int bt_status_before_mode = 0;
 804
 805                 if (vconf_get_int(VCONFKEY_BT_STATUS, &bt_status_before_mode) == 0)
 806                         _bt_core_set_bt_status(BT_FLIGHT_MODE, bt_status_before_mode);
 807
 808 #ifdef TIZEN_FEATURE_BUSACT
 809                 _bt_core_service_request_adapter(BT_DISABLE_ADAPTER);
 810 #endif
 811                 _bt_disable_adapter();
 812         }
 813
 814         if (adapter_status_le == BT_LE_ACTIVATED) {
 815                 int bt_le_status_before_mode = 0;
 816
 817                 if (vconf_get_int(VCONFKEY_BT_LE_STATUS, &bt_le_status_before_mode) == 0)
 818                         _bt_core_set_bt_le_status(BT_FLIGHT_MODE, bt_le_status_before_mode);
 819
 820 #ifdef TIZEN_FEATURE_BUSACT
 821                 _bt_core_service_request_adapter(BT_DISABLE_ADAPTER_LE);
 822 #endif
 823                 _bt_disable_adapter_le();
 824         }
 825
 826         return FALSE;
 827 }
 828
 829 static int __bt_eventsystem_set_value(const char *event, const char *key, const char *value)
 830 {
 831         int ret;
 832         bundle *b = NULL;
 833
 834         b = bundle_create();
 835
 836         bundle_add_str(b, key, value);
 837
 838         ret = eventsystem_send_system_event(event, b);
 839
 840         BT_DBG("eventsystem_send_system_event result: %d", ret);
 841
 842         bundle_free(b);
 843
 844         return ret;
 845 }
 846
 847 void _bt_core_adapter_added_cb(void)
 848 {
 849         bt_status_t status;
 850         bt_le_status_t le_status;
 851         gboolean flight_mode_status;
 852
 853         BT_DBG("");
 854
 855         status = _bt_core_get_status();
 856         BT_DBG("status : %d", status);
 857         le_status = _bt_core_get_le_status();
 858         BT_DBG("le_status : %d", le_status);
 859
 860         if (status == BT_ACTIVATING)
 861                 __bt_core_set_status(BT_ACTIVATED);
 862         if (le_status == BT_LE_ACTIVATING)
 863                 __bt_core_set_le_status(BT_LE_ACTIVATED);
 864
 865         flight_mode_status = _bt_core_is_flight_mode_enabled();
 866
 867         if (flight_mode_status == TRUE && _bt_is_flightmode_request() == TRUE) {
 868                 _bt_set_flightmode_request(FALSE);
 869                 g_timeout_add(2000, (GSourceFunc)__bt_core_disable_timeout_cb, NULL);
 870                 return;
 871         }
 872         _bt_set_flightmode_request(FALSE);
 873
 874         if (__bt_eventsystem_set_value(SYS_EVENT_BT_STATE, EVT_KEY_BT_STATE,
 875                                                 EVT_VAL_BT_ON) != ES_R_OK)
 876                 BT_ERR("Fail to set BT state value");
 877
 878         if (__bt_eventsystem_set_value(SYS_EVENT_BT_STATE, EVT_KEY_BT_LE_STATE,
 879                                                 EVT_VAL_BT_LE_ON) != ES_R_OK)
 880                 BT_ERR("Fail to set BT LE state value");
 881
 882         _bt_core_terminate();
 883 }
 884
 885 void _bt_core_adapter_removed_cb(void)
 886 {
 887         int flight_mode_value = 0;
 888         int power_saving_mode = 0;
 889         gboolean flight_mode_status;
 890         static int timer_id = -1;
 891
 892         BT_DBG("is_recovery_mode: %d", is_recovery_mode);
 893
 894         __bt_core_set_status(BT_DEACTIVATED);
 895         __bt_core_set_le_status(BT_LE_DEACTIVATED);
 896         if (vconf_set_int(VCONFKEY_BT_STATUS, VCONFKEY_BT_STATUS_OFF) != 0)
 897                 BT_ERR("Set vconf failed");
 898         if (vconf_set_int(VCONFKEY_BT_LE_STATUS, VCONFKEY_BT_LE_STATUS_OFF) != 0)
 899                 BT_ERR("Set vconf failed");
 900
 901         if (__bt_eventsystem_set_value(SYS_EVENT_BT_STATE, EVT_KEY_BT_STATE,
 902                                                 EVT_VAL_BT_OFF) != ES_R_OK)
 903                 BT_ERR("Fail to set value");
 904
 905         if (__bt_eventsystem_set_value(SYS_EVENT_BT_STATE, EVT_KEY_BT_LE_STATE,
 906                                                 EVT_VAL_BT_LE_OFF) != ES_R_OK)
 907                 BT_ERR("Fail to set value");
 908
 909         if (is_recovery_mode == TRUE) {
 910                 if (timer_id < 0)
 911                         timer_id = g_timeout_add(2000, (GSourceFunc)__bt_core_recovery_cb, NULL);
 912                 return;
 913         }
 914
 915         if (vconf_get_int(BT_OFF_DUE_TO_FLIGHT_MODE, &flight_mode_value) != 0)
 916                 BT_ERR("Fail to get the flight_mode_deactivated value");
 917
 918         if (vconf_get_int(BT_OFF_DUE_TO_POWER_SAVING_MODE, &power_saving_mode) != 0)
 919                 BT_ERR("Fail to get the ps_mode_deactivated value");
 920
 921         flight_mode_status = _bt_core_is_flight_mode_enabled();
 922
 923         if (flight_mode_status == FALSE && _bt_is_flightmode_request() == TRUE) {
 924                 _bt_set_flightmode_request(FALSE);
 925                 if (timer_id < 0)
 926                         timer_id = g_timeout_add(2000, (GSourceFunc)__bt_core_enable_timeout_cb, NULL);
 927                 return;
 928         }
 929         _bt_set_flightmode_request(FALSE);
 930
 931         if (flight_mode_value == 1 || power_saving_mode == 1) {
 932                 BT_DBG("Bt Core not terminated");
 933                 return;
 934         }
 935
 936         _bt_core_terminate();
 937 }