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