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         gboolean connected = FALSE;
 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         connected = _bt_util_is_profile_connected(BT_NETWORK_CONNECTED, dev->bd_addr);
 882
 883         if (connected) {
 884                 ret = __bt_profile_disconnect_option((bt_ug_data *)dev->ugd,
 885                                         dev, BT_NETWORK_DEVICE);
 886         } else {
 887                 ret = __bt_profile_connect_option((bt_ug_data *)dev->ugd,
 888                                                 dev, BT_NETWORK_DEVICE);
 889         }
 890
 891         if (ret == BT_UG_FAIL)
 892                 elm_check_state_set(obj, dev->network_checked);
 893
 894         FN_END;
 895
 896 }
 897
 898 #ifndef TELEPHONY_DISABLED
 899 static Evas_Object *__bt_profile_call_option_icon_get(void *data, Evas_Object *obj,
 900                                           const char *part)
 901 {
 902         FN_START;
 903
 904         Evas_Object *check = NULL;
 905         bt_dev_t *dev = NULL;
 906
 907         retv_if(NULL == data, NULL);
 908
 909         dev = (bt_dev_t *)data;
 910
 911         if (!strcmp("elm.swallow.end", part)) {
 912                 check = elm_check_add(obj);
 913                 elm_object_style_set(check, "on&off");
 914
 915                 dev->call_checked = dev->connected_mask & \
 916                                         BT_HEADSET_CONNECTED;
 917                 elm_check_state_set(check, dev->call_checked);
 918
 919                 evas_object_size_hint_weight_set(check, EVAS_HINT_EXPAND,
 920                                                 EVAS_HINT_EXPAND);
 921                 evas_object_size_hint_align_set(check, EVAS_HINT_FILL,
 922                                                 EVAS_HINT_FILL);
 923
 924                 evas_object_smart_callback_add(check, "changed", __bt_profile_call_option_checkbox_sel, dev);
 925
 926                 evas_object_propagate_events_set(check, EINA_FALSE);
 927                 evas_object_show(check);
 928         }
 929         FN_END;
 930         return check;
 931 }
 932 #endif
 933
 934 static Evas_Object *__bt_profile_media_option_icon_get(void *data, Evas_Object *obj,
 935                                           const char *part)
 936 {
 937         FN_START;
 938
 939         Evas_Object *check = NULL;
 940         bt_dev_t *dev = NULL;
 941
 942         retv_if(NULL == data, NULL);
 943
 944         dev = (bt_dev_t *)data;
 945
 946         if (!strcmp("elm.swallow.end", part)) {
 947                 check = elm_check_add(obj);
 948                 elm_object_style_set(check, "on&off");
 949 #ifdef TIZEN_BT_A2DP_SINK_ENABLE
 950                 dev->media_checked = dev->connected_mask & \
 951                                         BT_MUSIC_PLAYER_CONNECTED;
 952 #else
 953                 dev->media_checked = dev->connected_mask & \
 954                                         BT_STEREO_HEADSET_CONNECTED;
 955 #endif
 956                 elm_check_state_set(check, dev->media_checked);
 957
 958                 evas_object_size_hint_weight_set(check, EVAS_HINT_EXPAND,
 959                                                 EVAS_HINT_EXPAND);
 960                 evas_object_size_hint_align_set(check, EVAS_HINT_FILL,
 961                                                 EVAS_HINT_FILL);
 962
 963                 evas_object_smart_callback_add(check, "changed", __bt_profile_media_option_checkbox_sel, dev);
 964
 965                 evas_object_propagate_events_set(check, EINA_FALSE);
 966                 evas_object_show(check);
 967         }
 968         FN_END;
 969         return check;
 970 }
 971
 972 static Evas_Object *__bt_profile_hid_option_icon_get(void *data, Evas_Object *obj,
 973                                           const char *part)
 974 {
 975         FN_START;
 976
 977         Evas_Object *check = NULL;
 978         bt_dev_t *dev = NULL;
 979
 980         retv_if(NULL == data, NULL);
 981
 982         dev = (bt_dev_t *)data;
 983
 984         if (!strcmp("elm.swallow.end", part)) {
 985                 check = elm_check_add(obj);
 986                 elm_object_style_set(check, "on&off");
 987
 988                 dev->hid_checked = dev->connected_mask & \
 989                                         BT_HID_CONNECTED;
 990                 elm_check_state_set(check, dev->hid_checked);
 991
 992                 evas_object_size_hint_weight_set(check, EVAS_HINT_EXPAND,
 993                                                 EVAS_HINT_EXPAND);
 994                 evas_object_size_hint_align_set(check, EVAS_HINT_FILL,
 995                                                 EVAS_HINT_FILL);
 996
 997                 evas_object_smart_callback_add(check, "changed", __bt_profile_hid_option_checkbox_sel, dev);
 998
 999                 evas_object_propagate_events_set(check, EINA_FALSE);
1000                 evas_object_show(check);
1001         }
1002         FN_END;
1003         return check;
1004 }
1005
1006 static Evas_Object *__bt_profile_nap_option_icon_get(void *data, Evas_Object *obj,
1007                                           const char *part)
1008 {
1009         FN_START;
1010
1011         Evas_Object *check = NULL;
1012         bt_dev_t *dev = NULL;
1013
1014         retv_if(NULL == data, NULL);
1015
1016         dev = (bt_dev_t *)data;
1017
1018         if (!strcmp("elm.swallow.end", part)) {
1019                 check = elm_check_add(obj);
1020                 elm_object_style_set(check, "on&off");
1021
1022                 dev->network_checked = _bt_util_is_profile_connected(BT_NETWORK_CONNECTED, dev->bd_addr);
1023
1024                 elm_check_state_set(check, dev->network_checked);
1025
1026                 evas_object_size_hint_weight_set(check, EVAS_HINT_EXPAND,
1027                                                 EVAS_HINT_EXPAND);
1028                 evas_object_size_hint_align_set(check, EVAS_HINT_FILL,
1029                                                 EVAS_HINT_FILL);
1030
1031                 evas_object_smart_callback_add(check, "changed", __bt_profile_nap_option_checkbox_sel, dev);
1032
1033                 evas_object_propagate_events_set(check, EINA_FALSE);
1034                 evas_object_show(check);
1035         }
1036         FN_END;
1037         return check;
1038 }
1039
1040 int __bt_profile_connect_option(bt_ug_data *ugd, bt_dev_t *dev,
1041                                 bt_device_type type)
1042 {
1043         FN_START;
1044
1045         int audio_profile;
1046
1047         retv_if(ugd == NULL, BT_UG_FAIL);
1048         retv_if(dev == NULL, BT_UG_FAIL);
1049
1050         if (type == BT_HEADSET_DEVICE || type == BT_STEREO_HEADSET_DEVICE ||
1051                         type == BT_MUSIC_PLAYER_DEVICE) {
1052                 if (type == BT_STEREO_HEADSET_DEVICE)
1053                         audio_profile = BT_AUDIO_PROFILE_TYPE_A2DP;
1054 #ifdef TIZEN_BT_A2DP_SINK_ENABLE
1055                 else if (type == BT_MUSIC_PLAYER_DEVICE)
1056                         audio_profile = BT_AUDIO_PROFILE_TYPE_A2DP_SINK;
1057 #endif
1058                 else
1059                         audio_profile = BT_AUDIO_PROFILE_TYPE_HSP_HFP;
1060
1061                 if (bt_audio_connect(dev->addr_str,
1062                                 audio_profile) != BT_ERROR_NONE) {
1063                         BT_ERR("Fail to connect Headset device");
1064                         return BT_UG_FAIL;
1065                 }
1066         } else if (type == BT_HID_DEVICE) {
1067 #ifdef TIZEN_HID
1068
1069                 BT_DBG("HID connect request");
1070
1071                 if (bt_hid_host_connect(dev->addr_str) != BT_ERROR_NONE) {
1072                         return BT_UG_FAIL;
1073                 }
1074 #endif
1075         } else if (type == BT_NETWORK_DEVICE){
1076                 BT_DBG("Network connect request");
1077
1078                 void *net_profile;
1079
1080                 if (dev->net_profile) {
1081                         if (_bt_connect_net_profile(ugd->connection,
1082                                                 dev->net_profile,
1083                                                 dev) != BT_UG_ERROR_NONE) {
1084                                 BT_ERR("Fail to connect the net profile");
1085                                 return BT_UG_FAIL;
1086                         }
1087                 } else {
1088                         net_profile =
1089                                 _bt_get_registered_net_profile(ugd->connection,
1090                                                                 dev->bd_addr);
1091                         if (net_profile) {
1092                                 _bt_set_profile_state_changed_cb(net_profile, dev);
1093
1094                                 if (_bt_connect_net_profile(ugd->connection,
1095                                                         net_profile,
1096                                                         dev) != BT_UG_ERROR_NONE) {
1097                                         BT_ERR("Fail to connect the net profile");
1098                                         return BT_UG_FAIL;
1099                                 }
1100                         } else {
1101                                 BT_ERR("No registered net profile");
1102                                 return BT_UG_FAIL;
1103                         }
1104                 }
1105         } else {
1106                 BT_ERR("Unknown type");
1107                 return BT_UG_FAIL;
1108         }
1109
1110         ugd->connect_req = TRUE;
1111         dev->status = BT_CONNECTING;
1112         _bt_update_genlist_item((Elm_Object_Item *)dev->genlist_item);
1113
1114         retv_if(ugd->profile_vd == NULL, BT_UG_FAIL);
1115
1116         if (ugd->profile_vd->genlist) {
1117                 _bt_util_set_list_disabled(ugd->profile_vd->genlist,
1118                                         EINA_TRUE);
1119         }
1120
1121         FN_END;
1122         return BT_UG_ERROR_NONE;
1123 }
1124
1125 int __bt_profile_disconnect_option(bt_ug_data *ugd, bt_dev_t *dev,
1126                                         bt_device_type type)
1127 {
1128         FN_START;
1129
1130         int audio_profile;
1131         bt_ug_ipc_param_t param;
1132         gboolean connected = FALSE;
1133         gboolean connected_nap_profile = FALSE;
1134
1135         retv_if(ugd == NULL, BT_UG_FAIL);
1136         retv_if(dev == NULL, BT_UG_FAIL);
1137
1138         memset(&param, 0x00, sizeof(bt_ug_ipc_param_t));
1139         memcpy(param.param2, dev->bd_addr, BT_ADDRESS_LENGTH_MAX);
1140
1141         if (type == BT_HEADSET_DEVICE) {
1142                 connected = _bt_util_is_profile_connected(BT_HEADSET_CONNECTED,
1143                                                 dev->bd_addr);
1144         } else if (type == BT_STEREO_HEADSET_DEVICE) {
1145                 connected = _bt_util_is_profile_connected(BT_STEREO_HEADSET_CONNECTED,
1146                                                 dev->bd_addr);
1147         } else if (type == BT_MUSIC_PLAYER_DEVICE) {
1148                 connected = _bt_util_is_profile_connected(BT_MUSIC_PLAYER_CONNECTED,
1149                                                 dev->bd_addr);
1150         } else if (type == BT_HID_DEVICE) {
1151                 connected = _bt_util_is_profile_connected(BT_HID_CONNECTED,
1152                                                 dev->bd_addr);
1153         } else if (type == BT_NETWORK_DEVICE) {
1154                 connected = _bt_util_is_profile_connected(BT_NETWORK_CONNECTED,
1155                                                 dev->bd_addr);
1156                 /* Need to check */
1157                 if (!connected) {
1158                         connected = _bt_util_is_profile_connected(BT_NETWORK_SERVER_CONNECTED,
1159                                                 dev->bd_addr);
1160                         connected_nap_profile = connected;
1161                 }
1162         }
1163
1164         if (connected == FALSE) {
1165                 BT_ERR("Not connected");
1166                 return BT_UG_FAIL;
1167         }
1168
1169         if (type == BT_HEADSET_DEVICE || type == BT_STEREO_HEADSET_DEVICE ||
1170                         type == BT_MUSIC_PLAYER_DEVICE) {
1171                 if (type == BT_STEREO_HEADSET_DEVICE)
1172                         audio_profile = BT_AUDIO_PROFILE_TYPE_A2DP;
1173 #ifdef TIZEN_BT_A2DP_SINK_ENABLE
1174                 else if (type == BT_MUSIC_PLAYER_DEVICE)
1175                         audio_profile = BT_AUDIO_PROFILE_TYPE_A2DP_SINK;
1176 #endif
1177                 else
1178                         audio_profile = BT_AUDIO_PROFILE_TYPE_HSP_HFP;
1179
1180                 if (bt_audio_disconnect(dev->addr_str,
1181                                 audio_profile) != BT_ERROR_NONE) {
1182                         BT_ERR("Fail to connect Headset device");
1183                         return BT_UG_FAIL;
1184                 }
1185         } else if (type == BT_HID_DEVICE) {
1186                 BT_DBG("Disconnecting HID service!!");
1187
1188                 if (bt_hid_host_disconnect(dev->addr_str) != BT_ERROR_NONE) {
1189                         BT_ERR("Fail to disconnect HID device");
1190                         return BT_UG_FAIL;
1191                 }
1192         } else if (type == BT_NETWORK_DEVICE) {
1193
1194                 void *net_profile;
1195
1196                 if (connected_nap_profile == FALSE) {
1197                         BT_DBG("Disconnecting network service!! [PANU]");
1198                         if (dev->net_profile) {
1199                                 if (_bt_disconnect_net_profile(ugd->connection,
1200                                                         dev->net_profile,
1201                                                         dev) != BT_UG_ERROR_NONE) {
1202                                         BT_ERR("Fail to disconnect the net profile");
1203                                         return BT_UG_FAIL;
1204                                 }
1205                         } else {
1206                                 net_profile =
1207                                         _bt_get_registered_net_profile(ugd->connection,
1208                                                                         dev->bd_addr);
1209                                 if (net_profile) {
1210                                         _bt_set_profile_state_changed_cb(net_profile, dev);
1211                                         if (_bt_disconnect_net_profile(ugd->connection,
1212                                                                 dev->net_profile,
1213                                                                 dev) != BT_UG_ERROR_NONE) {
1214                                                 BT_ERR("Fail to disconnect the net profile");
1215                                                 return BT_UG_FAIL;
1216                                         }
1217                                 } else {
1218                                         BT_ERR("No registered net profile");
1219                                         return BT_UG_FAIL;
1220                                 }
1221                         }
1222                 } else {
1223                         BT_DBG("Disconnecting network service!! [NAP]");
1224                         if (bt_nap_disconnect(dev->addr_str) == BT_UG_ERROR_NONE)
1225                                 BT_ERR("Failed to disconnect pan server");
1226                 }
1227
1228         } else {
1229                 BT_ERR("Unknown type");
1230                 return BT_UG_FAIL;
1231         }
1232
1233         ugd->connect_req = TRUE;
1234         dev->status = BT_DISCONNECTING;
1235         _bt_update_genlist_item((Elm_Object_Item *)dev->genlist_item);
1236
1237         if (ugd->profile_vd->genlist) {
1238                 _bt_util_set_list_disabled(ugd->profile_vd->genlist,
1239                                         EINA_TRUE);
1240         }
1241
1242         FN_END;
1243         return BT_UG_ERROR_NONE;
1244 }
1245
1246 #ifndef TELEPHONY_DISABLED
1247 static void __bt_profile_call_option_item_sel(void *data, Evas_Object *obj,
1248                                       void *event_info)
1249 {
1250         FN_START;
1251
1252         bt_dev_t *dev = NULL;
1253         Elm_Object_Item *item = NULL;
1254
1255         ret_if(event_info == NULL);
1256
1257         if(event_info) {
1258                 item = (Elm_Object_Item *)event_info;
1259                 elm_genlist_item_selected_set(item, EINA_FALSE);
1260         }
1261
1262         ret_if(data == NULL);
1263
1264         dev = (bt_dev_t *)data;
1265         ret_if(dev->ugd == NULL);
1266
1267         if (dev->status == BT_DEV_UNPAIRING)
1268                 return;
1269
1270         if (dev->connected_mask & BT_HEADSET_CONNECTED) {
1271                 __bt_profile_disconnect_option((bt_ug_data *)dev->ugd,
1272                                         dev, BT_HEADSET_DEVICE);
1273         } else {
1274                 __bt_profile_connect_option((bt_ug_data *)dev->ugd,
1275                                                 dev, BT_HEADSET_DEVICE);
1276         }
1277         _bt_update_genlist_item(item);
1278
1279         FN_END;
1280 }
1281 #endif
1282
1283 static void __bt_profile_media_option_item_sel(void *data, Evas_Object *obj,
1284                                       void *event_info)
1285 {
1286         FN_START;
1287
1288         bt_dev_t *dev = NULL;
1289         Elm_Object_Item *item = NULL;
1290
1291         ret_if(event_info == NULL);
1292
1293         if(event_info) {
1294                 item = (Elm_Object_Item *)event_info;
1295                 elm_genlist_item_selected_set(item, EINA_FALSE);
1296         }
1297
1298         ret_if(data == NULL);
1299
1300         dev = (bt_dev_t *)data;
1301         ret_if(dev->ugd == NULL);
1302
1303         if (dev->status == BT_DEV_UNPAIRING)
1304                 return;
1305 #ifdef TIZEN_BT_A2DP_SINK_ENABLE
1306         if (dev->connected_mask & BT_MUSIC_PLAYER_CONNECTED) {
1307                 __bt_profile_disconnect_option((bt_ug_data *)dev->ugd,
1308                                         dev, BT_MUSIC_PLAYER_DEVICE);
1309         } else {
1310                 __bt_profile_connect_option((bt_ug_data *)dev->ugd,
1311                                                 dev, BT_MUSIC_PLAYER_DEVICE);
1312         }
1313 #else
1314         if (dev->connected_mask & BT_STEREO_HEADSET_CONNECTED) {
1315                 __bt_profile_disconnect_option((bt_ug_data *)dev->ugd,
1316                                         dev, BT_STEREO_HEADSET_DEVICE);
1317         } else {
1318                 __bt_profile_connect_option((bt_ug_data *)dev->ugd,
1319                                                 dev, BT_STEREO_HEADSET_DEVICE);
1320         }
1321 #endif
1322
1323         _bt_update_genlist_item(item);
1324
1325         FN_END;
1326 }
1327
1328 #ifdef TIZEN_HID
1329 static void __bt_profile_hid_option_item_sel(void *data, Evas_Object *obj,
1330                                       void *event_info)
1331 {
1332         FN_START;
1333
1334         bt_dev_t *dev = NULL;
1335         Elm_Object_Item *item = NULL;
1336
1337         ret_if(event_info == NULL);
1338
1339         if(event_info) {
1340                 item = (Elm_Object_Item *)event_info;
1341                 elm_genlist_item_selected_set(item, EINA_FALSE);
1342         }
1343
1344         ret_if(data == NULL);
1345
1346         dev = (bt_dev_t *)data;
1347         ret_if(dev->ugd == NULL);
1348
1349         if (dev->status == BT_DEV_UNPAIRING)
1350                 return;
1351
1352         if (dev->connected_mask & BT_HID_CONNECTED) {
1353                 __bt_profile_disconnect_option((bt_ug_data *)dev->ugd,
1354                                         dev, BT_HID_DEVICE);
1355         } else {
1356                 __bt_profile_connect_option((bt_ug_data *)dev->ugd,
1357                                                 dev, BT_HID_DEVICE);
1358         }
1359         _bt_update_genlist_item(item);
1360
1361         FN_END;
1362 }
1363 #endif
1364
1365 static void __bt_profile_nap_option_item_sel(void *data, Evas_Object *obj,
1366                                       void *event_info)
1367 {
1368         FN_START;
1369
1370         bt_dev_t *dev = NULL;
1371         Elm_Object_Item *item = NULL;
1372         gboolean connected = FALSE;
1373
1374         ret_if(event_info == NULL);
1375
1376         if(event_info) {
1377                 item = (Elm_Object_Item *)event_info;
1378                 elm_genlist_item_selected_set(item, EINA_FALSE);
1379         }
1380
1381         ret_if(data == NULL);
1382
1383         dev = (bt_dev_t *)data;
1384         ret_if(dev->ugd == NULL);
1385
1386         if (dev->status == BT_DEV_UNPAIRING)
1387                 return;
1388
1389         connected = _bt_util_is_profile_connected(BT_NETWORK_CONNECTED, dev->bd_addr);
1390
1391         if (connected) {
1392                 __bt_profile_disconnect_option((bt_ug_data *)dev->ugd,
1393                                         dev, BT_NETWORK_DEVICE);
1394         } else {
1395                 __bt_profile_connect_option((bt_ug_data *)dev->ugd,
1396                                                 dev, BT_NETWORK_DEVICE);
1397         }
1398
1399         _bt_update_genlist_item(item);
1400
1401         FN_END;
1402 }
1403
1404 void _bt_update_detail_item_style(bt_profile_view_data *vd)
1405 {
1406         FN_START;
1407
1408         int item_count;
1409         int i = 1;
1410         Elm_Object_Item *item = NULL;
1411
1412         ret_if(vd == NULL);
1413         ret_if(vd->genlist == NULL);
1414
1415         item_count = elm_genlist_items_count(vd->genlist);
1416
1417         BT_INFO("item_count %d", item_count);
1418
1419         if (vd->title_item == NULL || item_count < 4)
1420                 return;
1421         /* Do not need to take care first 4 items as they are fixed */
1422         item_count = item_count - 5;
1423
1424         item = elm_genlist_item_next_get(vd->title_item);
1425
1426         while (item != NULL) {
1427                 if (item_count == 1) {
1428                         elm_object_item_signal_emit(item, "elm,state,normal", "");
1429                         break;
1430                 } else if (i == 1) {
1431                         elm_object_item_signal_emit(item, "elm,state,top", "");
1432                         i++;
1433                 } else if (item_count == i) {
1434                         elm_object_item_signal_emit(item, "elm,state,bottom", "");
1435                         break;
1436                 } else {
1437                         elm_object_item_signal_emit(item, "elm,state,center", "");
1438                         i++;
1439                 }
1440
1441                 item = elm_genlist_item_next_get(item);
1442         }
1443
1444         FN_END;
1445 }
1446
1447 static int __bt_profile_get_item_type(bt_profile_view_data *vd, Elm_Object_Item *item)
1448 {
1449         retv_if(vd == NULL, BT_ITEM_NONE);
1450         retv_if(item == NULL, BT_ITEM_NONE);
1451
1452         if (item == vd->name_item) {
1453                 return BT_ITEM_NAME;
1454         } else if (item == vd->unpair_item) {
1455                 return BT_ITEM_UNPAIR;
1456 #ifndef TELEPHONY_DISABLED
1457         } else if (item == vd->call_item) {
1458                 return BT_ITEM_CALL;
1459 #endif
1460         } else if (item == vd->media_item) {
1461                 return BT_ITEM_MEDIA;
1462         } else if (item == vd->hid_item) {
1463                 return BT_ITEM_HID;
1464         } else if (item == vd->network_item) {
1465                 return BT_ITEM_NETWORK;
1466         }
1467
1468         return BT_ITEM_NONE;
1469 }
1470
1471 static void __bt_profile_gl_realized(void *data, Evas_Object *obj, void *event_info)
1472 {
1473         FN_START;
1474
1475         int item_type;
1476         bt_ug_data *ugd;
1477         bt_profile_view_data *vd;
1478         Elm_Object_Item *item = (Elm_Object_Item *)event_info;
1479 #ifdef KIRAN_ACCESSIBILITY
1480         Evas_Object *ao;
1481         char str[BT_STR_ACCES_INFO_MAX_LEN] = {0, };
1482         bt_dev_t *dev_info;
1483 #endif
1484
1485         ret_if(data == NULL);
1486         ret_if(item == NULL);
1487
1488         ugd = (bt_ug_data *)data;
1489
1490         vd = ugd->profile_vd;
1491         ret_if(vd == NULL);
1492
1493         item_type = __bt_profile_get_item_type(vd, item);
1494
1495         BT_INFO("type: %d", item_type);
1496 #ifdef KIRAN_ACCESSIBILITY
1497         dev_info = (bt_dev_t *)elm_object_item_data_get(item);
1498         ao = elm_object_item_access_object_get(item);
1499 #endif
1500         switch (item_type) {
1501         case BT_ITEM_NAME:
1502                 elm_object_item_signal_emit(item, "elm,state,top", "");
1503
1504 #ifdef KIRAN_ACCESSIBILITY
1505                 if (dev_info != NULL)
1506                         snprintf(str, sizeof(str), "%s, %s, %s", BT_STR_DEVICE_NAME,
1507                                 dev_info->name, BT_STR_DOUBLE_TAP_RENAME);
1508                 else
1509                         snprintf(str, sizeof(str), "%s, %s", BT_STR_DEVICE_NAME,
1510                                 BT_STR_DOUBLE_TAP_RENAME);
1511
1512                 elm_access_info_set(ao, ELM_ACCESS_INFO, str);
1513 #endif
1514                 break;
1515         case BT_ITEM_UNPAIR:
1516                 elm_object_item_signal_emit(item, "elm,state,bottom", "");
1517
1518 #ifdef KIRAN_ACCESSIBILITY
1519                 snprintf(str, sizeof(str), "%s, %s", BT_STR_UNPAIR,
1520                                 BT_STR_DOUBLE_TAP_UNPAIR);
1521                 elm_access_info_set(ao, ELM_ACCESS_INFO, str);
1522 #endif
1523                 break;
1524
1525 #ifndef TELEPHONY_DISABLED
1526         case BT_ITEM_CALL:
1527 #ifdef KIRAN_ACCESSIBILITY
1528                 if (dev_info->call_checked)
1529                         snprintf(str, sizeof(str), "%s, %s, %s", BT_STR_CALL_AUDIO,
1530                                 BT_STR_RADIO_BUTTON, BT_STR_RADIO_SELECTED);
1531                 else
1532                         snprintf(str, sizeof(str), "%s, %s, %s", BT_STR_CALL_AUDIO,
1533                                 BT_STR_RADIO_BUTTON, BT_STR_RADIO_UNSELECTED);
1534                 elm_access_info_set(ao, ELM_ACCESS_INFO, str);
1535 #endif
1536                 break;
1537 #endif
1538         case BT_ITEM_MEDIA:
1539 #ifdef KIRAN_ACCESSIBILITY
1540                 if (dev_info->media_checked)
1541                         snprintf(str, sizeof(str), "%s, %s, %s", BT_STR_MEDIA_AUDIO,
1542                                 BT_STR_RADIO_BUTTON, BT_STR_RADIO_SELECTED);
1543                 else
1544                         snprintf(str, sizeof(str), "%s, %s, %s", BT_STR_MEDIA_AUDIO,
1545                                 BT_STR_RADIO_BUTTON, BT_STR_RADIO_UNSELECTED);
1546                 elm_access_info_set(ao, ELM_ACCESS_INFO, str);
1547 #endif
1548                 break;
1549
1550         case BT_ITEM_HID:
1551 #ifdef KIRAN_ACCESSIBILITY
1552                 if (dev_info->hid_checked)
1553                         snprintf(str, sizeof(str), "%s, %s, %s", BT_STR_INPUT_DEVICE,
1554                                 BT_STR_RADIO_BUTTON, BT_STR_RADIO_SELECTED);
1555                 else
1556                         snprintf(str, sizeof(str), "%s, %s, %s", BT_STR_INPUT_DEVICE,
1557                                 BT_STR_RADIO_BUTTON, BT_STR_RADIO_UNSELECTED);
1558                 elm_access_info_set(ao, ELM_ACCESS_INFO, str);
1559 #endif
1560                 break;
1561
1562         case BT_ITEM_NETWORK:
1563 #ifdef KIRAN_ACCESSIBILITY
1564                 if (dev_info->network_checked)
1565                         snprintf(str, sizeof(str), "%s, %s, %s", BT_STR_INTERNET_ACCESS,
1566                                 BT_STR_RADIO_BUTTON, BT_STR_RADIO_SELECTED);
1567                 else
1568                         snprintf(str, sizeof(str), "%s, %s, %s", BT_STR_INTERNET_ACCESS,
1569                                 BT_STR_RADIO_BUTTON, BT_STR_RADIO_UNSELECTED);
1570                 elm_access_info_set(ao, ELM_ACCESS_INFO, str);
1571 #endif
1572                 break;
1573
1574         case BT_ITEM_NONE:
1575         default:
1576                 break;
1577         }
1578
1579         _bt_update_detail_item_style(vd);
1580         FN_END;
1581 }
1582
1583 /* Create genlist and append items */
1584 static Evas_Object *__bt_profile_draw_genlist(bt_ug_data *ugd, bt_dev_t *dev_info)
1585 {
1586         FN_START;
1587
1588         bt_profile_view_data *vd = NULL;
1589         Evas_Object *genlist = NULL;
1590         Elm_Object_Item *git = NULL;
1591
1592         retv_if(ugd == NULL, NULL);
1593         retv_if(ugd->profile_vd == NULL, NULL);
1594
1595         vd = ugd->profile_vd;
1596
1597         /* Set item class for dialogue normal items */
1598         vd->name_itc = elm_genlist_item_class_new();
1599         retv_if (vd->name_itc == NULL, NULL);
1600         vd->name_itc->item_style = BT_GENLIST_2LINE_BOTTOM_TEXT_STYLE;
1601         vd->name_itc->func.text_get = __bt_profile_name_label_get;
1602         vd->name_itc->func.content_get = NULL;
1603         vd->name_itc->func.state_get = NULL;
1604         vd->name_itc->func.del = NULL;
1605
1606         vd->unpair_itc = elm_genlist_item_class_new();
1607         retv_if (vd->unpair_itc == NULL, NULL);
1608
1609         vd->unpair_itc->item_style = BT_GENLIST_1LINE_TEXT_STYLE;
1610         vd->unpair_itc->func.text_get = __bt_profile_unpair_label_get;
1611         vd->unpair_itc->func.content_get = NULL;
1612         vd->unpair_itc->func.state_get = NULL;
1613         vd->unpair_itc->func.del = NULL;
1614
1615         /* Create genlist */
1616         genlist = elm_genlist_add(ugd->navi_bar);
1617         elm_genlist_mode_set(genlist, ELM_LIST_COMPRESS);
1618         elm_genlist_homogeneous_set(genlist, EINA_FALSE);
1619         elm_genlist_block_count_set(genlist, 3);
1620
1621         evas_object_smart_callback_add(genlist, "realized",
1622                                 __bt_profile_gl_realized, ugd);
1623
1624         /* device name item */
1625         git = elm_genlist_item_append(genlist, vd->name_itc, dev_info, NULL,
1626                                     ELM_GENLIST_ITEM_NONE,
1627                                     __bt_profile_name_item_sel, ugd);
1628         vd->name_item = git;
1629
1630         /* unpair item */
1631         git = elm_genlist_item_append(genlist, vd->unpair_itc, NULL, NULL,
1632                                     ELM_GENLIST_ITEM_NONE,
1633                                     __bt_profile_unpair_item_sel, dev_info);
1634         vd->unpair_item = git;
1635
1636         /* If the device has no headset profile, exit this function */
1637         if (!(dev_info->service_list & BT_SC_HFP_SERVICE_MASK) &&
1638                 !(dev_info->service_list & BT_SC_HSP_SERVICE_MASK) &&
1639                 !(dev_info->service_list & BT_SC_A2DP_SERVICE_MASK) &&
1640                 !(dev_info->service_list & BT_SC_A2DP_SOURCE_SERVICE_MASK) &&
1641                 !(dev_info->service_list & BT_SC_HID_SERVICE_MASK) &&
1642                 !(dev_info->service_list & BT_SC_NAP_SERVICE_MASK)) {
1643                 return genlist;
1644         }
1645
1646         vd->title_itc = elm_genlist_item_class_new();
1647         retv_if (vd->title_itc == NULL, NULL);
1648
1649         vd->title_itc->item_style = BT_GENLIST_GROUP_INDEX_STYLE;
1650         vd->title_itc->func.text_get = __bt_proflie_title_label_get;
1651         vd->title_itc->func.content_get = NULL;
1652         vd->title_itc->func.state_get = NULL;
1653         vd->title_itc->func.del = NULL;
1654
1655 #ifndef TELEPHONY_DISABLED
1656         vd->call_itc = elm_genlist_item_class_new();
1657         retv_if (vd->call_itc == NULL, NULL);
1658
1659         vd->call_itc->item_style = BT_GENLIST_1LINE_TEXT_ICON_STYLE;
1660         vd->call_itc->func.text_get = __bt_proflie_call_option_label_get;
1661         vd->call_itc->func.content_get = __bt_profile_call_option_icon_get;
1662         vd->call_itc->func.state_get = NULL;
1663         vd->call_itc->func.del = NULL;
1664 #endif
1665         vd->media_itc = elm_genlist_item_class_new();
1666         retv_if (vd->media_itc == NULL, NULL);
1667
1668         vd->media_itc->item_style = BT_GENLIST_1LINE_TEXT_ICON_STYLE;
1669         vd->media_itc->func.text_get = __bt_proflie_media_option_label_get;
1670         vd->media_itc->func.content_get = __bt_profile_media_option_icon_get;
1671         vd->media_itc->func.state_get = NULL;
1672         vd->media_itc->func.del = NULL;
1673
1674         vd->hid_itc = elm_genlist_item_class_new();
1675         retv_if (vd->hid_itc == NULL, NULL);
1676
1677         vd->hid_itc->item_style = BT_GENLIST_1LINE_TEXT_ICON_STYLE;
1678         vd->hid_itc->func.text_get = __bt_proflie_hid_option_label_get;
1679         vd->hid_itc->func.content_get = __bt_profile_hid_option_icon_get;
1680         vd->hid_itc->func.state_get = NULL;
1681         vd->hid_itc->func.del = NULL;
1682
1683 #ifndef TIZEN_BT_A2DP_SINK_ENABLE
1684         vd->network_itc = elm_genlist_item_class_new();
1685         retv_if (vd->network_itc == NULL, NULL);
1686
1687         vd->network_itc->item_style = BT_GENLIST_1LINE_TEXT_ICON_STYLE;
1688         vd->network_itc->func.text_get = __bt_proflie_nap_option_label_get;
1689         vd->network_itc->func.content_get = __bt_profile_nap_option_icon_get;
1690         vd->network_itc->func.state_get = NULL;
1691         vd->network_itc->func.del = NULL;
1692 #endif
1693         /* Connection options title */
1694         git = elm_genlist_item_append(genlist, vd->title_itc, NULL, NULL,
1695                                     ELM_GENLIST_ITEM_NONE,
1696                                     NULL, NULL);
1697
1698         elm_genlist_item_select_mode_set(git,
1699                                 ELM_OBJECT_SELECT_MODE_DISPLAY_ONLY);
1700
1701         vd->title_item = git;
1702
1703 #ifndef TELEPHONY_DISABLED
1704         if (dev_info->service_list & BT_SC_HFP_SERVICE_MASK ||
1705              dev_info->service_list & BT_SC_HSP_SERVICE_MASK) {
1706                 /* Call audio */
1707                 git = elm_genlist_item_append(genlist, vd->call_itc,
1708                                         dev_info, NULL,
1709                                         ELM_GENLIST_ITEM_NONE,
1710                                         __bt_profile_call_option_item_sel,
1711                                         dev_info);
1712                 vd->call_item = git;
1713         }
1714 #endif
1715 #ifdef TIZEN_BT_A2DP_SINK_ENABLE
1716         if (dev_info->service_list & BT_SC_A2DP_SOURCE_SERVICE_MASK) {
1717 #else
1718         if (dev_info->service_list & BT_SC_A2DP_SERVICE_MASK) {
1719 #endif
1720                 /* Media audio */
1721                 git = elm_genlist_item_append(genlist, vd->media_itc,
1722                                         dev_info, NULL,
1723                                         ELM_GENLIST_ITEM_NONE,
1724                                         __bt_profile_media_option_item_sel,
1725                                         dev_info);
1726
1727                 vd->media_item = git;
1728         }
1729         BT_INFO("service list: %x", dev_info->service_list);
1730         BT_INFO("is hid: %d", dev_info->service_list & BT_SC_HID_SERVICE_MASK);
1731
1732         if (dev_info->service_list & BT_SC_HID_SERVICE_MASK) {
1733 #ifdef TIZEN_HID
1734                 /* HID device */
1735                 git = elm_genlist_item_append(genlist, vd->hid_itc,
1736                                         dev_info, NULL,
1737                                         ELM_GENLIST_ITEM_NONE,
1738                                         __bt_profile_hid_option_item_sel,
1739                                         dev_info);
1740                 vd->hid_item = git;
1741 #else
1742                 /* HID device */
1743                 BT_INFO("HID options is disabled");
1744                 git = elm_genlist_item_append(genlist, vd->hid_itc,
1745                                         dev_info, NULL,
1746                                         ELM_GENLIST_ITEM_NONE,
1747                                         NULL,
1748                                         NULL);
1749                 vd->hid_item = git;
1750                 BT_INFO("HID item disabled");
1751                 elm_object_item_disabled_set (vd->hid_item, EINA_TRUE);
1752 #endif
1753         }
1754
1755 #ifndef TIZEN_BT_A2DP_SINK_ENABLE
1756         if (dev_info->service_list & BT_SC_NAP_SERVICE_MASK) {
1757                 /* NAP device */
1758                 git = elm_genlist_item_append(genlist, vd->network_itc,
1759                                         dev_info, NULL,
1760                                         ELM_GENLIST_ITEM_NONE,
1761                                         __bt_profile_nap_option_item_sel,
1762                                         dev_info);
1763                 vd->network_item = git;
1764         }
1765 #endif
1766         FN_END;
1767
1768         return genlist;
1769 }
1770
1771 void _bt_profile_destroy_profile_view(void *data)
1772 {
1773         FN_START;
1774
1775         bt_ug_data *ugd = (bt_ug_data *)data;
1776         bt_profile_view_data *vd = NULL;
1777
1778         ret_if(ugd == NULL);
1779         ret_if(ugd->profile_vd == NULL);
1780
1781         vd = ugd->profile_vd;
1782
1783         if (vd->name_itc) {
1784                 elm_genlist_item_class_free(vd->name_itc);
1785                 vd->name_itc = NULL;
1786         }
1787
1788         if (vd->unpair_itc) {
1789                 elm_genlist_item_class_free(vd->unpair_itc);
1790                 vd->unpair_itc = NULL;
1791         }
1792
1793         if (vd->title_itc) {
1794                 elm_genlist_item_class_free(vd->title_itc);
1795                 vd->title_itc = NULL;
1796         }
1797
1798 #ifndef TELEPHONY_DISABLED
1799         if (vd->call_itc) {
1800                 elm_genlist_item_class_free(vd->call_itc);
1801                 vd->call_itc = NULL;
1802         }
1803 #endif
1804
1805         if (vd->media_itc) {
1806                 elm_genlist_item_class_free(vd->media_itc);
1807                 vd->media_itc = NULL;
1808         }
1809
1810         if (vd->hid_itc) {
1811                 elm_genlist_item_class_free(vd->hid_itc);
1812                 vd->hid_itc = NULL;
1813         }
1814 #ifndef TIZEN_BT_A2DP_SINK_ENABLE
1815         if (vd->network_itc) {
1816                 elm_genlist_item_class_free(vd->network_itc);
1817                 vd->network_itc = NULL;
1818         }
1819 #endif
1820         vd->save_btn = NULL;
1821
1822         /* unregister callback functions */
1823         if (vd->imf_context) {
1824                 ecore_imf_context_input_panel_event_callback_del(vd->imf_context,
1825                                         ECORE_IMF_INPUT_PANEL_STATE_EVENT,
1826                                         __bt_profile_input_panel_state_cb);
1827                 vd->imf_context = NULL;
1828         }
1829
1830         free(vd);
1831         ugd->profile_vd = NULL;
1832
1833         FN_END;
1834 }
1835
1836 static Eina_Bool __bt_profile_back_clicked_cb(void *data, Elm_Object_Item *it)
1837 {
1838         FN_START;
1839         retv_if(!data, EINA_TRUE);
1840
1841         bt_ug_data *ugd = (bt_ug_data *)data;
1842         ugd->profile_vd = NULL;
1843
1844         if (ugd->popup != NULL){
1845                 evas_object_del(ugd->popup);
1846                 ugd->popup = NULL;
1847                 ugd->is_popup_exist = 0;
1848         }
1849
1850         FN_END;
1851         return EINA_TRUE;
1852 }
1853
1854 static void __bt_profile_back_cb(void *data, Evas_Object *obj, void *event_info)
1855 {
1856         _bt_profile_delete_view(data);
1857 }
1858
1859 /**********************************************************************
1860 *                                              Common Functions
1861 ***********************************************************************/
1862
1863 void _bt_profile_create_view(bt_dev_t *dev_info)
1864 {
1865         FN_START;
1866
1867         bt_profile_view_data *vd;
1868         bt_ug_data *ugd;
1869         Evas_Object *genlist;
1870         Elm_Object_Item *navi_it;
1871         Evas_Object *back_button = NULL;
1872         int connected;
1873
1874         ret_if(dev_info == NULL);
1875         ret_if(dev_info->ugd == NULL);
1876
1877         ugd = dev_info->ugd;
1878
1879         vd = calloc(1, sizeof(bt_profile_view_data));
1880         ret_if(vd == NULL);
1881
1882         ugd->profile_vd = vd;
1883         vd->win_main = ugd->win_main;
1884         vd->navi_bar = ugd->navi_bar;
1885
1886
1887         if (dev_info->service_list & BT_SC_HFP_SERVICE_MASK ||
1888             dev_info->service_list & BT_SC_HSP_SERVICE_MASK ||
1889             dev_info->service_list & BT_SC_A2DP_SERVICE_MASK) {
1890                 connected = _bt_util_is_profile_connected(BT_HEADSET_CONNECTED,
1891                                                      dev_info->bd_addr);
1892                 dev_info->connected_mask |= connected ? BT_HEADSET_CONNECTED : 0x00;
1893
1894                 connected =
1895                     _bt_util_is_profile_connected(BT_STEREO_HEADSET_CONNECTED,
1896                                              dev_info->bd_addr);
1897                 dev_info->connected_mask |=
1898                     connected ? BT_STEREO_HEADSET_CONNECTED : 0x00;
1899         } else if (dev_info->service_list & BT_SC_A2DP_SOURCE_SERVICE_MASK ) {
1900                 connected = _bt_util_is_profile_connected(BT_MUSIC_PLAYER_CONNECTED,
1901                                                      dev_info->bd_addr);
1902                 dev_info->connected_mask |=
1903                     connected ? BT_MUSIC_PLAYER_CONNECTED : 0x00;
1904         } else if (dev_info->service_list & BT_SC_HID_SERVICE_MASK) {
1905                 connected = _bt_util_is_profile_connected(BT_HID_CONNECTED,
1906                                                      dev_info->bd_addr);
1907                 dev_info->connected_mask |= connected ? BT_HID_CONNECTED : 0x00;
1908         } else {
1909                 connected = _bt_util_is_profile_connected(BT_NETWORK_CONNECTED,
1910                                         dev_info->bd_addr);
1911                 if (!connected)
1912                         connected = _bt_util_is_profile_connected(
1913                                                 BT_NETWORK_SERVER_CONNECTED,
1914                                                 dev_info->bd_addr);
1915                 dev_info->connected_mask |= connected ? BT_NETWORK_CONNECTED : 0x00;
1916         }
1917
1918         genlist = __bt_profile_draw_genlist(ugd, dev_info);
1919         vd->genlist = genlist;
1920
1921         /* Set ugd as genlist object data. */
1922         /* We can get this data from genlist object anytime. */
1923         evas_object_data_set(genlist, "view_data", vd);
1924
1925         back_button = elm_button_add(vd->navi_bar);
1926         elm_object_style_set(back_button, "naviframe/end_btn/default");
1927
1928         navi_it = elm_naviframe_item_push(vd->navi_bar, BT_STR_DETAILS,
1929                                         back_button, NULL, genlist, NULL);
1930
1931         vd->navi_it = navi_it;
1932
1933         evas_object_smart_callback_add(back_button, "clicked", __bt_profile_back_cb, ugd);
1934
1935         elm_naviframe_prev_btn_auto_pushed_set(vd->navi_bar, EINA_FALSE);
1936
1937         elm_naviframe_item_pop_cb_set(navi_it, __bt_profile_back_clicked_cb,
1938                                                                 ugd);
1939
1940
1941         FN_END;
1942
1943         return;
1944 }
1945
1946 void _bt_profile_delete_view(void *data)
1947 {
1948         FN_START;
1949
1950         bt_ug_data *ugd;
1951
1952         ret_if(data == NULL);
1953
1954         ugd = (bt_ug_data *)data;
1955
1956         _bt_profile_destroy_profile_view(ugd);
1957
1958         elm_naviframe_item_pop(ugd->navi_bar);
1959
1960         if (ugd->rename_popup != NULL) {
1961                 BT_INFO("Destorying rename_popup");
1962                 evas_object_del(ugd->rename_popup);
1963                 ugd->rename_popup = NULL;
1964                 ugd->rename_entry = NULL;
1965         }
1966
1967         FN_END;
1968 }
1969