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