src/ui/bt-profile-view.c

   1 /*
   2 * ug-bluetooth-efl
   3 *
   4 * Copyright 2012 Samsung Electronics Co., Ltd
   5 *
   6 * Contact: Hocheol Seo <hocheol.seo@samsung.com>
   7 *           GirishAshok Joshi <girish.joshi@samsung.com>
   8 *           DoHyun Pyun <dh79.pyun@samsung.com>
   9 *
  10 * Licensed under the Flora License, Version 1.0 (the "License");
  11 * you may not use this file except in compliance with the License.
  12 * You may obtain a copy of the License at
  13 *
  14 * http://www.tizenopensource.org/license
  15 *
  16 * Unless required by applicable law or agreed to in writing,
  17 * software distributed under the License is distributed on an "AS IS" BASIS,
  18 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  19 * See the License for the specific language governing permissions and
  20 * limitations under the License.
  21 *
  22 */
  23
  24 #include <glib.h>
  25 #include <bluetooth.h>
  26 #include <Elementary.h>
  27 #include <Ecore_IMF.h>
  28 #include <efl_extension.h>
  29 #include <notification.h>
  30
  31 #include "bt-main-ug.h"
  32 #include "bt-main-view.h"
  33 #include "bt-debug.h"
  34 #include "bt-widget.h"
  35 #include "bt-type-define.h"
  36 #include "bt-string-define.h"
  37 #include "bt-profile-view.h"
  38 #include "bt-ipc-handler.h"
  39 #include "bt-util.h"
  40 #include "bt-net-connection.h"
  41 #include "bluetooth_internal.h"
  42
  43 /**********************************************************************
  44 *                                      Static Functions declaration
  45 ***********************************************************************/
  46 int __bt_profile_disconnect_option(bt_ug_data *ugd, bt_dev_t *dev,
  47                                         bt_device_type type);
  48
  49 int __bt_profile_connect_option(bt_ug_data *ugd, bt_dev_t *dev,
  50                                 bt_device_type type);
  51
  52 /**********************************************************************
  53 *                                               Static Functions
  54 ***********************************************************************/
  55 static void __bt_toast_popup_timeout_cb(void *data,
  56                                 Evas_Object *obj, void *event_info)
  57 {
  58         bt_ug_data *ugd = (bt_ug_data *)data;
  59         evas_object_del(obj);
  60         if (ugd->rename_entry)
  61                 elm_object_focus_set(ugd->rename_entry, EINA_TRUE);
  62 }
  63
  64 void __bt_profile_input_panel_state_cb(void *data, Ecore_IMF_Context *ctx, int value)
  65 {
  66         FN_START;
  67
  68         bt_dev_t *dev;
  69         bt_ug_data *ugd;
  70         bt_profile_view_data *vd;
  71
  72         dev = (bt_dev_t *)data;
  73         ret_if(dev == NULL);
  74         ret_if(dev->ugd == NULL);
  75
  76         ugd = dev->ugd;
  77         ret_if(ugd->profile_vd == NULL);
  78
  79         vd = ugd->profile_vd;
  80         ret_if(vd->navi_it == NULL);
  81
  82         FN_END;
  83 }
  84
  85 static char *__bt_profile_name_label_get(void *data, Evas_Object *obj, const char *part)
  86 {
  87         FN_START;
  88
  89         char *name = NULL;
  90         bt_dev_t *dev = (bt_dev_t *)data;
  91
  92         if (!strcmp("elm.text.sub", part))
  93                 return strdup(BT_STR_DEVICE_NAME);
  94         else if (!strcmp("elm.text", part)) {
  95                 name = elm_entry_utf8_to_markup(dev->name);
  96                 if (name)
  97                         return name;
  98                 else
  99                         return strdup(dev->name);
 100         }
 101
 102         FN_END;
 103         return NULL;
 104 }
 105
 106 static void __bt_profile_rename_device_entry_changed_cb(void *data, Evas_Object *obj,
 107                                 void *event_info)
 108 {
 109         FN_START;
 110         ret_if(obj == NULL);
 111         ret_if(data == NULL);
 112         bt_ug_data *ugd = NULL;
 113
 114         ugd = (bt_ug_data *)data;
 115
 116         const char *entry_text = NULL;
 117         char *input_str = NULL;
 118
 119
 120         if (ugd->rename_entry != obj)
 121                 ugd->rename_entry = obj;
 122
 123         entry_text = elm_entry_entry_get(obj);
 124         input_str = elm_entry_markup_to_utf8(entry_text);
 125
 126         if (input_str == NULL || strlen(input_str) == 0 ||
 127                                 _bt_util_is_space_str(input_str)) {
 128                 elm_object_disabled_set(ugd->rename_button, EINA_TRUE);
 129                 elm_entry_input_panel_return_key_disabled_set(obj,
 130                                                                 EINA_TRUE);
 131         } else {
 132                 if (elm_object_disabled_get(ugd->rename_button))
 133                         elm_object_disabled_set(ugd->rename_button, EINA_FALSE);
 134                 if (elm_entry_input_panel_return_key_disabled_get(obj))
 135                         elm_entry_input_panel_return_key_disabled_set(
 136                                                                 obj, EINA_FALSE);
 137         }
 138
 139         if(input_str != NULL) {
 140                 free(input_str);
 141                 input_str = NULL;
 142         }
 143
 144         FN_END;
 145 }
 146
 147 static void __bt_profile_rename_device_cancel_cb(void *data, Evas_Object *obj,
 148                                 void *event_info)
 149 {
 150         FN_START;
 151         bt_ug_data *ugd = NULL;
 152
 153         ret_if(data == NULL);
 154         ugd = (bt_ug_data *)data;
 155
 156         if (ugd->rename_popup != NULL) {
 157                 evas_object_del(ugd->rename_popup);
 158                 ugd->rename_popup = NULL;
 159                 ugd->rename_entry = NULL;
 160         }
 161
 162         FN_END;
 163 }
 164
 165 static void __bt_profile_rename_device_ok_cb(void *data, Evas_Object *obj,
 166                                 void *event_info)
 167 {
 168         FN_START;
 169         bt_dev_t *dev = (bt_dev_t *)data;
 170         ret_if(!dev);
 171         bt_ug_data *ugd = (bt_ug_data *)dev->ugd;
 172         ret_if(!ugd);
 173         char *str = NULL;
 174         bt_dev_t *temp = NULL;
 175         Eina_List *l = NULL;
 176         bool flag = true;
 177         char msg[BT_STR_ACCES_INFO_MAX_LEN] = {0, };
 178         Evas_Object *popup = NULL;
 179
 180         const char *entry_str = elm_entry_entry_get(ugd->rename_entry);
 181         char *device_name_str = NULL;
 182         device_name_str = elm_entry_markup_to_utf8(entry_str);
 183         ret_if(!device_name_str);
 184
 185         EINA_LIST_FOREACH(ugd->paired_device, l, temp) {
 186                 if (temp)
 187                         if (g_strcmp0(temp->name, device_name_str) == 0) {
 188                                 if(g_strcmp0(dev->name, device_name_str) != 0) {
 189                                         flag = false;
 190                                         break;
 191                                 }
 192                         }
 193         }
 194
 195         if (flag) {
 196                 EINA_LIST_FOREACH(ugd->searched_device, l, temp) {
 197                         if (temp)
 198                                 if (g_strcmp0(temp->name, device_name_str) == 0) {
 199                                         flag = false;
 200                                         break;
 201                                 }
 202                         }
 203         }
 204
 205         if (!flag){
 206                 snprintf(msg, sizeof(msg), BT_STR_NAME_IN_USE);
 207
 208                 popup = elm_popup_add(ugd->win_main);
 209                 elm_object_style_set(popup, "toast");
 210                 evas_object_size_hint_weight_set(popup, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
 211                 eext_object_event_callback_add(popup, EEXT_CALLBACK_BACK, eext_popup_back_cb, NULL);
 212                 elm_object_text_set(popup, msg);
 213                 elm_popup_timeout_set(popup, 2.0);
 214                 evas_object_smart_callback_add(popup, "timeout",
 215                                 __bt_toast_popup_timeout_cb, ugd);
 216
 217                 elm_popup_align_set(popup, ELM_NOTIFY_ALIGN_FILL, 1.0);
 218                 evas_object_show(popup);
 219         } else {
 220                 BT_DBG("Device name:[%s]", device_name_str);
 221
 222                 str = g_strndup(device_name_str, DEVICE_NAME_MAX_LEN);
 223                 if (BT_ERROR_NONE == bt_device_set_alias(dev->addr_str, str)) {
 224                         memset(dev->name, 0, DEVICE_NAME_MAX_LEN + 1);
 225                         g_strlcpy(dev->name, str, DEVICE_NAME_MAX_LEN + 1);
 226                         free(str);
 227
 228                         if (ugd->profile_vd)
 229                                 _bt_update_genlist_item((Elm_Object_Item *)ugd->profile_vd->name_item);
 230                         _bt_update_genlist_item((Elm_Object_Item *)dev->genlist_item);
 231                 }
 232
 233                 evas_object_del(ugd->rename_popup);
 234                 ugd->rename_popup = NULL;
 235                 ugd->rename_entry = NULL;
 236         }
 237         g_free(device_name_str);
 238         FN_END;
 239 }
 240
 241 static void __bt_profile_rename_entry_changed_cb(void *data, Evas_Object *obj,
 242                                 void *event_info)
 243 {
 244         if (elm_object_part_content_get(obj, "elm.swallow.clear")) {
 245                 if (elm_object_focus_get(obj)) {
 246                         if (elm_entry_is_empty(obj))
 247                                 elm_object_signal_emit(obj, "elm,state,clear,hidden", "");
 248                         else
 249                                 elm_object_signal_emit(obj, "elm,state,clear,visible", "");
 250                 }
 251         }
 252         __bt_profile_rename_device_entry_changed_cb(data, obj, event_info);
 253 }
 254
 255 static void __bt_profile_rename_entry_focused_cb(void *data, Evas_Object *obj,
 256                                 void *event_info)
 257 {
 258         if (elm_object_part_content_get(obj, "elm.swallow.clear")) {
 259                 if (!elm_entry_is_empty(obj))
 260                         elm_object_signal_emit(obj, "elm,state,clear,visible", "");
 261                 else
 262                         elm_object_signal_emit(obj, "elm,state,clear,hidden", "");
 263         }
 264         elm_object_signal_emit(obj, "elm,state,focus,on", "");
 265 }
 266
 267 static void __bt_profile_rename_entry_keydown_cb(void *data, Evas *e, Evas_Object *obj,
 268                                                         void *event_info)
 269 {
 270         Evas_Event_Key_Down *ev;
 271         Evas_Object *entry = obj;
 272
 273         ret_if(data == NULL);
 274         ret_if(event_info == NULL);
 275         ret_if(entry == NULL);
 276
 277         ev = (Evas_Event_Key_Down *)event_info;
 278         BT_INFO("ENTER ev->key:%s", ev->key);
 279
 280         if (g_strcmp0(ev->key, "KP_Enter") == 0 ||
 281                         g_strcmp0(ev->key, "Return") == 0) {
 282
 283                 Ecore_IMF_Context *imf_context = NULL;
 284
 285                 imf_context =
 286                         (Ecore_IMF_Context*)elm_entry_imf_context_get(entry);
 287                 if (imf_context)
 288                         ecore_imf_context_input_panel_hide(imf_context);
 289
 290                 elm_object_focus_set(entry, EINA_FALSE);
 291         }
 292 }
 293
 294 static Evas_Object *__bt_profile_rename_entry_icon_get(
 295                                 void *data, Evas_Object *obj, const char *part)
 296 {
 297         FN_START;
 298         retv_if (obj == NULL || data == NULL, NULL);
 299
 300         bt_dev_t *dev = data;
 301         Evas_Object *entry = NULL;
 302         char *name_value = NULL;
 303         bt_ug_data *ugd;
 304         bt_profile_view_data *vd;
 305         static Elm_Entry_Filter_Limit_Size limit_filter_data;
 306
 307         dev = (bt_dev_t *)data;
 308         retv_if(dev == NULL, NULL);
 309
 310         ugd = (bt_ug_data *)dev->ugd;
 311         retv_if(ugd == NULL, NULL);
 312
 313         vd = ugd->profile_vd;
 314         retv_if(vd == NULL, NULL);
 315
 316         if (!strcmp(part, "elm.icon.entry")) {
 317                 name_value = elm_entry_utf8_to_markup(dev->name);
 318
 319                 entry = elm_entry_add(obj);
 320                 elm_entry_single_line_set(entry, EINA_TRUE);
 321                 elm_entry_scrollable_set(entry, EINA_TRUE);
 322
 323                 eext_entry_selection_back_event_allow_set(entry, EINA_TRUE);
 324                 elm_entry_scrollable_set(entry, EINA_TRUE);
 325                 elm_object_signal_emit(entry, "elm,action,hide,search_icon", "");
 326                 elm_object_part_text_set(entry, "elm.guide", BT_STR_DEVICE_NAME);
 327                 elm_entry_entry_set(entry, name_value);
 328                 elm_entry_cursor_end_set(entry);
 329                 elm_entry_input_panel_imdata_set(entry, "action=disable_emoticons", 24);
 330
 331                 elm_entry_input_panel_return_key_type_set(entry, ECORE_IMF_INPUT_PANEL_RETURN_KEY_TYPE_DONE);
 332                 limit_filter_data.max_char_count = DEVICE_NAME_MAX_CHARACTER;
 333                 elm_entry_markup_filter_append(entry,
 334                         elm_entry_filter_limit_size, &limit_filter_data);
 335
 336                 elm_entry_cnp_mode_set(entry, ELM_CNP_MODE_PLAINTEXT);
 337
 338                 evas_object_smart_callback_add(entry, "maxlength,reached",
 339                                 _bt_util_max_len_reached_cb, ugd);
 340                 evas_object_smart_callback_add(entry, "changed",
 341                                 __bt_profile_rename_entry_changed_cb, ugd);
 342                 evas_object_smart_callback_add(entry, "preedit,changed",
 343                                 __bt_profile_rename_entry_changed_cb, ugd);
 344                 evas_object_smart_callback_add(entry, "focused",
 345                                 __bt_profile_rename_entry_focused_cb, NULL);
 346                 evas_object_event_callback_add(entry, EVAS_CALLBACK_KEY_DOWN,
 347                                 __bt_profile_rename_entry_keydown_cb, ugd);
 348
 349                 evas_object_show(entry);
 350
 351                 elm_object_focus_set(entry, EINA_TRUE);
 352                 ugd->rename_entry = entry;
 353
 354                 if (name_value)
 355                         free(name_value);
 356
 357                 return entry;
 358         }
 359
 360         return NULL;
 361 }
 362
 363 static void __bt_profile_name_item_sel(void *data, Evas_Object *obj,
 364                                       void *event_info)
 365 {
 366         FN_START;
 367
 368         bt_profile_view_data *vd;
 369
 370         if (event_info)
 371                 elm_genlist_item_selected_set((Elm_Object_Item *)event_info,
 372                                               EINA_FALSE);
 373         bt_ug_data *ugd = (bt_ug_data *)data;
 374         ret_if(ugd == NULL);
 375
 376         vd = ugd->profile_vd;
 377         ret_if(vd == NULL);
 378
 379         bt_dev_t *dev = elm_object_item_data_get((Elm_Object_Item *)event_info);
 380         ret_if(dev == NULL);
 381         Evas_Object *popup = NULL;
 382         Evas_Object *button = NULL;
 383         Evas_Object *genlist = NULL;
 384
 385 /*
 386         char *name_value = NULL;
 387
 388         name_value = elm_entry_utf8_to_markup(dev->name);
 389 */
 390         popup = elm_popup_add(ugd->base);
 391         eext_object_event_callback_add(popup, EEXT_CALLBACK_BACK, eext_popup_back_cb, NULL);
 392         evas_object_size_hint_weight_set(popup, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
 393         elm_popup_align_set(popup, ELM_NOTIFY_ALIGN_FILL, 1.0);
 394 /*
 395         layout = elm_layout_add(popup);
 396
 397         elm_layout_file_set(layout, BT_GENLIST_EDJ, "profile_rename_device_ly");
 398         evas_object_size_hint_weight_set(layout, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
 399 */
 400         elm_object_domain_translatable_part_text_set(popup,
 401                                                 "title,text",
 402                                                 PKGNAME,
 403                                                 "IDS_ST_HEADER_RENAME_DEVICE");
 404
 405         genlist = elm_genlist_add(popup);
 406         evas_object_size_hint_weight_set(genlist,
 407                         EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
 408         evas_object_size_hint_align_set(genlist, EVAS_HINT_FILL, EVAS_HINT_FILL);
 409         elm_genlist_mode_set(genlist, ELM_LIST_COMPRESS);
 410         elm_scroller_content_min_limit(genlist, EINA_FALSE, EINA_TRUE);
 411
 412         /* Entry genlist item */
 413         vd->rename_entry_itc = elm_genlist_item_class_new();
 414         if (vd->rename_entry_itc) {
 415                 vd->rename_entry_itc->item_style = "entry";
 416                 vd->rename_entry_itc->func.text_get = NULL;
 417                 vd->rename_entry_itc->func.content_get = __bt_profile_rename_entry_icon_get;
 418                 vd->rename_entry_itc->func.state_get = NULL;
 419                 vd->rename_entry_itc->func.del = NULL;
 420
 421                 vd->rename_entry_item = elm_genlist_item_append(genlist,
 422                                 vd->rename_entry_itc, dev,
 423                                 NULL, ELM_GENLIST_ITEM_NONE, NULL, NULL);
 424         }
 425 /*
 426         entry = elm_entry_add(obj);
 427         elm_entry_single_line_set(entry, EINA_TRUE);
 428         elm_entry_scrollable_set(entry, EINA_TRUE);
 429
 430         eext_entry_selection_back_event_allow_set(entry, EINA_TRUE);
 431         elm_entry_scrollable_set(entry, EINA_TRUE);
 432         elm_object_signal_emit(entry, "elm,action,hide,search_icon", "");
 433         elm_object_part_text_set(entry, "elm.guide", BT_STR_DEVICE_NAME);
 434         elm_entry_input_panel_imdata_set(entry, "action=disable_emoticons", 24);
 435
 436         limit_filter.max_char_count = DEVICE_NAME_MAX_CHARACTER;
 437         elm_entry_markup_filter_append(entry, elm_entry_filter_limit_size,
 438                         &limit_filter);
 439
 440         elm_entry_input_panel_return_key_type_set(entry,
 441                         ECORE_IMF_INPUT_PANEL_RETURN_KEY_TYPE_DONE);
 442
 443         if (name_value)
 444                 elm_entry_entry_set(entry, name_value);
 445
 446         elm_entry_cnp_mode_set(entry, ELM_CNP_MODE_PLAINTEXT);
 447
 448         evas_object_smart_callback_add(entry, "maxlength,reached",
 449                         _bt_util_max_len_reached_cb, ugd);
 450         evas_object_smart_callback_add(entry, "changed",
 451                         __bt_profile_rename_entry_changed_cb, ugd);
 452         evas_object_smart_callback_add(entry, "preedit,changed",
 453                         __bt_profile_rename_entry_changed_cb, ugd);
 454         evas_object_smart_callback_add(entry, "focused",
 455                         __bt_profile_rename_entry_focused_cb, NULL);
 456         evas_object_event_callback_add(entry, EVAS_CALLBACK_KEY_DOWN,
 457                         __bt_profile_rename_entry_keydown_cb, ugd);
 458
 459         evas_object_show(entry);
 460         elm_object_part_content_set(layout, "elm.swallow.layout", entry);
 461
 462         elm_object_content_set(popup, layout);
 463 */
 464         button = elm_button_add(popup);
 465         elm_object_style_set(button, "popup");
 466         elm_object_domain_translatable_text_set(button,
 467                                                 PKGNAME,
 468                                                 "IDS_BR_SK_CANCEL");
 469         elm_object_part_content_set(popup, "button1", button);
 470         evas_object_smart_callback_add(button, "clicked",
 471                         __bt_profile_rename_device_cancel_cb, ugd);
 472
 473         button = elm_button_add(popup);
 474         ugd->rename_button = button;
 475         elm_object_style_set(button, "popup");
 476         elm_object_domain_translatable_text_set(button,
 477                                                 PKGNAME,
 478                                                 "IDS_BT_OPT_RENAME");
 479         elm_object_part_content_set(popup, "button2", button);
 480         evas_object_smart_callback_add(button, "clicked",
 481                         __bt_profile_rename_device_ok_cb, dev);
 482
 483         evas_object_show(genlist);
 484
 485         elm_object_content_set(popup, genlist);
 486         evas_object_show(popup);
 487
 488         if (ugd->rename_entry)
 489                 elm_object_focus_set(ugd->rename_entry, EINA_TRUE);
 490
 491         ugd->rename_popup = popup;
 492
 493         FN_END;
 494 }
 495
 496 static void __bt_profile_unpair_item_sel(void *data, Evas_Object *obj,
 497                                       void *event_info)
 498 {
 499         FN_START;
 500         bt_dev_t *dev = NULL;
 501         bt_ug_data *ugd;
 502
 503         ret_if(NULL == data);
 504
 505         dev = (bt_dev_t *)data;
 506
 507         ugd = dev->ugd;
 508         ret_if(NULL == ugd);
 509
 510         if (event_info)
 511                 elm_genlist_item_selected_set((Elm_Object_Item *)event_info,
 512                                               EINA_FALSE);
 513
 514         /* If rename entry is focused, then unfocus and return */
 515         if (ugd->rename_entry && elm_object_focus_get(ugd->rename_entry)) {
 516                 BT_DBG("Unfocus Rename Entry");
 517                 elm_object_focus_set(ugd->rename_entry, EINA_FALSE);
 518                 return;
 519         }
 520
 521         if (dev->status == BT_DEV_UNPAIRING)
 522                 return;
 523
 524         dev->status = BT_DEV_UNPAIRING;
 525         if (bt_device_destroy_bond(dev->addr_str) != BT_ERROR_NONE) {
 526                 BT_ERR("Fail to unpair");
 527                 dev->status = BT_IDLE;
 528                 return;
 529         }
 530
 531         FN_END;
 532         return;
 533 }
 534
 535 static char *__bt_profile_unpair_label_get(void *data, Evas_Object *obj,
 536                                             const char *part)
 537 {
 538         FN_START;
 539
 540         char buf[BT_GLOBALIZATION_STR_LENGTH] = { 0, };
 541
 542         if (!strcmp("elm.text", part)) {
 543                 g_strlcpy(buf, BT_STR_UNPAIR, BT_GLOBALIZATION_STR_LENGTH);
 544         } else {
 545                 BT_ERR("empty text for label");
 546                 return NULL;
 547         }
 548
 549         FN_END;
 550         return strdup(buf);
 551 }
 552
 553 static char *__bt_proflie_title_label_get(void *data, Evas_Object *obj,
 554                                                 const char *part)
 555 {
 556         FN_START;
 557
 558         char buf[BT_GLOBALIZATION_STR_LENGTH] = { 0, };
 559
 560         if (!strcmp("elm.text", part)) {
 561                 /*Label */
 562                 g_strlcpy(buf, BT_STR_CONNECTION_OPTIONS,
 563                         BT_GLOBALIZATION_STR_LENGTH);
 564         } else {
 565                 BT_ERR("This part name is not exist in style");
 566                 return NULL;
 567         }
 568
 569         FN_END;
 570         return strdup(buf);
 571 }
 572
 573 #ifndef TELEPHONY_DISABLED
 574 static char *__bt_proflie_call_option_label_get(void *data, Evas_Object *obj,
 575                                                 const char *part)
 576 {
 577         FN_START;
 578
 579         char buf[BT_GLOBALIZATION_STR_LENGTH] = { 0, };
 580 #ifdef KIRAN_ACCESSIBILITY
 581         char str[BT_STR_ACCES_INFO_MAX_LEN] = {0, };
 582         Evas_Object *ao;
 583 #endif
 584         bt_dev_t *dev_info = NULL;
 585         bt_ug_data *ugd = NULL;
 586
 587         retv_if(NULL == data, NULL);
 588         dev_info = (bt_dev_t *)data;
 589
 590         ugd = (bt_ug_data *)(dev_info->ugd);
 591         retv_if(NULL == ugd, NULL);
 592
 593         if (!strcmp("elm.text", part)) {
 594                 g_strlcpy(buf, BT_STR_CALL_AUDIO,
 595                         BT_GLOBALIZATION_STR_LENGTH);
 596         } else {
 597                 BT_ERR("This part name is not exist in style");
 598                 return NULL;
 599         }
 600
 601 #ifdef KIRAN_ACCESSIBILITY
 602         if (ugd->profile_vd && ugd->profile_vd->call_item) {
 603                 ao = elm_object_item_access_object_get(
 604                                 ugd->profile_vd->call_item);
 605                 if (dev_info->status == BT_IDLE) {
 606                         if (dev_info->call_checked)
 607                                 snprintf(str, sizeof(str), "%s, %s, %s",
 608                                                 BT_STR_CALL_AUDIO,
 609                                                 BT_STR_RADIO_BUTTON,
 610                                                 BT_STR_RADIO_SELECTED);
 611                         else
 612                                 snprintf(str, sizeof(str), "%s, %s, %s",
 613                                                 BT_STR_CALL_AUDIO,
 614                                                 BT_STR_RADIO_BUTTON,
 615                                                 BT_STR_RADIO_UNSELECTED);
 616                 }
 617                 elm_access_info_set(ao, ELM_ACCESS_INFO, str);
 618         }
 619 #endif
 620         FN_END;
 621         return strdup(buf);
 622 }
 623 #endif
 624
 625 static char *__bt_proflie_media_option_label_get(void *data, Evas_Object *obj,
 626                                               const char *part)
 627 {
 628         FN_START;
 629
 630         char buf[BT_GLOBALIZATION_STR_LENGTH] = { 0, };
 631 #ifdef KIRAN_ACCESSIBILITY
 632         char str[BT_STR_ACCES_INFO_MAX_LEN] = {0, };
 633         Evas_Object *ao;
 634 #endif
 635         bt_dev_t *dev_info = NULL;
 636         bt_ug_data *ugd = NULL;
 637
 638         retv_if(NULL == data, NULL);
 639         dev_info = (bt_dev_t *)data;
 640
 641         ugd = (bt_ug_data *)(dev_info->ugd);
 642         retv_if(NULL == ugd, NULL);
 643
 644         if (!strcmp("elm.text", part)) {
 645                 g_strlcpy(buf, BT_STR_MEDIA_AUDIO,
 646                         BT_GLOBALIZATION_STR_LENGTH);
 647         } else {
 648                 BT_ERR("This part name is not exist in style");
 649                 return NULL;
 650         }
 651
 652 #ifdef KIRAN_ACCESSIBILITY
 653         if (ugd->profile_vd && ugd->profile_vd->media_item) {
 654                 ao = elm_object_item_access_object_get(
 655                                 ugd->profile_vd->media_item);
 656                 if (dev_info->status == BT_IDLE) {
 657                         if (dev_info->media_checked)
 658                                 snprintf(str, sizeof(str), "%s, %s, %s",
 659                                                 BT_STR_MEDIA_AUDIO,
 660                                                 BT_STR_RADIO_BUTTON,
 661                                                 BT_STR_RADIO_SELECTED);
 662                         else
 663                                 snprintf(str, sizeof(str), "%s, %s, %s",
 664                                                 BT_STR_MEDIA_AUDIO,
 665                                                 BT_STR_RADIO_BUTTON,
 666                                                 BT_STR_RADIO_UNSELECTED);
 667                 }
 668                 elm_access_info_set(ao, ELM_ACCESS_INFO, str);
 669         }
 670 #endif
 671         FN_END;
 672         return strdup(buf);
 673 }
 674
 675 static char *__bt_proflie_hid_option_label_get(void *data, Evas_Object *obj,
 676                                               const char *part)
 677 {
 678         FN_START;
 679
 680         char buf[BT_GLOBALIZATION_STR_LENGTH] = { 0, };
 681 #ifdef KIRAN_ACCESSIBILITY
 682         char str[BT_STR_ACCES_INFO_MAX_LEN] = {0, };
 683         Evas_Object *ao;
 684 #endif
 685         bt_dev_t *dev_info = NULL;
 686         bt_ug_data *ugd = NULL;
 687
 688         retv_if(NULL == data, NULL);
 689         dev_info = (bt_dev_t *)data;
 690
 691         ugd = (bt_ug_data *)(dev_info->ugd);
 692         retv_if(NULL == ugd, NULL);
 693
 694         if (!strcmp("elm.text", part)) {
 695                 g_strlcpy(buf, BT_STR_INPUT_DEVICE,
 696                         BT_GLOBALIZATION_STR_LENGTH);
 697         } else {
 698                 BT_ERR("This part name is not exist in style");
 699                 return NULL;
 700         }
 701 #ifdef KIRAN_ACCESSIBILITY
 702         if (ugd->profile_vd && ugd->profile_vd->hid_item) {
 703                 ao = elm_object_item_access_object_get(
 704                                 ugd->profile_vd->hid_item);
 705                 if (dev_info->status == BT_IDLE) {
 706                         if (dev_info->hid_checked)
 707                                 snprintf(str, sizeof(str), "%s, %s, %s",
 708                                                 BT_STR_INPUT_DEVICE,
 709                                                 BT_STR_RADIO_BUTTON,
 710                                                 BT_STR_RADIO_SELECTED);
 711                         else
 712                                 snprintf(str, sizeof(str), "%s, %s, %s",
 713                                                 BT_STR_INPUT_DEVICE,
 714                                                 BT_STR_RADIO_BUTTON,
 715                                                 BT_STR_RADIO_UNSELECTED);
 716                 }
 717                 elm_access_info_set(ao, ELM_ACCESS_INFO, str);
 718         }
 719 #endif
 720         FN_END;
 721         return strdup(buf);
 722 }
 723
 724 static char *__bt_proflie_nap_option_label_get(void *data, Evas_Object *obj,
 725                                               const char *part)
 726 {
 727         FN_START;
 728
 729         char buf[BT_GLOBALIZATION_STR_LENGTH] = { 0, };
 730 #ifdef KIRAN_ACCESSIBILITY
 731         char str[BT_STR_ACCES_INFO_MAX_LEN] = {0, };
 732         Evas_Object *ao;
 733 #endif
 734         bt_dev_t *dev_info = NULL;
 735         bt_ug_data *ugd = NULL;
 736
 737         retv_if(NULL == data, NULL);
 738         dev_info = (bt_dev_t *)data;
 739
 740         ugd = (bt_ug_data *)(dev_info->ugd);
 741         retv_if(NULL == ugd, NULL);
 742
 743         if (!strcmp("elm.text", part)) {
 744                 g_strlcpy(buf, BT_STR_INTERNET_ACCESS,
 745                         BT_GLOBALIZATION_STR_LENGTH);
 746         } else {
 747                 BT_ERR("This part name is not exist in style");
 748                 return NULL;
 749         }
 750
 751 #ifdef KIRAN_ACCESSIBILITY
 752         if (ugd->profile_vd && ugd->profile_vd->network_item) {
 753                 ao = elm_object_item_access_object_get(
 754                                 ugd->profile_vd->network_item);
 755                 if (dev_info->status == BT_IDLE) {
 756                         if (dev_info->network_checked)
 757                                 snprintf(str, sizeof(str), "%s, %s, %s",
 758                                                 BT_STR_INTERNET_ACCESS,
 759                                                 BT_STR_RADIO_BUTTON,
 760                                                 BT_STR_RADIO_SELECTED);
 761                         else
 762                                 snprintf(str, sizeof(str), "%s, %s, %s",
 763                                                 BT_STR_INTERNET_ACCESS,
 764                                                 BT_STR_RADIO_BUTTON,
 765                                                 BT_STR_RADIO_UNSELECTED);
 766                 }
 767                 elm_access_info_set(ao, ELM_ACCESS_INFO, str);
 768         }
 769 #endif
 770         FN_END;
 771         return strdup(buf);
 772 }
 773
 774 #ifndef TELEPHONY_DISABLED
 775 static void __bt_profile_call_option_checkbox_sel(void *data, Evas_Object *obj,
 776                                       void *event_info)
 777 {
 778         FN_START;
 779         bt_dev_t *dev = NULL;
 780         int ret;
 781
 782         dev = (bt_dev_t *)data;
 783         ret_if(dev->ugd == NULL);
 784
 785         if (dev->status == BT_DEV_UNPAIRING)
 786                 return;
 787
 788         if (dev->connected_mask & BT_HEADSET_CONNECTED) {
 789                 ret = __bt_profile_disconnect_option((bt_ug_data *)dev->ugd,
 790                                         dev, BT_HEADSET_DEVICE);
 791         } else {
 792                 ret = __bt_profile_connect_option((bt_ug_data *)dev->ugd,
 793                                                 dev, BT_HEADSET_DEVICE);
 794         }
 795
 796         if (ret == BT_UG_FAIL)
 797                 elm_check_state_set(obj, dev->call_checked);
 798
 799         FN_END;
 800 }
 801 #endif
 802
 803 static void __bt_profile_media_option_checkbox_sel(void *data, Evas_Object *obj,
 804                                       void *event_info)
 805 {
 806         FN_START;
 807         bt_dev_t *dev = NULL;
 808         int ret;
 809
 810         dev = (bt_dev_t *)data;
 811         ret_if(dev->ugd == NULL);
 812
 813         if (dev->status == BT_DEV_UNPAIRING)
 814                 return;
 815
 816 #ifdef TIZEN_BT_A2DP_SINK_ENABLE
 817         if (dev->connected_mask & BT_MUSIC_PLAYER_CONNECTED) {
 818                 ret = __bt_profile_disconnect_option((bt_ug_data *)dev->ugd,
 819                                         dev, BT_MUSIC_PLAYER_DEVICE);
 820         } else {
 821                 ret = __bt_profile_connect_option((bt_ug_data *)dev->ugd,
 822                                         dev, BT_MUSIC_PLAYER_DEVICE);
 823         }
 824 #else
 825         if (dev->connected_mask & BT_STEREO_HEADSET_CONNECTED) {
 826                 ret = __bt_profile_disconnect_option((bt_ug_data *)dev->ugd,
 827                                         dev, BT_STEREO_HEADSET_DEVICE);
 828         } else {
 829                 ret = __bt_profile_connect_option((bt_ug_data *)dev->ugd,
 830                                         dev, BT_STEREO_HEADSET_DEVICE);
 831         }
 832 #endif
 833
 834         if (ret == BT_UG_FAIL)
 835                 elm_check_state_set(obj, dev->media_checked);
 836
 837         FN_END;
 838 }
 839
 840
 841 static void __bt_profile_hid_option_checkbox_sel(void *data, Evas_Object *obj,
 842                                       void *event_info)
 843 {
 844         FN_START;
 845         bt_dev_t *dev = NULL;
 846         int ret;
 847
 848         dev = (bt_dev_t *)data;
 849         ret_if(dev->ugd == NULL);
 850
 851         if (dev->status == BT_DEV_UNPAIRING)
 852                 return;
 853
 854         if (dev->connected_mask & BT_HID_CONNECTED) {
 855                 ret = __bt_profile_disconnect_option((bt_ug_data *)dev->ugd,
 856                                         dev, BT_HID_DEVICE);
 857         } else {
 858                 ret = __bt_profile_connect_option((bt_ug_data *)dev->ugd,
 859                                                 dev, BT_HID_DEVICE);
 860         }
 861
 862         if (ret == BT_UG_FAIL)
 863                 elm_check_state_set(obj, dev->hid_checked);
 864
 865         FN_END;
 866 }
 867
 868 static void __bt_profile_nap_option_checkbox_sel(void *data, Evas_Object *obj,
 869                                       void *event_info)
 870 {
 871         FN_START;
 872         bt_dev_t *dev = NULL;
 873         int ret;
 874
 875         dev = (bt_dev_t *)data;
 876         ret_if(dev->ugd == NULL);
 877
 878         if (dev->status == BT_DEV_UNPAIRING)
 879                 return;
 880
 881         if (dev->connected_mask & BT_NETWORK_CONNECTED) {
 882                 ret = __bt_profile_disconnect_option((bt_ug_data *)dev->ugd,
 883                                         dev, BT_NETWORK_DEVICE);
 884         } else {
 885                 ret = __bt_profile_connect_option((bt_ug_data *)dev->ugd,
 886                                                 dev, BT_NETWORK_DEVICE);
 887         }
 888
 889         if (ret == BT_UG_FAIL)
 890                 elm_check_state_set(obj, dev->network_checked);
 891
 892         FN_END;
 893
 894 }
 895
 896 #ifndef TELEPHONY_DISABLED
 897 static Evas_Object *__bt_profile_call_option_icon_get(void *data, Evas_Object *obj,
 898                                           const char *part)
 899 {
 900         FN_START;
 901
 902         Evas_Object *check = NULL;
 903         bt_dev_t *dev = NULL;
 904
 905         retv_if(NULL == data, NULL);
 906
 907         dev = (bt_dev_t *)data;
 908
 909         if (!strcmp("elm.swallow.end", part)) {
 910                 check = elm_check_add(obj);
 911                 elm_object_style_set(check, "on&off");
 912
 913                 dev->call_checked = dev->connected_mask & \
 914                                         BT_HEADSET_CONNECTED;
 915                 elm_check_state_set(check, dev->call_checked);
 916
 917                 evas_object_size_hint_weight_set(check, EVAS_HINT_EXPAND,
 918                                                 EVAS_HINT_EXPAND);
 919                 evas_object_size_hint_align_set(check, EVAS_HINT_FILL,
 920                                                 EVAS_HINT_FILL);
 921
 922                 evas_object_smart_callback_add(check, "changed", __bt_profile_call_option_checkbox_sel, dev);
 923
 924                 evas_object_propagate_events_set(check, EINA_FALSE);
 925                 evas_object_show(check);
 926         }
 927         FN_END;
 928         return check;
 929 }
 930 #endif
 931
 932 static Evas_Object *__bt_profile_media_option_icon_get(void *data, Evas_Object *obj,
 933                                           const char *part)
 934 {
 935         FN_START;
 936
 937         Evas_Object *check = NULL;
 938         bt_dev_t *dev = NULL;
 939
 940         retv_if(NULL == data, NULL);
 941
 942         dev = (bt_dev_t *)data;
 943
 944         if (!strcmp("elm.swallow.end", part)) {
 945                 check = elm_check_add(obj);
 946                 elm_object_style_set(check, "on&off");
 947 #ifdef TIZEN_BT_A2DP_SINK_ENABLE
 948                 dev->media_checked = dev->connected_mask & \
 949                                         BT_MUSIC_PLAYER_CONNECTED;
 950 #else
 951                 dev->media_checked = dev->connected_mask & \
 952                                         BT_STEREO_HEADSET_CONNECTED;
 953 #endif
 954                 elm_check_state_set(check, dev->media_checked);
 955
 956                 evas_object_size_hint_weight_set(check, EVAS_HINT_EXPAND,
 957                                                 EVAS_HINT_EXPAND);
 958                 evas_object_size_hint_align_set(check, EVAS_HINT_FILL,
 959                                                 EVAS_HINT_FILL);
 960
 961                 evas_object_smart_callback_add(check, "changed", __bt_profile_media_option_checkbox_sel, dev);
 962
 963                 evas_object_propagate_events_set(check, EINA_FALSE);
 964                 evas_object_show(check);
 965         }
 966         FN_END;
 967         return check;
 968 }
 969
 970 static Evas_Object *__bt_profile_hid_option_icon_get(void *data, Evas_Object *obj,
 971                                           const char *part)
 972 {
 973         FN_START;
 974
 975         Evas_Object *check = NULL;
 976         bt_dev_t *dev = NULL;
 977
 978         retv_if(NULL == data, NULL);
 979
 980         dev = (bt_dev_t *)data;
 981
 982         if (!strcmp("elm.swallow.end", part)) {
 983                 check = elm_check_add(obj);
 984                 elm_object_style_set(check, "on&off");
 985
 986                 dev->hid_checked = dev->connected_mask & \
 987                                         BT_HID_CONNECTED;
 988                 elm_check_state_set(check, dev->hid_checked);
 989
 990                 evas_object_size_hint_weight_set(check, EVAS_HINT_EXPAND,
 991                                                 EVAS_HINT_EXPAND);
 992                 evas_object_size_hint_align_set(check, EVAS_HINT_FILL,
 993                                                 EVAS_HINT_FILL);
 994
 995                 evas_object_smart_callback_add(check, "changed", __bt_profile_hid_option_checkbox_sel, dev);
 996
 997                 evas_object_propagate_events_set(check, EINA_FALSE);
 998                 evas_object_show(check);
 999         }
1000         FN_END;
1001         return check;
1002 }
1003
1004 static Evas_Object *__bt_profile_nap_option_icon_get(void *data, Evas_Object *obj,
1005                                           const char *part)
1006 {
1007         FN_START;
1008
1009         Evas_Object *check = NULL;
1010         bt_dev_t *dev = NULL;
1011
1012         retv_if(NULL == data, NULL);
1013
1014         dev = (bt_dev_t *)data;
1015
1016         if (!strcmp("elm.swallow.end", part)) {
1017                 check = elm_check_add(obj);
1018                 elm_object_style_set(check, "on&off");
1019
1020                 dev->network_checked = dev->connected_mask & \
1021                                         BT_NETWORK_CONNECTED;
1022                 elm_check_state_set(check, dev->network_checked);
1023
1024                 evas_object_size_hint_weight_set(check, EVAS_HINT_EXPAND,
1025                                                 EVAS_HINT_EXPAND);
1026                 evas_object_size_hint_align_set(check, EVAS_HINT_FILL,
1027                                                 EVAS_HINT_FILL);
1028
1029                 evas_object_smart_callback_add(check, "changed", __bt_profile_nap_option_checkbox_sel, dev);
1030
1031                 evas_object_propagate_events_set(check, EINA_FALSE);
1032                 evas_object_show(check);
1033         }
1034         FN_END;
1035         return check;
1036 }
1037
1038 int __bt_profile_connect_option(bt_ug_data *ugd, bt_dev_t *dev,
1039                                 bt_device_type type)
1040 {
1041         FN_START;
1042
1043         int audio_profile;
1044
1045         retv_if(ugd == NULL, BT_UG_FAIL);
1046         retv_if(dev == NULL, BT_UG_FAIL);
1047
1048         if (type == BT_HEADSET_DEVICE || type == BT_STEREO_HEADSET_DEVICE ||
1049                         type == BT_MUSIC_PLAYER_DEVICE) {
1050                 if (type == BT_STEREO_HEADSET_DEVICE)
1051                         audio_profile = BT_AUDIO_PROFILE_TYPE_A2DP;
1052 #ifdef TIZEN_BT_A2DP_SINK_ENABLE
1053                 else if (type == BT_MUSIC_PLAYER_DEVICE)
1054                         audio_profile = BT_AUDIO_PROFILE_TYPE_A2DP_SINK;
1055 #endif
1056                 else
1057                         audio_profile = BT_AUDIO_PROFILE_TYPE_HSP_HFP;
1058
1059                 if (bt_audio_connect(dev->addr_str,
1060                                 audio_profile) != BT_ERROR_NONE) {
1061                         BT_ERR("Fail to connect Headset device");
1062                         return BT_UG_FAIL;
1063                 }
1064         } else if (type == BT_HID_DEVICE) {
1065 #ifdef TIZEN_HID
1066
1067                 BT_DBG("HID connect request");
1068
1069                 if (bt_hid_host_connect(dev->addr_str) != BT_ERROR_NONE) {
1070                         return BT_UG_FAIL;
1071                 }
1072 #endif
1073         } else if (type == BT_NETWORK_DEVICE){
1074                 BT_DBG("Network connect request");
1075
1076                 void *net_profile;
1077
1078                 if (dev->net_profile) {
1079                         if (_bt_connect_net_profile(ugd->connection,
1080                                                 dev->net_profile,
1081                                                 dev) != BT_UG_ERROR_NONE) {
1082                                 BT_ERR("Fail to connect the net profile");
1083                                 return BT_UG_FAIL;
1084                         }
1085                 } else {
1086                         net_profile =
1087                                 _bt_get_registered_net_profile(ugd->connection,
1088                                                                 dev->bd_addr);
1089                         if (net_profile) {
1090                                 _bt_set_profile_state_changed_cb(net_profile, dev);
1091
1092                                 if (_bt_connect_net_profile(ugd->connection,
1093                                                         net_profile,
1094                                                         dev) != BT_UG_ERROR_NONE) {
1095                                         BT_ERR("Fail to connect the net profile");
1096                                         return BT_UG_FAIL;
1097                                 }
1098                         } else {
1099                                 BT_ERR("No registered net profile");
1100                                 return BT_UG_FAIL;
1101                         }
1102                 }
1103         } else {
1104                 BT_ERR("Unknown type");
1105                 return BT_UG_FAIL;
1106         }
1107
1108         ugd->connect_req = TRUE;
1109         dev->status = BT_CONNECTING;
1110         _bt_update_genlist_item((Elm_Object_Item *)dev->genlist_item);
1111
1112         retv_if(ugd->profile_vd == NULL, BT_UG_FAIL);
1113
1114         if (ugd->profile_vd->genlist) {
1115                 _bt_util_set_list_disabled(ugd->profile_vd->genlist,
1116                                         EINA_TRUE);
1117         }
1118
1119         FN_END;
1120         return BT_UG_ERROR_NONE;
1121 }
1122
1123 int __bt_profile_disconnect_option(bt_ug_data *ugd, bt_dev_t *dev,
1124                                         bt_device_type type)
1125 {
1126         FN_START;
1127
1128         int audio_profile;
1129         bt_ug_ipc_param_t param;
1130         gboolean connected = FALSE;
1131         gboolean connected_nap_profile = FALSE;
1132
1133         retv_if(ugd == NULL, BT_UG_FAIL);
1134         retv_if(dev == NULL, BT_UG_FAIL);
1135
1136         memset(&param, 0x00, sizeof(bt_ug_ipc_param_t));
1137         memcpy(param.param2, dev->bd_addr, BT_ADDRESS_LENGTH_MAX);
1138
1139         if (type == BT_HEADSET_DEVICE) {
1140                 connected = _bt_util_is_profile_connected(BT_HEADSET_CONNECTED,
1141                                                 dev->bd_addr);
1142         } else if (type == BT_STEREO_HEADSET_DEVICE) {
1143                 connected = _bt_util_is_profile_connected(BT_STEREO_HEADSET_CONNECTED,
1144                                                 dev->bd_addr);
1145         } else if (type == BT_MUSIC_PLAYER_DEVICE) {
1146                 connected = _bt_util_is_profile_connected(BT_MUSIC_PLAYER_CONNECTED,
1147                                                 dev->bd_addr);
1148         } else if (type == BT_HID_DEVICE) {
1149                 connected = _bt_util_is_profile_connected(BT_HID_CONNECTED,
1150                                                 dev->bd_addr);
1151         } else if (type == BT_NETWORK_DEVICE) {
1152                 connected = _bt_util_is_profile_connected(BT_NETWORK_CONNECTED,
1153                                                 dev->bd_addr);
1154                 /* Need to check */
1155                 if (!connected) {
1156                         connected = _bt_util_is_profile_connected(BT_NETWORK_SERVER_CONNECTED,
1157                                                 dev->bd_addr);
1158                         connected_nap_profile = connected;
1159                 }
1160         }
1161
1162         if (connected == FALSE) {
1163                 BT_ERR("Not connected");
1164                 return BT_UG_FAIL;
1165         }
1166
1167         if (type == BT_HEADSET_DEVICE || type == BT_STEREO_HEADSET_DEVICE ||
1168                         type == BT_MUSIC_PLAYER_DEVICE) {
1169                 if (type == BT_STEREO_HEADSET_DEVICE)
1170                         audio_profile = BT_AUDIO_PROFILE_TYPE_A2DP;
1171 #ifdef TIZEN_BT_A2DP_SINK_ENABLE
1172                 else if (type == BT_MUSIC_PLAYER_DEVICE)
1173                         audio_profile = BT_AUDIO_PROFILE_TYPE_A2DP_SINK;
1174 #endif
1175                 else
1176                         audio_profile = BT_AUDIO_PROFILE_TYPE_HSP_HFP;
1177
1178                 if (bt_audio_disconnect(dev->addr_str,
1179                                 audio_profile) != BT_ERROR_NONE) {
1180                         BT_ERR("Fail to connect Headset device");
1181                         return BT_UG_FAIL;
1182                 }
1183         } else if (type == BT_HID_DEVICE) {
1184                 BT_DBG("Disconnecting HID service!!");
1185
1186                 if (bt_hid_host_disconnect(dev->addr_str) != BT_ERROR_NONE) {
1187                         BT_ERR("Fail to disconnect HID device");
1188                         return BT_UG_FAIL;
1189                 }
1190         } else if (type == BT_NETWORK_DEVICE) {
1191
1192                 void *net_profile;
1193
1194                 if (connected_nap_profile == FALSE) {
1195                         BT_DBG("Disconnecting network service!! [PANU]");
1196                         if (dev->net_profile) {
1197                                 if (_bt_disconnect_net_profile(ugd->connection,
1198                                                         dev->net_profile,
1199                                                         dev) != BT_UG_ERROR_NONE) {
1200                                         BT_ERR("Fail to disconnect the net profile");
1201                                         return BT_UG_FAIL;
1202                                 }
1203                         } else {
1204                                 net_profile =
1205                                         _bt_get_registered_net_profile(ugd->connection,
1206                                                                         dev->bd_addr);
1207                                 if (net_profile) {
1208                                         _bt_set_profile_state_changed_cb(net_profile, dev);
1209                                         if (_bt_disconnect_net_profile(ugd->connection,
1210                                                                 dev->net_profile,
1211                                                                 dev) != BT_UG_ERROR_NONE) {
1212                                                 BT_ERR("Fail to disconnect the net profile");
1213                                                 return BT_UG_FAIL;
1214                                         }
1215                                 } else {
1216                                         BT_ERR("No registered net profile");
1217                                         return BT_UG_FAIL;
1218                                 }
1219                         }
1220                 } else {
1221                         BT_DBG("Disconnecting network service!! [NAP]");
1222                         if (bt_nap_disconnect(dev->addr_str) == BT_UG_ERROR_NONE)
1223                                 BT_ERR("Failed to disconnect pan server");
1224                 }
1225
1226         } else {
1227                 BT_ERR("Unknown type");
1228                 return BT_UG_FAIL;
1229         }
1230
1231         ugd->connect_req = TRUE;
1232         dev->status = BT_DISCONNECTING;
1233         _bt_update_genlist_item((Elm_Object_Item *)dev->genlist_item);
1234
1235         if (ugd->profile_vd->genlist) {
1236                 _bt_util_set_list_disabled(ugd->profile_vd->genlist,
1237                                         EINA_TRUE);
1238         }
1239
1240         FN_END;
1241         return BT_UG_ERROR_NONE;
1242 }
1243
1244 #ifndef TELEPHONY_DISABLED
1245 static void __bt_profile_call_option_item_sel(void *data, Evas_Object *obj,
1246                                       void *event_info)
1247 {
1248         FN_START;
1249
1250         bt_dev_t *dev = NULL;
1251         Elm_Object_Item *item = NULL;
1252
1253         ret_if(event_info == NULL);
1254
1255         if(event_info) {
1256                 item = (Elm_Object_Item *)event_info;
1257                 elm_genlist_item_selected_set(item, EINA_FALSE);
1258         }
1259
1260         ret_if(data == NULL);
1261
1262         dev = (bt_dev_t *)data;
1263         ret_if(dev->ugd == NULL);
1264
1265         if (dev->status == BT_DEV_UNPAIRING)
1266                 return;
1267
1268         if (dev->connected_mask & BT_HEADSET_CONNECTED) {
1269                 __bt_profile_disconnect_option((bt_ug_data *)dev->ugd,
1270                                         dev, BT_HEADSET_DEVICE);
1271         } else {
1272                 __bt_profile_connect_option((bt_ug_data *)dev->ugd,
1273                                                 dev, BT_HEADSET_DEVICE);
1274         }
1275         _bt_update_genlist_item(item);
1276
1277         FN_END;
1278 }
1279 #endif
1280
1281 static void __bt_profile_media_option_item_sel(void *data, Evas_Object *obj,
1282                                       void *event_info)
1283 {
1284         FN_START;
1285
1286         bt_dev_t *dev = NULL;
1287         Elm_Object_Item *item = NULL;
1288
1289         ret_if(event_info == NULL);
1290
1291         if(event_info) {
1292                 item = (Elm_Object_Item *)event_info;
1293                 elm_genlist_item_selected_set(item, EINA_FALSE);
1294         }
1295
1296         ret_if(data == NULL);
1297
1298         dev = (bt_dev_t *)data;
1299         ret_if(dev->ugd == NULL);
1300
1301         if (dev->status == BT_DEV_UNPAIRING)
1302                 return;
1303 #ifdef TIZEN_BT_A2DP_SINK_ENABLE
1304         if (dev->connected_mask & BT_MUSIC_PLAYER_CONNECTED) {
1305                 __bt_profile_disconnect_option((bt_ug_data *)dev->ugd,
1306                                         dev, BT_MUSIC_PLAYER_DEVICE);
1307         } else {
1308                 __bt_profile_connect_option((bt_ug_data *)dev->ugd,
1309                                                 dev, BT_MUSIC_PLAYER_DEVICE);
1310         }
1311 #else
1312         if (dev->connected_mask & BT_STEREO_HEADSET_CONNECTED) {
1313                 __bt_profile_disconnect_option((bt_ug_data *)dev->ugd,
1314                                         dev, BT_STEREO_HEADSET_DEVICE);
1315         } else {
1316                 __bt_profile_connect_option((bt_ug_data *)dev->ugd,
1317                                                 dev, BT_STEREO_HEADSET_DEVICE);
1318         }
1319 #endif
1320
1321         _bt_update_genlist_item(item);
1322
1323         FN_END;
1324 }
1325
1326 #ifdef TIZEN_HID
1327 static void __bt_profile_hid_option_item_sel(void *data, Evas_Object *obj,
1328                                       void *event_info)
1329 {
1330         FN_START;
1331
1332         bt_dev_t *dev = NULL;
1333         Elm_Object_Item *item = NULL;
1334
1335         ret_if(event_info == NULL);
1336
1337         if(event_info) {
1338                 item = (Elm_Object_Item *)event_info;
1339                 elm_genlist_item_selected_set(item, EINA_FALSE);
1340         }
1341
1342         ret_if(data == NULL);
1343
1344         dev = (bt_dev_t *)data;
1345         ret_if(dev->ugd == NULL);
1346
1347         if (dev->status == BT_DEV_UNPAIRING)
1348                 return;
1349
1350         if (dev->connected_mask & BT_HID_CONNECTED) {
1351                 __bt_profile_disconnect_option((bt_ug_data *)dev->ugd,
1352                                         dev, BT_HID_DEVICE);
1353         } else {
1354                 __bt_profile_connect_option((bt_ug_data *)dev->ugd,
1355                                                 dev, BT_HID_DEVICE);
1356         }
1357         _bt_update_genlist_item(item);
1358
1359         FN_END;
1360 }
1361 #endif
1362
1363 static void __bt_profile_nap_option_item_sel(void *data, Evas_Object *obj,
1364                                       void *event_info)
1365 {
1366         FN_START;
1367
1368         bt_dev_t *dev = NULL;
1369         Elm_Object_Item *item = NULL;
1370
1371         ret_if(event_info == NULL);
1372
1373         if(event_info) {
1374                 item = (Elm_Object_Item *)event_info;
1375                 elm_genlist_item_selected_set(item, EINA_FALSE);
1376         }
1377
1378         ret_if(data == NULL);
1379
1380         dev = (bt_dev_t *)data;
1381         ret_if(dev->ugd == NULL);
1382
1383         if (dev->status == BT_DEV_UNPAIRING)
1384                 return;
1385
1386         if (dev->connected_mask & BT_NETWORK_CONNECTED) {
1387                 __bt_profile_disconnect_option((bt_ug_data *)dev->ugd,
1388                                         dev, BT_NETWORK_DEVICE);
1389         } else {
1390                 __bt_profile_connect_option((bt_ug_data *)dev->ugd,
1391                                                 dev, BT_NETWORK_DEVICE);
1392         }
1393
1394         _bt_update_genlist_item(item);
1395
1396         FN_END;
1397 }
1398
1399 void _bt_update_detail_item_style(bt_profile_view_data *vd)
1400 {
1401         FN_START;
1402
1403         int item_count;
1404         int i = 1;
1405         Elm_Object_Item *item = NULL;
1406
1407         ret_if(vd == NULL);
1408         ret_if(vd->genlist == NULL);
1409
1410         item_count = elm_genlist_items_count(vd->genlist);
1411
1412         BT_INFO("item_count %d", item_count);
1413
1414         if (vd->title_item == NULL || item_count < 4)
1415                 return;
1416         /* Do not need to take care first 4 items as they are fixed */
1417         item_count = item_count - 5;
1418
1419         item = elm_genlist_item_next_get(vd->title_item);
1420
1421         while (item != NULL) {
1422                 if (item_count == 1) {
1423                         elm_object_item_signal_emit(item, "elm,state,normal", "");
1424                         break;
1425                 } else if (i == 1) {
1426                         elm_object_item_signal_emit(item, "elm,state,top", "");
1427                         i++;
1428                 } else if (item_count == i) {
1429                         elm_object_item_signal_emit(item, "elm,state,bottom", "");
1430                         break;
1431                 } else {
1432                         elm_object_item_signal_emit(item, "elm,state,center", "");
1433                         i++;
1434                 }
1435
1436                 item = elm_genlist_item_next_get(item);
1437         }
1438
1439         FN_END;
1440 }
1441
1442 static int __bt_profile_get_item_type(bt_profile_view_data *vd, Elm_Object_Item *item)
1443 {
1444         retv_if(vd == NULL, BT_ITEM_NONE);
1445         retv_if(item == NULL, BT_ITEM_NONE);
1446
1447         if (item == vd->name_item) {
1448                 return BT_ITEM_NAME;
1449         } else if (item == vd->unpair_item) {
1450                 return BT_ITEM_UNPAIR;
1451 #ifndef TELEPHONY_DISABLED
1452         } else if (item == vd->call_item) {
1453                 return BT_ITEM_CALL;
1454 #endif
1455         } else if (item == vd->media_item) {
1456                 return BT_ITEM_MEDIA;
1457         } else if (item == vd->hid_item) {
1458                 return BT_ITEM_HID;
1459         } else if (item == vd->network_item) {
1460                 return BT_ITEM_NETWORK;
1461         }
1462
1463         return BT_ITEM_NONE;
1464 }
1465
1466 static void __bt_profile_gl_realized(void *data, Evas_Object *obj, void *event_info)
1467 {
1468         FN_START;
1469
1470         int item_type;
1471         bt_ug_data *ugd;
1472         bt_profile_view_data *vd;
1473         Elm_Object_Item *item = (Elm_Object_Item *)event_info;
1474 #ifdef KIRAN_ACCESSIBILITY
1475         Evas_Object *ao;
1476         char str[BT_STR_ACCES_INFO_MAX_LEN] = {0, };
1477         bt_dev_t *dev_info;
1478 #endif
1479
1480         ret_if(data == NULL);
1481         ret_if(item == NULL);
1482
1483         ugd = (bt_ug_data *)data;
1484
1485         vd = ugd->profile_vd;
1486         ret_if(vd == NULL);
1487
1488         item_type = __bt_profile_get_item_type(vd, item);
1489
1490         BT_INFO("type: %d", item_type);
1491 #ifdef KIRAN_ACCESSIBILITY
1492         dev_info = (bt_dev_t *)elm_object_item_data_get(item);
1493         ao = elm_object_item_access_object_get(item);
1494 #endif
1495         switch (item_type) {
1496         case BT_ITEM_NAME:
1497                 elm_object_item_signal_emit(item, "elm,state,top", "");
1498
1499 #ifdef KIRAN_ACCESSIBILITY
1500                 if (dev_info != NULL)
1501                         snprintf(str, sizeof(str), "%s, %s, %s", BT_STR_DEVICE_NAME,
1502                                 dev_info->name, BT_STR_DOUBLE_TAP_RENAME);
1503                 else
1504                         snprintf(str, sizeof(str), "%s, %s", BT_STR_DEVICE_NAME,
1505                                 BT_STR_DOUBLE_TAP_RENAME);
1506
1507                 elm_access_info_set(ao, ELM_ACCESS_INFO, str);
1508 #endif
1509                 break;
1510         case BT_ITEM_UNPAIR:
1511                 elm_object_item_signal_emit(item, "elm,state,bottom", "");
1512
1513 #ifdef KIRAN_ACCESSIBILITY
1514                 snprintf(str, sizeof(str), "%s, %s", BT_STR_UNPAIR,
1515                                 BT_STR_DOUBLE_TAP_UNPAIR);
1516                 elm_access_info_set(ao, ELM_ACCESS_INFO, str);
1517 #endif
1518                 break;
1519
1520 #ifndef TELEPHONY_DISABLED
1521         case BT_ITEM_CALL:
1522 #ifdef KIRAN_ACCESSIBILITY
1523                 if (dev_info->call_checked)
1524                         snprintf(str, sizeof(str), "%s, %s, %s", BT_STR_CALL_AUDIO,
1525                                 BT_STR_RADIO_BUTTON, BT_STR_RADIO_SELECTED);
1526                 else
1527                         snprintf(str, sizeof(str), "%s, %s, %s", BT_STR_CALL_AUDIO,
1528                                 BT_STR_RADIO_BUTTON, BT_STR_RADIO_UNSELECTED);
1529                 elm_access_info_set(ao, ELM_ACCESS_INFO, str);
1530 #endif
1531                 break;
1532 #endif
1533         case BT_ITEM_MEDIA:
1534 #ifdef KIRAN_ACCESSIBILITY
1535                 if (dev_info->media_checked)
1536                         snprintf(str, sizeof(str), "%s, %s, %s", BT_STR_MEDIA_AUDIO,
1537                                 BT_STR_RADIO_BUTTON, BT_STR_RADIO_SELECTED);
1538                 else
1539                         snprintf(str, sizeof(str), "%s, %s, %s", BT_STR_MEDIA_AUDIO,
1540                                 BT_STR_RADIO_BUTTON, BT_STR_RADIO_UNSELECTED);
1541                 elm_access_info_set(ao, ELM_ACCESS_INFO, str);
1542 #endif
1543                 break;
1544
1545         case BT_ITEM_HID:
1546 #ifdef KIRAN_ACCESSIBILITY
1547                 if (dev_info->hid_checked)
1548                         snprintf(str, sizeof(str), "%s, %s, %s", BT_STR_INPUT_DEVICE,
1549                                 BT_STR_RADIO_BUTTON, BT_STR_RADIO_SELECTED);
1550                 else
1551                         snprintf(str, sizeof(str), "%s, %s, %s", BT_STR_INPUT_DEVICE,
1552                                 BT_STR_RADIO_BUTTON, BT_STR_RADIO_UNSELECTED);
1553                 elm_access_info_set(ao, ELM_ACCESS_INFO, str);
1554 #endif
1555                 break;
1556
1557         case BT_ITEM_NETWORK:
1558 #ifdef KIRAN_ACCESSIBILITY
1559                 if (dev_info->network_checked)
1560                         snprintf(str, sizeof(str), "%s, %s, %s", BT_STR_INTERNET_ACCESS,
1561                                 BT_STR_RADIO_BUTTON, BT_STR_RADIO_SELECTED);
1562                 else
1563                         snprintf(str, sizeof(str), "%s, %s, %s", BT_STR_INTERNET_ACCESS,
1564                                 BT_STR_RADIO_BUTTON, BT_STR_RADIO_UNSELECTED);
1565                 elm_access_info_set(ao, ELM_ACCESS_INFO, str);
1566 #endif
1567                 break;
1568
1569         case BT_ITEM_NONE:
1570         default:
1571                 break;
1572         }
1573
1574         _bt_update_detail_item_style(vd);
1575         FN_END;
1576 }
1577
1578 /* Create genlist and append items */
1579 static Evas_Object *__bt_profile_draw_genlist(bt_ug_data *ugd, bt_dev_t *dev_info)
1580 {
1581         FN_START;
1582
1583         bt_profile_view_data *vd = NULL;
1584         Evas_Object *genlist = NULL;
1585         Elm_Object_Item *git = NULL;
1586
1587         retv_if(ugd == NULL, NULL);
1588         retv_if(ugd->profile_vd == NULL, NULL);
1589
1590         vd = ugd->profile_vd;
1591
1592         /* Set item class for dialogue normal items */
1593         vd->name_itc = elm_genlist_item_class_new();
1594         retv_if (vd->name_itc == NULL, NULL);
1595         vd->name_itc->item_style = BT_GENLIST_2LINE_BOTTOM_TEXT_STYLE;
1596         vd->name_itc->func.text_get = __bt_profile_name_label_get;
1597         vd->name_itc->func.content_get = NULL;
1598         vd->name_itc->func.state_get = NULL;
1599         vd->name_itc->func.del = NULL;
1600
1601         vd->unpair_itc = elm_genlist_item_class_new();
1602         retv_if (vd->unpair_itc == NULL, NULL);
1603
1604         vd->unpair_itc->item_style = BT_GENLIST_1LINE_TEXT_STYLE;
1605         vd->unpair_itc->func.text_get = __bt_profile_unpair_label_get;
1606         vd->unpair_itc->func.content_get = NULL;
1607         vd->unpair_itc->func.state_get = NULL;
1608         vd->unpair_itc->func.del = NULL;
1609
1610         /* Create genlist */
1611         genlist = elm_genlist_add(ugd->navi_bar);
1612         elm_genlist_mode_set(genlist, ELM_LIST_COMPRESS);
1613         elm_genlist_homogeneous_set(genlist, EINA_FALSE);
1614         elm_genlist_block_count_set(genlist, 3);
1615
1616         evas_object_smart_callback_add(genlist, "realized",
1617                                 __bt_profile_gl_realized, ugd);
1618
1619         /* device name item */
1620         git = elm_genlist_item_append(genlist, vd->name_itc, dev_info, NULL,
1621                                     ELM_GENLIST_ITEM_NONE,
1622                                     __bt_profile_name_item_sel, ugd);
1623         vd->name_item = git;
1624
1625         /* unpair item */
1626         git = elm_genlist_item_append(genlist, vd->unpair_itc, NULL, NULL,
1627                                     ELM_GENLIST_ITEM_NONE,
1628                                     __bt_profile_unpair_item_sel, dev_info);
1629         vd->unpair_item = git;
1630
1631         /* If the device has no headset profile, exit this function */
1632         if (!(dev_info->service_list & BT_SC_HFP_SERVICE_MASK) &&
1633                 !(dev_info->service_list & BT_SC_HSP_SERVICE_MASK) &&
1634                 !(dev_info->service_list & BT_SC_A2DP_SERVICE_MASK) &&
1635                 !(dev_info->service_list & BT_SC_A2DP_SOURCE_SERVICE_MASK) &&
1636                 !(dev_info->service_list & BT_SC_HID_SERVICE_MASK) &&
1637                 !(dev_info->service_list & BT_SC_NAP_SERVICE_MASK)) {
1638                 return genlist;
1639         }
1640
1641         vd->title_itc = elm_genlist_item_class_new();
1642         retv_if (vd->title_itc == NULL, NULL);
1643
1644         vd->title_itc->item_style = BT_GENLIST_GROUP_INDEX_STYLE;
1645         vd->title_itc->func.text_get = __bt_proflie_title_label_get;
1646         vd->title_itc->func.content_get = NULL;
1647         vd->title_itc->func.state_get = NULL;
1648         vd->title_itc->func.del = NULL;
1649
1650 #ifndef TELEPHONY_DISABLED
1651         vd->call_itc = elm_genlist_item_class_new();
1652         retv_if (vd->call_itc == NULL, NULL);
1653
1654         vd->call_itc->item_style = BT_GENLIST_1LINE_TEXT_ICON_STYLE;
1655         vd->call_itc->func.text_get = __bt_proflie_call_option_label_get;
1656         vd->call_itc->func.content_get = __bt_profile_call_option_icon_get;
1657         vd->call_itc->func.state_get = NULL;
1658         vd->call_itc->func.del = NULL;
1659 #endif
1660         vd->media_itc = elm_genlist_item_class_new();
1661         retv_if (vd->media_itc == NULL, NULL);
1662
1663         vd->media_itc->item_style = BT_GENLIST_1LINE_TEXT_ICON_STYLE;
1664         vd->media_itc->func.text_get = __bt_proflie_media_option_label_get;
1665         vd->media_itc->func.content_get = __bt_profile_media_option_icon_get;
1666         vd->media_itc->func.state_get = NULL;
1667         vd->media_itc->func.del = NULL;
1668
1669         vd->hid_itc = elm_genlist_item_class_new();
1670         retv_if (vd->hid_itc == NULL, NULL);
1671
1672         vd->hid_itc->item_style = BT_GENLIST_1LINE_TEXT_ICON_STYLE;
1673         vd->hid_itc->func.text_get = __bt_proflie_hid_option_label_get;
1674         vd->hid_itc->func.content_get = __bt_profile_hid_option_icon_get;
1675         vd->hid_itc->func.state_get = NULL;
1676         vd->hid_itc->func.del = NULL;
1677
1678 #ifndef TIZEN_BT_A2DP_SINK_ENABLE
1679         vd->network_itc = elm_genlist_item_class_new();
1680         retv_if (vd->network_itc == NULL, NULL);
1681
1682         vd->network_itc->item_style = BT_GENLIST_1LINE_TEXT_ICON_STYLE;
1683         vd->network_itc->func.text_get = __bt_proflie_nap_option_label_get;
1684         vd->network_itc->func.content_get = __bt_profile_nap_option_icon_get;
1685         vd->network_itc->func.state_get = NULL;
1686         vd->network_itc->func.del = NULL;
1687 #endif
1688         /* Connection options title */
1689         git = elm_genlist_item_append(genlist, vd->title_itc, NULL, NULL,
1690                                     ELM_GENLIST_ITEM_NONE,
1691                                     NULL, NULL);
1692
1693         elm_genlist_item_select_mode_set(git,
1694                                 ELM_OBJECT_SELECT_MODE_DISPLAY_ONLY);
1695
1696         vd->title_item = git;
1697
1698 #ifndef TELEPHONY_DISABLED
1699         if (dev_info->service_list & BT_SC_HFP_SERVICE_MASK ||
1700              dev_info->service_list & BT_SC_HSP_SERVICE_MASK) {
1701                 /* Call audio */
1702                 git = elm_genlist_item_append(genlist, vd->call_itc,
1703                                         dev_info, NULL,
1704                                         ELM_GENLIST_ITEM_NONE,
1705                                         __bt_profile_call_option_item_sel,
1706                                         dev_info);
1707                 vd->call_item = git;
1708         }
1709 #endif
1710 #ifdef TIZEN_BT_A2DP_SINK_ENABLE
1711         if (dev_info->service_list & BT_SC_A2DP_SOURCE_SERVICE_MASK) {
1712 #else
1713         if (dev_info->service_list & BT_SC_A2DP_SERVICE_MASK) {
1714 #endif
1715                 /* Media audio */
1716                 git = elm_genlist_item_append(genlist, vd->media_itc,
1717                                         dev_info, NULL,
1718                                         ELM_GENLIST_ITEM_NONE,
1719                                         __bt_profile_media_option_item_sel,
1720                                         dev_info);
1721
1722                 vd->media_item = git;
1723         }
1724         BT_INFO("service list: %x", dev_info->service_list);
1725         BT_INFO("is hid: %d", dev_info->service_list & BT_SC_HID_SERVICE_MASK);
1726
1727         if (dev_info->service_list & BT_SC_HID_SERVICE_MASK) {
1728 #ifdef TIZEN_HID
1729                 /* HID device */
1730                 git = elm_genlist_item_append(genlist, vd->hid_itc,
1731                                         dev_info, NULL,
1732                                         ELM_GENLIST_ITEM_NONE,
1733                                         __bt_profile_hid_option_item_sel,
1734                                         dev_info);
1735                 vd->hid_item = git;
1736 #else
1737                 /* HID device */
1738                 BT_INFO("HID options is disabled");
1739                 git = elm_genlist_item_append(genlist, vd->hid_itc,
1740                                         dev_info, NULL,
1741                                         ELM_GENLIST_ITEM_NONE,
1742                                         NULL,
1743                                         NULL);
1744                 vd->hid_item = git;
1745                 BT_INFO("HID item disabled");
1746                 elm_object_item_disabled_set (vd->hid_item, EINA_TRUE);
1747 #endif
1748         }
1749
1750 #ifndef TIZEN_BT_A2DP_SINK_ENABLE
1751         if (dev_info->service_list & BT_SC_NAP_SERVICE_MASK) {
1752                 /* NAP device */
1753                 git = elm_genlist_item_append(genlist, vd->network_itc,
1754                                         dev_info, NULL,
1755                                         ELM_GENLIST_ITEM_NONE,
1756                                         __bt_profile_nap_option_item_sel,
1757                                         dev_info);
1758                 vd->network_item = git;
1759         }
1760 #endif
1761         FN_END;
1762
1763         return genlist;
1764 }
1765
1766 void _bt_profile_destroy_profile_view(void *data)
1767 {
1768         FN_START;
1769
1770         bt_ug_data *ugd = (bt_ug_data *)data;
1771         bt_profile_view_data *vd = NULL;
1772
1773         ret_if(ugd == NULL);
1774         ret_if(ugd->profile_vd == NULL);
1775
1776         vd = ugd->profile_vd;
1777
1778         if (vd->name_itc) {
1779                 elm_genlist_item_class_free(vd->name_itc);
1780                 vd->name_itc = NULL;
1781         }
1782
1783         if (vd->unpair_itc) {
1784                 elm_genlist_item_class_free(vd->unpair_itc);
1785                 vd->unpair_itc = NULL;
1786         }
1787
1788         if (vd->title_itc) {
1789                 elm_genlist_item_class_free(vd->title_itc);
1790                 vd->title_itc = NULL;
1791         }
1792
1793 #ifndef TELEPHONY_DISABLED
1794         if (vd->call_itc) {
1795                 elm_genlist_item_class_free(vd->call_itc);
1796                 vd->call_itc = NULL;
1797         }
1798 #endif
1799
1800         if (vd->media_itc) {
1801                 elm_genlist_item_class_free(vd->media_itc);
1802                 vd->media_itc = NULL;
1803         }
1804
1805         if (vd->hid_itc) {
1806                 elm_genlist_item_class_free(vd->hid_itc);
1807                 vd->hid_itc = NULL;
1808         }
1809 #ifndef TIZEN_BT_A2DP_SINK_ENABLE
1810         if (vd->network_itc) {
1811                 elm_genlist_item_class_free(vd->network_itc);
1812                 vd->network_itc = NULL;
1813         }
1814 #endif
1815         vd->save_btn = NULL;
1816
1817         /* unregister callback functions */
1818         if (vd->imf_context) {
1819                 ecore_imf_context_input_panel_event_callback_del(vd->imf_context,
1820                                         ECORE_IMF_INPUT_PANEL_STATE_EVENT,
1821                                         __bt_profile_input_panel_state_cb);
1822                 vd->imf_context = NULL;
1823         }
1824
1825         free(vd);
1826         ugd->profile_vd = NULL;
1827
1828         FN_END;
1829 }
1830
1831 static Eina_Bool __bt_profile_back_clicked_cb(void *data, Elm_Object_Item *it)
1832 {
1833         FN_START;
1834         retv_if(!data, EINA_TRUE);
1835
1836         bt_ug_data *ugd = (bt_ug_data *)data;
1837         ugd->profile_vd = NULL;
1838
1839         if (ugd->popup != NULL){
1840                 evas_object_del(ugd->popup);
1841                 ugd->popup = NULL;
1842                 ugd->is_popup_exist = 0;
1843         }
1844
1845         FN_END;
1846         return EINA_TRUE;
1847 }
1848
1849 /**********************************************************************
1850 *                                              Common Functions
1851 ***********************************************************************/
1852
1853 void _bt_profile_create_view(bt_dev_t *dev_info)
1854 {
1855         FN_START;
1856
1857         bt_profile_view_data *vd;
1858         bt_ug_data *ugd;
1859         Evas_Object *genlist;
1860         Elm_Object_Item *navi_it;
1861         int connected;
1862
1863         ret_if(dev_info == NULL);
1864         ret_if(dev_info->ugd == NULL);
1865
1866         ugd = dev_info->ugd;
1867
1868         vd = calloc(1, sizeof(bt_profile_view_data));
1869         ret_if(vd == NULL);
1870
1871         ugd->profile_vd = vd;
1872         vd->win_main = ugd->win_main;
1873         vd->navi_bar = ugd->navi_bar;
1874
1875
1876         if (dev_info->service_list & BT_SC_HFP_SERVICE_MASK ||
1877             dev_info->service_list & BT_SC_HSP_SERVICE_MASK ||
1878             dev_info->service_list & BT_SC_A2DP_SERVICE_MASK) {
1879                 connected = _bt_util_is_profile_connected(BT_HEADSET_CONNECTED,
1880                                                      dev_info->bd_addr);
1881                 dev_info->connected_mask |= connected ? BT_HEADSET_CONNECTED : 0x00;
1882
1883                 connected =
1884                     _bt_util_is_profile_connected(BT_STEREO_HEADSET_CONNECTED,
1885                                              dev_info->bd_addr);
1886                 dev_info->connected_mask |=
1887                     connected ? BT_STEREO_HEADSET_CONNECTED : 0x00;
1888         } else if (dev_info->service_list & BT_SC_A2DP_SOURCE_SERVICE_MASK ) {
1889                 connected = _bt_util_is_profile_connected(BT_MUSIC_PLAYER_CONNECTED,
1890                                                      dev_info->bd_addr);
1891                 dev_info->connected_mask |=
1892                     connected ? BT_MUSIC_PLAYER_CONNECTED : 0x00;
1893         } else if (dev_info->service_list & BT_SC_HID_SERVICE_MASK) {
1894                 connected = _bt_util_is_profile_connected(BT_HID_CONNECTED,
1895                                                      dev_info->bd_addr);
1896                 dev_info->connected_mask |= connected ? BT_HID_CONNECTED : 0x00;
1897         } else {
1898                 connected = _bt_util_is_profile_connected(BT_NETWORK_CONNECTED,
1899                                         dev_info->bd_addr);
1900                 if (!connected)
1901                         connected = _bt_util_is_profile_connected(
1902                                                 BT_NETWORK_SERVER_CONNECTED,
1903                                                 dev_info->bd_addr);
1904                 dev_info->connected_mask |= connected ? BT_NETWORK_CONNECTED : 0x00;
1905         }
1906
1907         genlist = __bt_profile_draw_genlist(ugd, dev_info);
1908         vd->genlist = genlist;
1909
1910         /* Set ugd as genlist object data. */
1911         /* We can get this data from genlist object anytime. */
1912         evas_object_data_set(genlist, "view_data", vd);
1913
1914         navi_it = elm_naviframe_item_push(vd->navi_bar, BT_STR_DETAILS,
1915                                         NULL, NULL, genlist, NULL);
1916
1917         elm_naviframe_prev_btn_auto_pushed_set(vd->navi_bar, EINA_FALSE);
1918
1919         elm_naviframe_item_pop_cb_set(navi_it, __bt_profile_back_clicked_cb,
1920                                                                 ugd);
1921
1922         vd->navi_it = navi_it;
1923
1924         FN_END;
1925
1926         return;
1927 }
1928
1929 void _bt_profile_delete_view(void *data)
1930 {
1931         FN_START;
1932
1933         bt_ug_data *ugd;
1934
1935         ret_if(data == NULL);
1936
1937         ugd = (bt_ug_data *)data;
1938
1939         _bt_profile_destroy_profile_view(ugd);
1940
1941         elm_naviframe_item_pop(ugd->navi_bar);
1942
1943         if (ugd->rename_popup != NULL) {
1944                 BT_INFO("Destorying rename_popup");
1945                 evas_object_del(ugd->rename_popup);
1946                 ugd->rename_popup = NULL;
1947                 ugd->rename_entry = NULL;
1948         }
1949
1950         FN_END;
1951 }
1952