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