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