src/setting-bluetooth.c

   1 /*
   2  *  Copyright (c) 2014 Samsung Electronics Co., Ltd.
   3  *
   4  *  Licensed under the Flora License, Version 1.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://floralicense.org/license/
   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  * setting-bluetooth.c
  19  *
  20  *  Created on: Oct 9, 2013
  21  *      Author: min-hoyun
  22  */
  23
  24 #include <feedback.h>
  25
  26 #include "setting-bluetooth.h"
  27 #include "setting_control_bt.h"
  28 #include "setting_data_vconf.h"
  29 #include "setting-common-sound.h"
  30 #include "util.h"
  31
  32
  33 static struct _bt_menu_item bt_menu_its[] = {
  34         { "IDS_QP_BUTTON_BLUETOOTH",            DISABLE, _blutooth_cb           },
  35         { "IDS_VCALL_BODY_BT_HEADSET",          DISABLE, _BT_headset_cb         },
  36         { "IDS_ST_MBODY_MAKE_VISIBLE_ABB",      DISABLE, _visibility_cb         },      /* "IDS_OP_BODY_VISIBILITY" */
  37         { NULL, DISABLE, NULL }
  38 };
  39
  40 static char *bluetooth_enable_str[] = {
  41         "IDS_ST_BODY_OFF_M_STATUS",
  42         "IDS_ST_BODY_ON_M_STATUS",
  43         "IDS_COM_POP_PROCESSING"
  44 };
  45
  46 static char *visible_str[] = {
  47         "IDS_ST_BODY_DISABLED_M_STATUS",
  48         "IDS_ST_BODY_YOUR_GEAR_IS_VISIBLE_FOR_PS_ABB"
  49 };
  50
  51
  52 static Ecore_Timer *bt_timer = NULL;
  53 static Ecore_Timer *vb_timer = NULL;
  54
  55 static Elm_Object_Item *bt_it = NULL;
  56 static Elm_Object_Item *vb_it = NULL;
  57 static Elm_Object_Item *hf_it = NULL;
  58
  59 static Evas_Object *bt_genlist = NULL;
  60 static Evas_Object *g_bt_check = NULL;
  61 static Evas_Object *g_vb_check = NULL;
  62
  63 static int is_bt_operating = BT_NON_OPERATING;
  64 static int timeout_seconds = VISIBILITY_TIMEOUT;
  65 static bt_adapter_visibility_mode_e visibility_mode = BT_ADAPTER_VISIBILITY_MODE_NON_DISCOVERABLE;
  66 static int origin_bt_enable;
  67 static double bt_time = 0.0;
  68 static int is_connected_hf = FALSE;
  69 static char *g_device_name = NULL;
  70
  71
  72 static void _init_bt_value();
  73 static int is_handsfree_connected();
  74 static void _bt_genlist_update();
  75 static int is_disable_visibility_item_view();
  76 static void _update_visibility_view();
  77
  78
  79 static void sap_state_vconf_change_cb(keynode_t *key, void *data)
  80 {
  81         _update_visibility_item_view(is_handsfree_connected());
  82 }
  83
  84 static void _bt_adapter_state_enabled_cb(int result, bt_adapter_state_e adapter_state, void *user_data)
  85 {
  86         DBG("Setting - _bt_adapter_state_enabled_cb() is called!");
  87
  88         if (adapter_state == BT_ADAPTER_ENABLED) {
  89                 DBG("Setting - BT adapter state : BT_ADAPTER_ENABLED");
  90
  91                 bt_menu_its[BT_MENU_TYPE_BT_ON_OFF].is_enable = 1;
  92
  93                 _bt_genlist_update();
  94         } else if (adapter_state == BT_ADAPTER_DISABLED) {
  95                 DBG("Setting - BT adapter state : BT_ADAPTER_DISABLED");
  96
  97                 bt_menu_its[BT_MENU_TYPE_BT_ON_OFF].is_enable = 0;
  98                 is_connected_hf = FALSE;
  99
 100                 _bt_genlist_update();
 101         }
 102         _init_bt_value();
 103 }
 104
 105 void initialize_bt()
 106 {
 107         DBG("Setting - initialize_bt()");
 108
 109         if (bt_initialize() != BT_ERROR_NONE) {
 110                 ERR("Setting - bt_initialize() is failed....");
 111                 return;
 112         }
 113         DBG("Setting - bt_initialize() is success");
 114
 115         if (bt_adapter_set_state_changed_cb(_bt_adapter_state_enabled_cb, NULL) != BT_ERROR_NONE) {
 116                 ERR("[%s] bt_adapter_set_state_changed_cb() failed.", __FUNCTION__);
 117                 return;
 118         } else {
 119                 DBG("bt_adapter_set_state_changed_cb() is success!");
 120         }
 121
 122         bluetooth_hf_init(hf_event_handler, NULL);
 123
 124         register_vconf_changing("memory/private/sap/conn_status", sap_state_vconf_change_cb, NULL);
 125
 126         int ret;
 127         ret = feedback_initialize();
 128         if (ret != FEEDBACK_ERROR_NONE) {
 129                 DBG("feedback_initialize failed");
 130         }
 131 }
 132
 133 Eina_Bool _clear_bluetooth_cb(void *data, Elm_Object_Item *it)
 134 {
 135         clear_bt_resource();
 136
 137         return EINA_TRUE;
 138 }
 139
 140 static void _disable_visibility_item_view()
 141 {
 142         bt_menu_its[BT_MENU_TYPE_VISIBLE_ON_OFF].is_enable = DISABLE;
 143         timeout_seconds = VISIBILITY_TIMEOUT;
 144
 145         _update_visibility_view();
 146 }
 147
 148 static void hf_event_handler(int event, void *data, void *user_data)
 149 {
 150         switch (event) {
 151         case BLUETOOTH_EVENT_HF_CONNECTED:
 152                 DBG("Setting - BLUETOOTH_EVENT_HF_CONNECTED");
 153                 _update_visibility_item_view(TRUE);
 154                 break;
 155
 156         case BLUETOOTH_EVENT_HF_DISCONNECTED:
 157                 DBG("Setting - BLUETOOTH_EVENT_HF_DISCONNECTED");
 158                 _update_visibility_item_view(is_handsfree_connected());
 159                 break;
 160         }
 161 }
 162
 163 void _update_visibility_item_view(int is_hf_connected)
 164 {
 165         DBG("Setting - _update_view() is called!!");
 166
 167         if (is_hf_connected) {
 168                 is_connected_hf = TRUE;
 169
 170                 if (vb_timer) {
 171                         ecore_timer_del(vb_timer);
 172                         vb_timer = NULL;
 173                 }
 174
 175                 bt_menu_its[BT_MENU_TYPE_VISIBLE_ON_OFF].is_enable = DISABLE;
 176                 timeout_seconds = VISIBILITY_TIMEOUT;
 177
 178                 _update_visibility_view();
 179         } else {
 180                 is_connected_hf = FALSE;
 181
 182                 _update_visibility_view();
 183         }
 184 }
 185
 186 void clear_bt_resource()
 187 {
 188         bt_menu_its[BT_MENU_TYPE_BT_ON_OFF].is_enable = DISABLE;
 189         is_bt_operating = BT_NON_OPERATING;
 190
 191         if (timeout_seconds == 0 && vb_timer) {
 192                 ecore_timer_del(vb_timer);
 193                 vb_timer = NULL;
 194
 195                 bt_menu_its[BT_MENU_TYPE_VISIBLE_ON_OFF].is_enable = DISABLE;
 196                 timeout_seconds = VISIBILITY_TIMEOUT;
 197         }
 198
 199         bluetooth_hf_deinit();
 200
 201         int ret = bt_adapter_unset_state_changed_cb();
 202
 203         if (ret != BT_ERROR_NONE) {
 204                 ERR("Setting - bt adapter unset state changed cb is fail");
 205         }
 206
 207         if (bt_deinitialize() < 0) {
 208                 ERR("Setting - bt_deinitialize() failed.");
 209                 return;
 210         }
 211         DBG("Setting - bt_deinitialize() is success");
 212
 213         bt_genlist = NULL;
 214         vb_it = NULL;
 215         bt_it = NULL;
 216         g_bt_check = NULL;
 217         g_vb_check = NULL;
 218
 219         /* Unregister SAP status vconf changeing callback */
 220         unregister_vconf_changing("memory/private/sap/conn_status", sap_state_vconf_change_cb);
 221
 222         ret = feedback_deinitialize();
 223         if (ret != FEEDBACK_ERROR_NONE) {
 224                 DBG("feedback_deinitialize failed");
 225         }
 226 }
 227
 228 static void _init_bt_value()
 229 {
 230         bt_timer = NULL;
 231         bt_time = 0.0;
 232         timeout_seconds = VISIBILITY_TIMEOUT;
 233         bt_menu_its[BT_MENU_TYPE_VISIBLE_ON_OFF].is_enable = DISABLE;
 234         is_bt_operating = BT_NON_OPERATING;
 235 }
 236
 237 static void _alternate_bt_mode(void *data)
 238 {
 239         int ret = 0;
 240         bt_adapter_state_e value;
 241
 242         /*appdata * ad = data; */
 243
 244         int prev_bt_enable = bt_menu_its[BT_MENU_TYPE_BT_ON_OFF].is_enable;
 245         bt_menu_its[BT_MENU_TYPE_BT_ON_OFF].is_enable = 2;
 246         if (bt_it != NULL) {
 247                 elm_genlist_item_fields_update(bt_it, "elm.text.2", ELM_GENLIST_ITEM_FIELD_TEXT);
 248                 elm_check_state_set(g_bt_check, !prev_bt_enable);
 249                 edje_object_signal_emit(elm_layout_edje_get(g_bt_check), "elm,state,disabled", "elm");
 250         }
 251
 252         if (bt_adapter_get_state(&value) != BT_ERROR_NONE) {
 253                 ERR("Setting - bt_adapter_get_state() is failed ");
 254                 _init_bt_value();
 255                 return;
 256         }
 257
 258         if (value == EINA_TRUE) {
 259                 DBG("Setting - Current bt is on....disable...");
 260
 261                 bt_menu_its[BT_MENU_TYPE_BT_ON_OFF].is_enable = 0;
 262                 is_connected_hf = TRUE;
 263                 _disable_visibility_item_view();
 264
 265                 if (hf_it) {
 266                         elm_genlist_item_update(hf_it);
 267                 }
 268
 269                 ret = bt_adapter_disable();
 270
 271                 timeout_seconds = 0;    /* vb_timer stop!! */
 272         } else {
 273                 DBG("Setting - Current bt is off....enable...");
 274                 ret = bt_adapter_enable();
 275         }
 276
 277         if (ret != BT_ERROR_NONE) {
 278                 DBG("Setting - Enalbe or Disable failed.... : %d", ret);
 279
 280                 bt_menu_its[BT_MENU_TYPE_BT_ON_OFF].is_enable = origin_bt_enable;
 281
 282                 _bt_genlist_update();
 283                 _init_bt_value();
 284
 285                 return;
 286         }
 287 }
 288
 289 static void _blutooth_cb(void *data, Evas_Object *obj, void *event_info)
 290 {
 291         DBG("Setting - %s", "Setting - _blutooth_cb is called");
 292
 293         Elm_Object_Item *it = (Elm_Object_Item *)event_info;
 294         elm_genlist_item_selected_set(it, EINA_FALSE);
 295
 296         if (is_bt_operating == BT_OPERATING) {
 297                 DBG("Setting - _blutooth_cb() is same status ");
 298
 299                 return;
 300         }
 301         is_bt_operating = BT_OPERATING;
 302
 303         appdata *ad = data;
 304         if (ad == NULL) {
 305                 DBG("%s", "Setting - _blutooth_cb - ad or check is null");
 306                 return;
 307         }
 308
 309         /* previous state backup */
 310         origin_bt_enable = bt_menu_its[BT_MENU_TYPE_BT_ON_OFF].is_enable;
 311
 312         if (vb_timer != NULL && vb_it != NULL) {
 313                 DBG("Setting - vb_it is disabled");
 314
 315                 bt_menu_its[BT_MENU_TYPE_VISIBLE_ON_OFF].is_enable = DISABLE;
 316                 timeout_seconds = 0;
 317
 318                 ecore_timer_del(vb_timer);
 319                 vb_timer = NULL;
 320
 321                 _update_visibility_view();
 322
 323                 /*elm_genlist_item_update(vb_it); */
 324         }
 325
 326         _alternate_bt_mode(data);
 327 }
 328
 329 static int is_valid_timeout(int seconds)
 330 {
 331         return ((seconds > 0) && (seconds <= VISIBILITY_TIMEOUT));
 332 }
 333
 334 static void _bt_genlist_update()
 335 {
 336         if (bt_it) {
 337                 elm_genlist_item_fields_update(bt_it, "elm.text.2", ELM_GENLIST_ITEM_FIELD_TEXT);
 338
 339                 int bt_enable = bt_menu_its[BT_MENU_TYPE_BT_ON_OFF].is_enable;
 340                 edje_object_signal_emit(elm_layout_edje_get(g_bt_check), "elm,state,enabled", "elm");
 341                 elm_check_state_set(g_bt_check, (bt_enable == 1) ? EINA_TRUE : EINA_FALSE);
 342         }
 343         if (hf_it) {
 344                 elm_genlist_item_update(hf_it);
 345         }
 346         if (vb_it) {
 347                 elm_genlist_item_fields_update(vb_it, "elm.text.1", ELM_GENLIST_ITEM_FIELD_TEXT);
 348                 elm_genlist_item_fields_update(vb_it, "elm.text.2", ELM_GENLIST_ITEM_FIELD_TEXT);
 349
 350                 elm_check_state_set(g_vb_check, (bt_menu_its[BT_MENU_TYPE_VISIBLE_ON_OFF].is_enable == 1) ? EINA_TRUE : EINA_FALSE);
 351
 352                 if (is_disable_visibility_item_view()) {
 353                         edje_object_signal_emit(elm_layout_edje_get(g_vb_check), "elm,state,disabled", "elm");
 354                 } else {
 355                         edje_object_signal_emit(elm_layout_edje_get(g_vb_check), "elm,state,enabled", "elm");
 356                 }
 357         }
 358 }
 359
 360 static void _update_visibility_view()
 361 {
 362         DBG("Setting - _update_visibility_view()");
 363
 364         if (vb_it) {
 365                 elm_genlist_item_fields_update(vb_it, "elm.text.1", ELM_GENLIST_ITEM_FIELD_TEXT);
 366                 elm_genlist_item_fields_update(vb_it, "elm.text.2", ELM_GENLIST_ITEM_FIELD_TEXT);
 367
 368                 elm_check_state_set(g_vb_check, (bt_menu_its[BT_MENU_TYPE_VISIBLE_ON_OFF].is_enable == TRUE)
 369                                                         ? EINA_TRUE : EINA_FALSE);
 370
 371                 if (is_disable_visibility_item_view()) {
 372                         edje_object_signal_emit(elm_layout_edje_get(g_vb_check), "elm,state,disabled", "elm");
 373                 } else {
 374                         edje_object_signal_emit(elm_layout_edje_get(g_vb_check), "elm,state,enabled", "elm");
 375                 }
 376         }
 377 }
 378
 379 static void _update_visibility_item_update(void *data)
 380 {
 381         appdata *ad = data;
 382         if (ad == NULL) {
 383                 DBG("Setting - ad is null.");
 384                 return;
 385         }
 386
 387         if (ad->MENU_TYPE == SETTING_BLUETOOTH) {
 388                 DBG("Setting - update_visibility_item_update");
 389
 390                 _update_visibility_view();
 391                 /*_bt_genlist_update(); */
 392         }
 393 }
 394
 395 static void _init_vb_data(void *data)
 396 {
 397         bt_menu_its[BT_MENU_TYPE_VISIBLE_ON_OFF].is_enable = DISABLE;
 398         timeout_seconds = VISIBILITY_TIMEOUT;
 399         _update_visibility_item_update(data);
 400         vb_timer = NULL;
 401 }
 402
 403 static Eina_Bool __vb_timeout(void *data)
 404 {
 405         if (is_valid_timeout(timeout_seconds)) {
 406                 DBG("Setting - %d seconds", timeout_seconds);
 407
 408                 --timeout_seconds;
 409
 410                 _update_visibility_item_update(data);
 411
 412                 return ECORE_CALLBACK_RENEW;
 413         }
 414
 415         bt_menu_its[BT_MENU_TYPE_VISIBLE_ON_OFF].is_enable = DISABLE;
 416         _update_visibility_item_update(data);
 417
 418         DBG("Setting - visibility time is out.");
 419
 420         if (visibility_mode != BT_ADAPTER_VISIBILITY_MODE_NON_DISCOVERABLE) {
 421                 if (bt_adapter_set_visibility(BT_ADAPTER_VISIBILITY_MODE_NON_DISCOVERABLE, 0) != BT_ERROR_NONE) {
 422                         DBG("[%s] Setting - bt_adapter_set_visibility(NON) failed.", __FUNCTION__);
 423                         _init_vb_data(data);
 424                         return ECORE_CALLBACK_CANCEL;
 425                 }
 426                 visibility_mode = BT_ADAPTER_VISIBILITY_MODE_NON_DISCOVERABLE;
 427                 DBG("[%s] Setting - bt_adapter_set_visibility(NON) success.", __FUNCTION__);
 428         }
 429
 430         _init_vb_data(data);
 431
 432         return ECORE_CALLBACK_CANCEL;
 433 }
 434
 435 static void _start_visibility_timer(void *data)
 436 {
 437         if (vb_timer) { /* Timer Start */
 438                 ecore_timer_del(vb_timer);
 439                 vb_timer = NULL;
 440         }
 441         vb_timer = ecore_timer_add(1.0, (Ecore_Task_Cb) __vb_timeout, data);
 442 }
 443
 444 static void _bt_visibility_mode(void *data)
 445 {
 446         bt_adapter_state_e bt_state;
 447
 448         if (bt_adapter_get_state(&bt_state) != BT_ERROR_NONE) {
 449                 DBG("[%s] Setting - bt_adapter_get_state() failed.", __FUNCTION__);
 450                 return;
 451         }
 452
 453         int state = DISABLE;
 454         vconf_get_int(VCONFKEY_BT_STATUS, &state);
 455
 456         DBG("Setting - bt state : %d", state);
 457
 458         if (bt_state == BT_ADAPTER_ENABLED) {
 459                 if (bt_adapter_get_visibility(&visibility_mode, NULL) != BT_ERROR_NONE) {
 460                         DBG("[%s] Setting - bt_adapter_get_visibility() failed.", __FUNCTION__);
 461                         return;
 462                 }
 463
 464                 DBG("Setting - visibility_mode : %d", visibility_mode);
 465
 466                 if (visibility_mode == BT_ADAPTER_VISIBILITY_MODE_NON_DISCOVERABLE) {
 467                         if (bt_adapter_set_visibility(BT_ADAPTER_VISIBILITY_MODE_GENERAL_DISCOVERABLE, 0) != BT_ERROR_NONE) {
 468                                 DBG("[%s] Setting - bt_adapter_set_visibility(VISIBLE) failed.", __FUNCTION__);
 469                         } else {
 470                                 visibility_mode = BT_ADAPTER_VISIBILITY_MODE_GENERAL_DISCOVERABLE;
 471                                 DBG("[%s] Setting - bt_adapter_set_visibility(VISIBLE) success.", __FUNCTION__);
 472
 473                                 bt_menu_its[BT_MENU_TYPE_VISIBLE_ON_OFF].is_enable = ENABLE;
 474                                 timeout_seconds = VISIBILITY_TIMEOUT;
 475
 476                                 _update_visibility_view();
 477
 478                                 _start_visibility_timer(data);  /* Timer start */
 479                         }
 480                 } else if (visibility_mode == BT_ADAPTER_VISIBILITY_MODE_GENERAL_DISCOVERABLE) {
 481                         DBG("[%s] Setting - Visibility mode was already set as BT_ADAPTER_VISIBILITY_MODE_GENERAL_DISCOVERABLE.", __FUNCTION__);
 482
 483                         timeout_seconds = 0;    /* Timer stop; */
 484
 485                         if (bt_adapter_set_visibility(BT_ADAPTER_VISIBILITY_MODE_NON_DISCOVERABLE, 0) != BT_ERROR_NONE) {
 486                                 DBG("[%s] Setting - bt_adapter_set_visibility(NON) failed.", __FUNCTION__);
 487                         } else {
 488                                 visibility_mode = BT_ADAPTER_VISIBILITY_MODE_NON_DISCOVERABLE;
 489                                 DBG("[%s] Setting - bt_adapter_set_visibility(NON) success.", __FUNCTION__);
 490                         }
 491                 }
 492         }
 493 }
 494
 495 static int is_disable_visibility_item_view()
 496 {
 497         return (!bt_menu_its[BT_MENU_TYPE_BT_ON_OFF].is_enable || is_connected_hf);
 498 }
 499
 500 static void _visibility_cb(void *data, Evas_Object *obj, void *event_info)
 501 {
 502         DBG("%s", "Setting - _visibility_cb is called");
 503
 504         Elm_Object_Item *it = (Elm_Object_Item *)event_info;
 505         elm_genlist_item_selected_set(it, EINA_FALSE);
 506
 507         bool touch_sound_enable = false;
 508         if (get_sound_mode() == SOUND_MODE_SOUND) {
 509                 vconf_get_bool(VCONFKEY_SETAPPL_TOUCH_SOUNDS_BOOL, &touch_sound_enable);
 510                 if (touch_sound_enable) {
 511                         feedback_play(FEEDBACK_PATTERN_TOUCH_TAP);
 512                 }
 513         }
 514
 515         if (is_disable_visibility_item_view()) {
 516                 DBG("Setting - disable visibility!!");
 517                 return;
 518         }
 519
 520         appdata *ad = data;
 521         if (ad == NULL) {
 522                 DBG("%s", "Setting - _visibility_cb - ad or check is null");
 523                 return;
 524         }
 525
 526         _bt_visibility_mode(data);
 527 }
 528
 529 static int _is_enable_BT_headset()
 530 {
 531         int enable = FALSE;
 532
 533         vconf_get_int(VCONFKEY_BT_STATUS, &enable);
 534
 535         return (enable != VCONFKEY_BT_STATUS_OFF) && bt_menu_its[BT_MENU_TYPE_BT_ON_OFF].is_enable;
 536 }
 537
 538 static void _BT_headset_cb(void *data, Evas_Object *obj, void *event_info)
 539 {
 540         DBG("%s", "Setting - _BT_headset_cb is called");
 541
 542         Elm_Object_Item *it = (Elm_Object_Item *)event_info;
 543         elm_genlist_item_selected_set(it, EINA_FALSE);
 544
 545         if (!_is_enable_BT_headset())
 546                 return;
 547
 548         app_control_h service;
 549         app_control_create(&service);
 550         app_control_set_app_id(service, "org.tizen.bluetooth");
 551         app_control_add_extra_data(service, "launch-type", "setting");
 552         app_control_send_launch_request(service, NULL, NULL);
 553         app_control_destroy(service);
 554 }
 555
 556 static char *_get_device_name()
 557 {
 558         char *bt_adapter_name = NULL;
 559
 560 #if 0
 561         bt_adapter_state_e bt_state;
 562         if (bt_adapter_get_state(&bt_state) != BT_ERROR_NONE) {
 563                 DBG("[%s] Setting - bt_adapter_get_state() failed.", __FUNCTION__);
 564                 return NULL;
 565         }
 566         if (bt_adapter_get_name(&bt_adapter_name) != BT_ERROR_NONE) {
 567                 ERR("%s,%d: bt get name fail", __func__, __LINE__);
 568                 return NULL;
 569         }
 570 #endif
 571         bt_adapter_name = vconf_get_str(VCONFKEY_SETAPPL_DEVICE_NAME_STR);
 572
 573         return strdup(bt_adapter_name);
 574 }
 575
 576 static char *_gl_bt_title_get(void *data, Evas_Object *obj, const char *part)
 577 {
 578         char buf[1024] = {0,};
 579         Bt_Item_Data *id = data;
 580         int index = id->index;
 581         char expression[32];
 582
 583         if (!strcmp(part, "elm.text.1") || !strcmp(part, "elm.text")) {
 584                 if (index == BT_MENU_TYPE_BT_ON_OFF) {
 585                         snprintf(buf, sizeof(buf) - 1, "%s", _(bt_menu_its[BT_MENU_TYPE_BT_ON_OFF].name));
 586                 } else if (index == BT_MENU_TYPE_VISIBLE_ON_OFF) {
 587                         if (is_disable_visibility_item_view()) {
 588                                 strcpy(expression, "<font color=#515151>%s</font>");
 589                         } else {
 590                                 strcpy(expression, "%s");
 591                         }
 592                         snprintf(buf, sizeof(buf) - 1, expression, _(bt_menu_its[BT_MENU_TYPE_VISIBLE_ON_OFF].name));
 593                 } else {
 594                         if (!_is_enable_BT_headset()) {
 595                                 strcpy(expression, "<font color=#515151>%s</font>");
 596                         } else {
 597                                 strcpy(expression, "%s");
 598                         }
 599                         snprintf(buf, sizeof(buf) - 1, expression, _(bt_menu_its[BT_MENU_TYPE_BT_HEADSET].name));
 600                 }
 601         } else if (!strcmp(part, "elm.text.2")) {
 602                 if (index == BT_MENU_TYPE_BT_ON_OFF) {
 603                         DBG("BT item subtitle updated!!");
 604                         int sub_title_type = bt_menu_its[BT_MENU_TYPE_BT_ON_OFF].is_enable;
 605                         char *subtitle = _(bluetooth_enable_str[sub_title_type]);
 606                         snprintf(buf, sizeof(buf) - 1, "%s", subtitle);
 607                 } else if (index == BT_MENU_TYPE_VISIBLE_ON_OFF) {
 608                         if (is_disable_visibility_item_view()) {
 609                                 strcpy(expression, "<font color=#515151>%s</font>");
 610
 611                                 if (g_device_name == NULL) {
 612                                         g_device_name = _get_device_name();
 613                                         if (g_device_name == NULL) {
 614                                                 g_device_name = _(visible_str[bt_menu_its[BT_MENU_TYPE_VISIBLE_ON_OFF].is_enable]);
 615                                         }
 616                                 }
 617
 618                                 snprintf(buf, sizeof(buf) - 1, expression, g_device_name);
 619                         } else {
 620                                 if (bt_menu_its[BT_MENU_TYPE_VISIBLE_ON_OFF].is_enable) {
 621                                         int hour = timeout_seconds / 60;
 622                                         int minutes = timeout_seconds % 60;
 623
 624                                         char time_buf[16] = {0,};
 625                                         snprintf(time_buf, sizeof(time_buf) - 1, "%02d:%02d", hour, minutes);
 626
 627                                         snprintf(buf, sizeof(buf) - 1, _(visible_str[bt_menu_its[BT_MENU_TYPE_VISIBLE_ON_OFF].is_enable]), time_buf);
 628                                 } else {
 629                                         g_device_name = _get_device_name();
 630                                         if (g_device_name == NULL) {
 631                                                 g_device_name = _(visible_str[bt_menu_its[BT_MENU_TYPE_VISIBLE_ON_OFF].is_enable]);
 632                                         }
 633
 634                                         snprintf(buf, sizeof(buf) - 1, "%s", g_device_name);
 635                                 }
 636                         }
 637                 }
 638         }
 639         return strdup(buf);
 640 }
 641 #if 0
 642 static Evas_Object *_get_emtpy_layout(Evas_Object *parent)
 643 {
 644         if (parent == NULL)
 645                 return NULL;
 646
 647         Evas_Object *layout = elm_layout_add(parent);
 648         elm_layout_file_set(layout, EDJE_PATH, "setting-empty/swallow");
 649
 650         return layout;
 651 }
 652 #endif
 653
 654 static Evas_Object *_gl_bt_check_get(void *data, Evas_Object *obj, const char *part)
 655 {
 656         Evas_Object *check = NULL;
 657
 658         Bt_Item_Data *id = data;
 659         int index = id->index;
 660
 661         if (!strcmp(part, "elm.icon")) {
 662                 check = elm_check_add(obj);
 663                 elm_object_style_set(check, "list");
 664                 elm_check_state_set(check, (bt_menu_its[index].is_enable == TRUE) ? EINA_TRUE : EINA_FALSE);
 665                 evas_object_size_hint_align_set(check, EVAS_HINT_FILL, EVAS_HINT_FILL);
 666                 evas_object_size_hint_weight_set(check, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
 667                 evas_object_propagate_events_set(check, EINA_FALSE);
 668                 evas_object_repeat_events_set(check, EINA_TRUE);
 669
 670                 if (index == BT_MENU_TYPE_VISIBLE_ON_OFF) {
 671                         if (is_disable_visibility_item_view()) {
 672                                 edje_object_signal_emit(elm_layout_edje_get(check), "elm,state,disabled", "elm");
 673                         }
 674                         g_vb_check = check;
 675                 } else if (index == BT_MENU_TYPE_BT_ON_OFF) {
 676                         g_bt_check = check;
 677                 }
 678         }
 679         return check;
 680 }
 681
 682 static void _bt_gl_del(void *data, Evas_Object *obj)
 683 {
 684         Bt_Item_Data *id = data;
 685         if (id)
 686                 free(id);
 687 }
 688
 689 static void init_values()
 690 {
 691         if (!vb_timer) {
 692                 bt_menu_its[BT_MENU_TYPE_VISIBLE_ON_OFF].is_enable = DISABLE;
 693         }
 694 }
 695
 696 static int is_handsfree_connected()
 697 {
 698         int ret = FALSE;
 699         int headset_connected = FALSE;
 700         int sap_connected = FALSE;
 701
 702         vconf_get_int(VCONFKEY_BT_DEVICE, &headset_connected);
 703         DBG("Heaadset connected : %x", headset_connected);
 704
 705         if (headset_connected & VCONFKEY_BT_DEVICE_AG_CONNECTED) {
 706                 DBG("Setting - Heaadset connected");
 707                 return TRUE;
 708         }
 709
 710         vconf_get_int("memory/private/sap/conn_status", &sap_connected);
 711         DBG("Sap connected : %d", sap_connected);
 712
 713         if (sap_connected) {
 714                 DBG("Setting - Sap connected");
 715                 return TRUE;
 716         }
 717
 718         return ret;
 719 }
 720
 721 static int is_add_BT_headset()
 722 {
 723         /* temporary code!! */
 724         /* this code will be changed!! */
 725         return TRUE;
 726 }
 727
 728 static int is_BT_enable()
 729 {
 730         int enable = DISABLE;
 731
 732         if (bt_adapter_get_state(&enable) != BT_ERROR_NONE) {
 733                 ERR("Setting - bt_adapter_get_state() is failed ");
 734                 _init_bt_value();
 735                 enable = DISABLE;
 736         }
 737
 738         return enable;
 739 }
 740
 741 Evas_Object *_create_bt_list(void *data)
 742 {
 743         appdata *ad = data;
 744         if (ad == NULL) {
 745                 DBG("%s", "_create_bluetooth_list - appdata is null");
 746                 return NULL;
 747         }
 748
 749         Evas_Object *genlist  = NULL;
 750         struct _bt_menu_item *menu_its = NULL;
 751         Elm_Genlist_Item_Class *temp_itc = NULL;
 752         int idx = 0;
 753
 754         init_values();
 755
 756         bt_menu_its[BT_MENU_TYPE_BT_ON_OFF].is_enable = is_BT_enable();
 757
 758         DBG("Setting - BT status is %d", bt_menu_its[BT_MENU_TYPE_BT_ON_OFF].is_enable);
 759
 760         if (bt_menu_its[BT_MENU_TYPE_BT_ON_OFF].is_enable > 1) {
 761                 bt_menu_its[BT_MENU_TYPE_BT_ON_OFF].is_enable = ENABLE;
 762         }
 763
 764         if (bt_menu_its[BT_MENU_TYPE_BT_ON_OFF].is_enable) {
 765                 is_connected_hf = is_handsfree_connected();
 766         } else {
 767                 is_connected_hf = FALSE;
 768         }
 769
 770         elm_theme_extension_add(NULL, EDJE_PATH);
 771         Elm_Genlist_Item_Class *itc = elm_genlist_item_class_new();
 772         itc->item_style = "2text.1icon.1";
 773         itc->func.text_get = _gl_bt_title_get;
 774         itc->func.content_get = _gl_bt_check_get;
 775         itc->func.del = _bt_gl_del;
 776
 777         Elm_Genlist_Item_Class *itc2 = elm_genlist_item_class_new();
 778         itc2->item_style = "1text";
 779         itc2->func.text_get = _gl_bt_title_get;
 780         itc2->func.del = _bt_gl_del;
 781
 782         Elm_Genlist_Item_Class *itc3 = elm_genlist_item_class_new();
 783         itc3->item_style = "multiline.2text.1icon";
 784         itc3->func.text_get = _gl_bt_title_get;
 785         itc3->func.content_get = _gl_bt_check_get;
 786         itc3->func.del = _bt_gl_del;
 787
 788         Evas_Object *layout = elm_layout_add(ad->nf);
 789         elm_layout_file_set(layout, EDJE_PATH, "setting/genlist/layout");
 790         evas_object_size_hint_weight_set(layout, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
 791
 792         genlist = elm_genlist_add(layout);
 793         elm_genlist_block_count_set(genlist, 14);
 794         elm_genlist_mode_set(genlist, ELM_LIST_COMPRESS);
 795
 796         menu_its = bt_menu_its;
 797
 798         Elm_Genlist_Item_Class *itc_arr[3] = { itc, itc2, itc3 };
 799
 800         for (idx = 0; idx < BT_LIST_ITEM_COUNT; idx++) {
 801                 /* if bt headset is disable, continue */
 802                 if (idx == BT_MENU_TYPE_BT_HEADSET && !is_add_BT_headset())
 803                         continue;
 804
 805                 Bt_Item_Data *id = calloc(sizeof(Bt_Item_Data), 1);
 806                 if (id) {
 807                         id->index = idx;
 808                         id->item = elm_genlist_item_append(
 809                                                    genlist,                             /* genlist object */
 810                                                    itc_arr[idx],                        /* item class */
 811                                                    id,                          /* data */
 812                                                    NULL,
 813                                                    ELM_GENLIST_ITEM_NONE,
 814                                                    menu_its[idx].func,  /* call back */
 815                                                    ad);
 816
 817                         if (idx == BT_MENU_TYPE_BT_ON_OFF) {
 818                                 bt_it = id->item;
 819                         } else if (idx == BT_MENU_TYPE_BT_HEADSET) {
 820                                 hf_it = id->item;
 821                         } else {
 822                                 vb_it = id->item;
 823                         }
 824                 }
 825         }
 826         elm_genlist_item_class_free(itc);
 827         elm_genlist_item_class_free(itc2);
 828         elm_genlist_item_class_free(itc3);
 829
 830         bt_genlist = genlist;
 831
 832         elm_object_part_content_set(layout, "elm.genlist", genlist);
 833
 834         return layout;
 835 }