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