src/ui/bt-profile-view.c

   1 /*
   2  * Copyright (c) 2012-2013 Samsung Electronics Co., Ltd.
   3  *
   4  * Licensed under the Flora License, Version 1.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *   http://floralicense.org/license/
   9  *
  10  * Unless required by applicable law or agreed to in writing,
  11  * software distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 #include <glib.h>
  18 #include <bluetooth.h>
  19 #include <Elementary.h>
  20
  21 #include "bt-main-ug.h"
  22 #include "bt-main-view.h"
  23 #include "bt-dbus-method.h"
  24 #include "bt-debug.h"
  25 #include "bt-widget.h"
  26 #include "bt-type-define.h"
  27 #include "bt-string-define.h"
  28 #include "bt-profile-view.h"
  29 #include "bt-ipc-handler.h"
  30 #include "bt-util.h"
  31 #include "bt-net-connection.h"
  32
  33 /**********************************************************************
  34 *                                      Static Functions declaration
  35 ***********************************************************************/
  36 static void __bt_profile_focused_cb(void *data, Evas_Object *obj,
  37                                         void *event_info);
  38
  39
  40 /**********************************************************************
  41 *                                               Static Functions
  42 ***********************************************************************/
  43
  44 static int __bt_profile_delete_button(void *data)
  45 {
  46         FN_START;
  47
  48         bt_dev_t *dev = NULL;
  49         bt_ug_data *ugd = NULL;
  50         bt_profile_view_data *vd = NULL;
  51
  52         retv_if(data == NULL, BT_UG_FAIL);
  53
  54         dev = (bt_dev_t *)data;
  55         retv_if(dev->ugd == NULL, BT_UG_FAIL);
  56
  57         ugd = dev->ugd;
  58         retv_if(ugd->profile_vd == NULL, BT_UG_FAIL);
  59
  60         vd = ugd->profile_vd;
  61
  62         /* When we try to delete the buttun, 'focused' event occurs.
  63             To remove this event, delete the callback.
  64         */
  65         evas_object_smart_callback_del(dev->entry, "focused",
  66                                 __bt_profile_focused_cb);
  67
  68         evas_object_del(vd->save_btn);
  69         evas_object_del(vd->cancel_btn);
  70
  71         vd->save_btn = NULL;
  72         vd->cancel_btn = NULL;
  73
  74         /* To shutdown the IME, set the focus to FALSE */
  75         elm_object_focus_set(dev->entry, EINA_FALSE);
  76
  77         evas_object_smart_callback_add(dev->entry, "focused",
  78                                 __bt_profile_focused_cb, dev);
  79
  80         FN_END;
  81         return BT_UG_ERROR_NONE;
  82 }
  83
  84 static void __bt_profile_save_clicked_cb(void *data, Evas_Object *obj,
  85                                   void *event_info)
  86 {
  87         FN_START;
  88
  89         bt_dev_t *dev;
  90         const char *entry_string;
  91         char *str;
  92         bt_ug_data *ugd;
  93
  94         ret_if(data == NULL);
  95
  96         dev = (bt_dev_t *)data;
  97         ret_if(dev->layout == NULL);
  98         ret_if(dev->entry == NULL);
  99
 100         elm_object_signal_emit((Evas_Object *)dev->layout,
 101                         "elm,state,eraser,hide", "elm");
 102
 103         entry_string = elm_entry_entry_get(dev->entry);
 104         ret_if(entry_string == NULL);
 105         str = elm_entry_markup_to_utf8(entry_string);
 106
 107         if (str == NULL || strlen(str) == 0) {
 108                 elm_object_focus_set(dev->entry, EINA_TRUE);
 109                 if (str)
 110                         free(str);
 111
 112                 ret_if(dev->ugd == NULL);
 113                 ugd = dev->ugd;
 114
 115                 ugd->popup =
 116                     _bt_create_popup(ugd->win_main, BT_STR_ERROR,
 117                                 BT_STR_EMPTY_NAME,
 118                                 _bt_main_popup_del_cb, ugd, 2);
 119                 ugd->back_cb = _bt_util_launch_no_event;
 120
 121                 return;
 122         }
 123
 124         g_strlcpy(dev->name, str, BT_DEVICE_NAME_LENGTH_MAX);
 125         bt_device_set_alias(dev->addr_str, str);
 126         elm_genlist_item_update((Elm_Object_Item *)dev->genlist_item);
 127
 128         free(str);
 129
 130         /* If we try to delete the button in this function,
 131             the crash will occur. */
 132         g_idle_add((GSourceFunc) __bt_profile_delete_button, dev);
 133
 134         FN_END;
 135 }
 136
 137 static void __bt_profile_eraser_clicked_cb(void *data, Evas_Object *obj,
 138                                 const char *emission, const char *source)
 139 {
 140         FN_START;
 141
 142         ret_if(NULL == data);
 143
 144         elm_entry_entry_set((Evas_Object *)data, "");
 145
 146         FN_END;
 147 }
 148
 149 static void __bt_profile_changed_cb(void *data, Evas_Object *obj,
 150                                         void *event_info)
 151 {
 152         FN_START;
 153
 154         bt_dev_t *dev = NULL;
 155         Evas_Object *layout = NULL;
 156
 157         ret_if(obj == NULL);
 158         ret_if(data == NULL);
 159
 160         dev = (bt_dev_t *)data;
 161         ret_if(dev->layout == NULL);
 162
 163         layout = (Evas_Object *)dev->layout;
 164
 165         if (elm_object_focus_get(layout)) {
 166                 if (elm_entry_is_empty(obj)) {
 167                         elm_object_signal_emit(layout,
 168                                         "elm,state,eraser,hide", "elm");
 169                 } else {
 170                         elm_object_signal_emit(layout,
 171                                         "elm,state,eraser,show", "elm");
 172                 }
 173         }
 174
 175         FN_END;
 176 }
 177
 178 static void __bt_profile_focused_cb(void *data, Evas_Object *obj,
 179                                         void *event_info)
 180 {
 181         FN_START;
 182
 183         bt_dev_t *dev = NULL;
 184         bt_ug_data *ugd = NULL;
 185         bt_profile_view_data *vd = NULL;
 186         Evas_Object *layout = NULL;
 187         Evas_Object *btn = NULL;
 188
 189         ret_if(obj == NULL);
 190         ret_if(data == NULL);
 191
 192         dev = (bt_dev_t *)data;
 193         ret_if(dev->layout == NULL);
 194
 195         layout = (Evas_Object *)dev->layout;
 196
 197         if (!elm_entry_is_empty(obj)) {
 198                 elm_object_signal_emit(layout,
 199                                 "elm,state,eraser,show", "elm");
 200         }
 201
 202         ret_if(dev->ugd == NULL);
 203         ugd = dev->ugd;
 204
 205         ret_if(ugd->profile_vd == NULL);
 206         vd = ugd->profile_vd;
 207
 208         if (vd->cancel_btn == NULL) {
 209                 btn = _bt_create_button(ugd->navi_bar,
 210                                         "naviframe/back_btn/default",
 211                                         NULL, NULL,
 212                                         __bt_profile_save_clicked_cb, dev);
 213
 214                 vd->cancel_btn = btn;
 215         }
 216
 217         elm_object_item_part_content_set(vd->navi_it,
 218                                         "title_right_btn", vd->cancel_btn);
 219
 220         FN_END;
 221 }
 222
 223 static void __bt_profile_unfocused_cb(void *data, Evas_Object *obj,
 224                                         void *event_info)
 225 {
 226         FN_START;
 227
 228         bt_dev_t *dev = NULL;
 229
 230         ret_if(data == NULL);
 231
 232         dev = (bt_dev_t *)data;
 233         ret_if(dev->layout == NULL);
 234
 235         elm_object_signal_emit((Evas_Object *)dev->layout,
 236                         "elm,state,eraser,hide", "elm");
 237
 238         FN_END;
 239 }
 240
 241 static void __bt_profile_maxlength_reached(void *data, Evas_Object *obj,
 242                                                 void *event_info)
 243 {
 244         FN_START;
 245
 246         /* In now, there is no UX guide */
 247
 248         FN_END;
 249 }
 250
 251 static Evas_Object *__bt_profile_name_icon_get(void *data, Evas_Object *obj,
 252                                           const char *part)
 253 {
 254         FN_START;
 255
 256         Elm_Entry_Filter_Limit_Size limit_filter;
 257         Evas_Object *layout = NULL;
 258         Evas_Object *entry = NULL;
 259         bt_dev_t *dev = NULL;
 260
 261         retv_if(NULL == data, NULL);
 262
 263         dev = (bt_dev_t *)data;
 264
 265         if (!strcmp(part, "elm.icon")) {
 266                 layout = elm_layout_add(obj);
 267                 dev->layout = layout;
 268                 elm_layout_theme_set(layout, "layout", "editfield", "title");
 269                 evas_object_size_hint_weight_set(layout, EVAS_HINT_EXPAND,
 270                                                 EVAS_HINT_EXPAND);
 271
 272                 entry = elm_entry_add(obj);
 273                 dev->entry = entry;
 274
 275                 limit_filter.max_byte_count = 0;
 276                 limit_filter.max_char_count = BT_DEVICE_NAME_LENGTH_MAX;
 277
 278                 elm_entry_markup_filter_append(entry, elm_entry_filter_limit_size,
 279                                              &limit_filter);
 280
 281                 elm_entry_prediction_allow_set(entry, EINA_FALSE);
 282
 283                 elm_entry_entry_set(entry, dev->name);
 284
 285                 evas_object_smart_callback_add(entry, "changed",
 286                                         __bt_profile_changed_cb, dev);
 287                 evas_object_smart_callback_add(entry, "focused",
 288                                         __bt_profile_focused_cb, dev);
 289                 evas_object_smart_callback_add(entry, "unfocused",
 290                                         __bt_profile_unfocused_cb, dev);
 291                 evas_object_smart_callback_add(entry, "maxlength,reached",
 292                                                __bt_profile_maxlength_reached,
 293                                                 dev);
 294
 295                 evas_object_show(entry);
 296
 297                 elm_object_part_content_set(layout,
 298                                 "elm.swallow.content", entry);
 299
 300                 elm_object_part_text_set(layout, "elm.text",
 301                                 (const char *)BT_STR_DEVICE_NAME);
 302
 303                 elm_object_signal_callback_add(layout, "elm,eraser,clicked",
 304                                         "elm", __bt_profile_eraser_clicked_cb,
 305                                         entry);
 306         }
 307
 308         FN_END;
 309
 310         return layout;
 311 }
 312
 313 static void __bt_profile_name_item_sel(void *data, Evas_Object *obj,
 314                                       void *event_info)
 315 {
 316         FN_START;
 317
 318         if (event_info)
 319                 elm_genlist_item_selected_set((Elm_Object_Item *)event_info,
 320                                               EINA_FALSE);
 321
 322         FN_END;
 323 }
 324
 325 static void __bt_profile_unpair_item_sel(void *data, Evas_Object *obj,
 326                                       void *event_info)
 327 {
 328         FN_START;
 329         bt_dev_t *dev = NULL;
 330
 331         if (event_info)
 332                 elm_genlist_item_selected_set((Elm_Object_Item *)event_info,
 333                                               EINA_FALSE);
 334         ret_if(NULL == data);
 335
 336         dev = (bt_dev_t *)data;
 337
 338         if (bt_device_destroy_bond(dev->addr_str) != BT_ERROR_NONE) {
 339                 BT_DBG("Fail to unpair");
 340         }
 341
 342         FN_END;
 343 }
 344
 345 static char *__bt_profile_unpair_label_get(void *data, Evas_Object *obj,
 346                                             const char *part)
 347 {
 348         FN_START;
 349
 350         char buf[BT_GLOBALIZATION_STR_LENGTH] = { 0, };
 351
 352         if (!strcmp(part, "elm.text")) {
 353                 g_strlcpy(buf, BT_STR_UNPAIR, BT_GLOBALIZATION_STR_LENGTH);
 354         } else {
 355                 BT_DBG("empty text for label. \n");
 356                 return NULL;
 357         }
 358
 359         FN_END;
 360         return strdup(buf);
 361 }
 362
 363 static char *__bt_proflie_title_label_get(void *data, Evas_Object *obj,
 364                                               const char *part)
 365 {
 366         FN_START;
 367
 368         char buf[BT_GLOBALIZATION_STR_LENGTH] = { 0, };
 369
 370         if (strcmp(part, "elm.text") == 0) {
 371                 /*Label */
 372                 g_strlcpy(buf, BT_STR_CONNECTION_OPTIONS,
 373                         BT_GLOBALIZATION_STR_LENGTH);
 374         } else {
 375                 BT_DBG("This part name is not exist in style");
 376                 return NULL;
 377         }
 378
 379         FN_END;
 380         return strdup(buf);
 381 }
 382
 383 static char *__bt_proflie_call_option_label_get(void *data, Evas_Object *obj,
 384                                               const char *part)
 385 {
 386         FN_START;
 387
 388         bt_dev_t *dev = NULL;
 389         char buf[BT_GLOBALIZATION_STR_LENGTH] = { 0, };
 390
 391         retv_if(NULL == data, NULL);
 392
 393         dev = (bt_dev_t *)data;
 394
 395         if (strcmp(part, "elm.text") == 0) {
 396                 g_strlcpy(buf, BT_STR_CALL_AUDIO,
 397                         BT_GLOBALIZATION_STR_LENGTH);
 398         } else {
 399                 BT_DBG("This part name is not exist in style");
 400                 return NULL;
 401         }
 402
 403         FN_END;
 404         return strdup(buf);
 405 }
 406
 407 static char *__bt_proflie_media_option_label_get(void *data, Evas_Object *obj,
 408                                               const char *part)
 409 {
 410         FN_START;
 411
 412         bt_dev_t *dev = NULL;
 413         char buf[BT_GLOBALIZATION_STR_LENGTH] = { 0, };
 414
 415         retv_if(NULL == data, NULL);
 416
 417         dev = (bt_dev_t *)data;
 418
 419         if (strcmp(part, "elm.text") == 0) {
 420                 g_strlcpy(buf, BT_STR_MEDIA_AUDIO,
 421                         BT_GLOBALIZATION_STR_LENGTH);
 422         } else {
 423                 BT_DBG("This part name is not exist in style");
 424                 return NULL;
 425         }
 426
 427         FN_END;
 428         return strdup(buf);
 429 }
 430
 431 static char *__bt_proflie_hid_option_label_get(void *data, Evas_Object *obj,
 432                                               const char *part)
 433 {
 434         FN_START;
 435
 436         bt_dev_t *dev = NULL;
 437         char buf[BT_GLOBALIZATION_STR_LENGTH] = { 0, };
 438
 439         retv_if(NULL == data, NULL);
 440
 441         dev = (bt_dev_t *)data;
 442
 443         if (strcmp(part, "elm.text") == 0) {
 444                 g_strlcpy(buf, BT_STR_INPUT_DEVICE,
 445                         BT_GLOBALIZATION_STR_LENGTH);
 446         } else {
 447                 BT_DBG("This part name is not exist in style");
 448                 return NULL;
 449         }
 450
 451         FN_END;
 452         return strdup(buf);
 453 }
 454
 455 static char *__bt_proflie_nap_option_label_get(void *data, Evas_Object *obj,
 456                                               const char *part)
 457 {
 458         FN_START;
 459
 460         bt_dev_t *dev = NULL;
 461         char buf[BT_GLOBALIZATION_STR_LENGTH] = { 0, };
 462
 463         retv_if(NULL == data, NULL);
 464
 465         dev = (bt_dev_t *)data;
 466
 467         if (strcmp(part, "elm.text") == 0) {
 468                 g_strlcpy(buf, BT_STR_INTERNET_ACCESS,
 469                         BT_GLOBALIZATION_STR_LENGTH);
 470         } else {
 471                 BT_DBG("This part name is not exist in style");
 472                 return NULL;
 473         }
 474
 475         FN_END;
 476         return strdup(buf);
 477 }
 478
 479 static Evas_Object *__bt_profile_call_option_icon_get(void *data, Evas_Object *obj,
 480                                           const char *part)
 481 {
 482         FN_START;
 483
 484         Evas_Object *check = NULL;
 485         bt_dev_t *dev = NULL;
 486
 487         retv_if(NULL == data, NULL);
 488
 489         dev = (bt_dev_t *)data;
 490
 491         if (!strcmp(part, "elm.icon")) {
 492                 check = elm_check_add(obj);
 493
 494                 dev->call_checked = dev->connected_mask & \
 495                                         BT_HEADSET_CONNECTED;
 496
 497                 elm_check_state_pointer_set(check,
 498                                 (Eina_Bool *)&dev->call_checked);
 499
 500                 evas_object_size_hint_weight_set(check, EVAS_HINT_EXPAND,
 501                                                 EVAS_HINT_EXPAND);
 502
 503                 evas_object_size_hint_align_set(check, EVAS_HINT_FILL,
 504                                                 EVAS_HINT_FILL);
 505         }
 506
 507         FN_END;
 508
 509         return check;
 510 }
 511
 512 static Evas_Object *__bt_profile_media_option_icon_get(void *data, Evas_Object *obj,
 513                                           const char *part)
 514 {
 515         FN_START;
 516
 517         Evas_Object *check = NULL;
 518         bt_dev_t *dev = NULL;
 519
 520         retv_if(NULL == data, NULL);
 521
 522         dev = (bt_dev_t *)data;
 523
 524         if (!strcmp(part, "elm.icon")) {
 525                 check = elm_check_add(obj);
 526
 527                 dev->media_checked = dev->connected_mask & \
 528                                         BT_STEREO_HEADSET_CONNECTED;
 529
 530                 elm_check_state_pointer_set(check,
 531                                 (Eina_Bool *)&dev->media_checked);
 532
 533                 evas_object_size_hint_weight_set(check, EVAS_HINT_EXPAND,
 534                                                 EVAS_HINT_EXPAND);
 535
 536                 evas_object_size_hint_align_set(check, EVAS_HINT_FILL,
 537                                                 EVAS_HINT_FILL);
 538         }
 539
 540         FN_END;
 541
 542         return check;
 543 }
 544
 545 static Evas_Object *__bt_profile_hid_option_icon_get(void *data, Evas_Object *obj,
 546                                           const char *part)
 547 {
 548         FN_START;
 549
 550         Evas_Object *check = NULL;
 551         bt_dev_t *dev = NULL;
 552
 553         retv_if(NULL == data, NULL);
 554
 555         dev = (bt_dev_t *)data;
 556
 557         if (!strcmp(part, "elm.icon")) {
 558                 check = elm_check_add(obj);
 559
 560                 dev->hid_checked = dev->connected_mask & \
 561                                         BT_HID_CONNECTED;
 562
 563                 elm_check_state_pointer_set(check,
 564                                 (Eina_Bool *)&dev->hid_checked);
 565
 566                 evas_object_size_hint_weight_set(check, EVAS_HINT_EXPAND,
 567                                                 EVAS_HINT_EXPAND);
 568
 569                 evas_object_size_hint_align_set(check, EVAS_HINT_FILL,
 570                                                 EVAS_HINT_FILL);
 571         }
 572
 573         FN_END;
 574
 575         return check;
 576 }
 577
 578 static Evas_Object *__bt_profile_nap_option_icon_get(void *data, Evas_Object *obj,
 579                                           const char *part)
 580 {
 581         FN_START;
 582
 583         Evas_Object *check = NULL;
 584         bt_dev_t *dev = NULL;
 585
 586         retv_if(NULL == data, NULL);
 587
 588         dev = (bt_dev_t *)data;
 589
 590         if (!strcmp(part, "elm.icon")) {
 591                 check = elm_check_add(obj);
 592
 593                 dev->network_checked = dev->connected_mask & \
 594                                         BT_NETWORK_CONNECTED;
 595
 596                 elm_check_state_pointer_set(check,
 597                                 (Eina_Bool *)&dev->network_checked);
 598
 599                 evas_object_size_hint_weight_set(check, EVAS_HINT_EXPAND,
 600                                                 EVAS_HINT_EXPAND);
 601
 602                 evas_object_size_hint_align_set(check, EVAS_HINT_FILL,
 603                                                 EVAS_HINT_FILL);
 604         }
 605
 606         FN_END;
 607
 608         return check;
 609 }
 610
 611 int __bt_profile_connect_option(bt_ug_data *ugd, bt_dev_t *dev,
 612                                 bt_device_type type)
 613 {
 614         FN_START;
 615
 616         int audio_profile;
 617         gboolean connected = FALSE;
 618
 619         retv_if(ugd == NULL, BT_UG_FAIL);
 620         retv_if(dev == NULL, BT_UG_FAIL);
 621
 622         if (dev->status != BT_IDLE) {
 623                 _bt_main_draw_selection_info(ugd, BT_STR_CONNECTION_FAILED);
 624                 return BT_UG_FAIL;
 625         }
 626
 627         if (type == BT_HEADSET_DEVICE)
 628                 connected = _bt_main_is_headset_connected(ugd);
 629         else if (type == BT_STEREO_HEADSET_DEVICE)
 630                 connected = _bt_main_is_stereo_headset_connected(ugd);
 631
 632         if (connected == TRUE) {
 633                 _bt_main_draw_selection_info(ugd, BT_STR_CONNECTION_EXISTS);
 634                 return BT_UG_FAIL;
 635         }
 636
 637         if (type == BT_HEADSET_DEVICE || type == BT_STEREO_HEADSET_DEVICE) {
 638                 if (type == BT_STEREO_HEADSET_DEVICE)
 639                         audio_profile = BT_AUDIO_PROFILE_TYPE_A2DP;
 640                 else
 641                         audio_profile = BT_AUDIO_PROFILE_TYPE_HSP_HFP;
 642
 643                 if (bt_audio_connect(dev->addr_str,
 644                                 audio_profile) != BT_ERROR_NONE) {
 645                         BT_DBG("Fail to connect Headset device");
 646                         return BT_UG_FAIL;
 647                 }
 648         } else if (type == BT_HID_DEVICE) {
 649                 BT_DBG("HID connect request\n");
 650
 651                 if (bt_hid_host_connect(dev->addr_str) != BT_ERROR_NONE) {
 652                         return BT_UG_FAIL;
 653                 }
 654         } else if (type == BT_NETWORK_DEVICE){
 655                 BT_DBG("Network connect request\n");
 656
 657                 if (_bt_connect_net_profile(ugd->connection,
 658                                         dev->net_profile,
 659                                         dev) != BT_UG_ERROR_NONE) {
 660                         BT_ERR("Fail to connect the net profile");
 661                         return BT_UG_FAIL;
 662                 }
 663         } else {
 664                 BT_DBG("Unknown type");
 665                 return BT_UG_FAIL;
 666         }
 667
 668         ugd->connect_req = TRUE;
 669         dev->status = BT_CONNECTING;
 670         elm_genlist_item_update((Elm_Object_Item *)dev->genlist_item);
 671
 672         if (ugd->profile_vd->genlist) {
 673                 _bt_util_set_list_disabled(ugd->profile_vd->genlist,
 674                                         EINA_TRUE);
 675         }
 676
 677         FN_END;
 678         return BT_UG_ERROR_NONE;
 679 }
 680
 681 int __bt_profile_disconnect_option(bt_ug_data *ugd, bt_dev_t *dev,
 682                                         bt_device_type type)
 683 {
 684         FN_START;
 685
 686         int audio_profile;
 687         bt_ug_ipc_param_t param;
 688         gboolean connected = FALSE;
 689
 690         retv_if(ugd == NULL, BT_UG_FAIL);
 691         retv_if(dev == NULL, BT_UG_FAIL);
 692
 693         if (dev->status != BT_IDLE) {
 694                 _bt_main_draw_selection_info(ugd, BT_STR_CONNECTION_FAILED);
 695                 return BT_UG_FAIL;
 696         }
 697
 698         memset(&param, 0x00, sizeof(bt_ug_ipc_param_t));
 699         memcpy(param.param2, dev->bd_addr, BT_ADDRESS_LENGTH_MAX);
 700
 701         if (type == BT_HEADSET_DEVICE) {
 702                 connected = _bt_is_profile_connected(BT_HEADSET_CONNECTED,
 703                                                 ugd->conn, dev->bd_addr);
 704         } else if (type == BT_STEREO_HEADSET_DEVICE) {
 705                 connected = _bt_is_profile_connected(BT_STEREO_HEADSET_CONNECTED,
 706                                                 ugd->conn, dev->bd_addr);
 707         } else if (type == BT_HID_DEVICE) {
 708                 connected = _bt_is_profile_connected(BT_HID_CONNECTED,
 709                                                 ugd->conn, dev->bd_addr);
 710         } else if (type == BT_NETWORK_DEVICE) {
 711                 connected = _bt_get_connected_net_profile(ugd->connection,
 712                                         dev->bd_addr) != NULL ? TRUE : FALSE;
 713         }
 714
 715         if (connected == FALSE) {
 716                 BT_DBG("Not connected");
 717                 return BT_UG_FAIL;
 718         }
 719
 720         if (type == BT_HEADSET_DEVICE || type == BT_STEREO_HEADSET_DEVICE) {
 721                 if (type == BT_STEREO_HEADSET_DEVICE)
 722                         audio_profile = BT_AUDIO_PROFILE_TYPE_A2DP;
 723                 else
 724                         audio_profile = BT_AUDIO_PROFILE_TYPE_HSP_HFP;
 725
 726                 if (bt_audio_disconnect(dev->addr_str,
 727                                 audio_profile) != BT_ERROR_NONE) {
 728                         BT_DBG("Fail to connect Headset device");
 729                         return BT_UG_FAIL;
 730                 }
 731         } else if (type == BT_HID_DEVICE) {
 732                 BT_DBG("Disconnecting HID service!!\n");
 733
 734                 if (bt_hid_host_disconnect(dev->addr_str) != BT_ERROR_NONE) {
 735                         BT_DBG("Fail to disconnect HID device");
 736                         return BT_UG_FAIL;
 737                 }
 738         } else if (type == BT_NETWORK_DEVICE) {
 739                 BT_DBG("Disconnecting network service!!\n");
 740
 741                 if (_bt_disconnect_net_profile(ugd->connection,
 742                                         dev->net_profile,
 743                                         dev) != BT_UG_ERROR_NONE) {
 744                         BT_ERR("Fail to disconnect the net profile");
 745                         return BT_UG_FAIL;
 746                 }
 747         } else {
 748                 BT_DBG("Unknown type");
 749                 return BT_UG_FAIL;
 750         }
 751
 752         ugd->connect_req = TRUE;
 753         dev->status = BT_DISCONNECTING;
 754         elm_genlist_item_update((Elm_Object_Item *)dev->genlist_item);
 755
 756         if (ugd->profile_vd->genlist) {
 757                 _bt_util_set_list_disabled(ugd->profile_vd->genlist,
 758                                         EINA_TRUE);
 759         }
 760
 761         FN_END;
 762         return BT_UG_ERROR_NONE;
 763 }
 764
 765 static void __bt_profile_call_disconnect_cb(void *data, Evas_Object *obj,
 766                                     void *event_info)
 767 {
 768         FN_START;
 769
 770         bt_dev_t *dev = NULL;
 771         bt_ug_data *ugd = NULL;
 772
 773         retm_if(data == NULL, "Invalid argument: data is NULL\n");
 774
 775         dev = (bt_dev_t *)data;
 776         retm_if(dev->ugd == NULL, "ugd is NULL\n");
 777
 778         ugd = dev->ugd;
 779
 780         if (ugd->popup) {
 781                 evas_object_del(ugd->popup);
 782                 ugd->popup = NULL;
 783         }
 784
 785         __bt_profile_disconnect_option((bt_ug_data *)dev->ugd,
 786                                 dev, BT_HEADSET_DEVICE);
 787
 788         FN_END;
 789 }
 790
 791 static void __bt_profile_call_option_item_sel(void *data, Evas_Object *obj,
 792                                       void *event_info)
 793 {
 794         FN_START;
 795
 796         int ret = BT_UG_ERROR_NONE;
 797         bt_dev_t *dev = NULL;
 798         bt_ug_data *ugd = NULL;
 799         Elm_Object_Item *item = NULL;
 800         Evas_Object *popup = NULL;
 801         Evas_Object *popup_btn = NULL;
 802         char msg[BT_DISCONNECT_TEXT_LENGTH] = { 0 };
 803
 804         ret_if(event_info == NULL);
 805
 806         item = (Elm_Object_Item *)event_info;
 807         elm_genlist_item_selected_set(item, EINA_FALSE);
 808
 809         ret_if(data == NULL);
 810
 811         dev = (bt_dev_t *)data;
 812         ret_if(dev->ugd == NULL);
 813
 814         ugd = dev->ugd;
 815
 816         if (dev->call_checked) {
 817                 /* connected case */
 818                 snprintf(msg, sizeof(msg), "%s %s<br>%s", BT_STR_END_CONNECTION,
 819                                                 dev->name,
 820                                                 BT_STR_DISCONNECT_Q);
 821
 822                 if (ugd->popup) {
 823                         evas_object_del(ugd->popup);
 824                         ugd->popup = NULL;
 825                 }
 826
 827                 popup = _bt_create_popup(ugd->win_main, BT_STR_INFORMATION,
 828                                 msg,
 829                                 _bt_main_popup_del_cb, ugd, 0);
 830
 831                 if (popup == NULL)
 832                         return;
 833
 834                 ugd->popup = popup;
 835
 836                 popup_btn = elm_button_add(popup);
 837                 elm_object_text_set(popup_btn, BT_STR_OK);
 838                 elm_object_part_content_set(popup, "button1", popup_btn);
 839                 evas_object_smart_callback_add(popup_btn, "clicked",
 840                                         __bt_profile_call_disconnect_cb, dev);
 841
 842                 popup_btn = elm_button_add(popup);
 843                 elm_object_text_set(popup_btn, BT_STR_CANCEL);
 844                 elm_object_part_content_set(popup, "button2", popup_btn);
 845                 evas_object_smart_callback_add(popup_btn, "clicked",
 846                                         _bt_main_popup_del_cb, ugd);
 847         } else {
 848                 ret = __bt_profile_connect_option((bt_ug_data *)dev->ugd,
 849                                                 dev, BT_HEADSET_DEVICE);
 850         }
 851
 852         elm_genlist_item_update(item);
 853
 854         FN_END;
 855 }
 856
 857 static void __bt_profile_media_disconnect_cb(void *data, Evas_Object *obj,
 858                                     void *event_info)
 859 {
 860         FN_START;
 861
 862         bt_dev_t *dev = NULL;
 863         bt_ug_data *ugd = NULL;
 864
 865         retm_if(data == NULL, "Invalid argument: data is NULL\n");
 866
 867         dev = (bt_dev_t *)data;
 868         retm_if(dev->ugd == NULL, "ugd is NULL\n");
 869
 870         ugd = dev->ugd;
 871
 872         if (ugd->popup) {
 873                 evas_object_del(ugd->popup);
 874                 ugd->popup = NULL;
 875         }
 876
 877         __bt_profile_disconnect_option((bt_ug_data *)dev->ugd,
 878                                 dev, BT_STEREO_HEADSET_DEVICE);
 879
 880         FN_END;
 881 }
 882
 883 static void __bt_profile_media_option_item_sel(void *data, Evas_Object *obj,
 884                                       void *event_info)
 885 {
 886         FN_START;
 887
 888         int ret = BT_UG_ERROR_NONE;
 889         bt_dev_t *dev = NULL;
 890         bt_ug_data *ugd = NULL;
 891         Elm_Object_Item *item = NULL;
 892         Evas_Object *popup = NULL;
 893         Evas_Object *popup_btn = NULL;
 894         char msg[BT_DISCONNECT_TEXT_LENGTH] = { 0 };
 895
 896         ret_if(event_info == NULL);
 897
 898         item = (Elm_Object_Item *)event_info;
 899         elm_genlist_item_selected_set(item, EINA_FALSE);
 900
 901         ret_if(data == NULL);
 902
 903         dev = (bt_dev_t *)data;
 904         ret_if(dev->ugd == NULL);
 905
 906         ugd = dev->ugd;
 907
 908         if (dev->media_checked) {
 909                 /* connected case */
 910                 snprintf(msg, sizeof(msg), "%s %s<br>%s", BT_STR_END_CONNECTION,
 911                                                 dev->name,
 912                                                 BT_STR_DISCONNECT_Q);
 913
 914                 if (ugd->popup) {
 915                         evas_object_del(ugd->popup);
 916                         ugd->popup = NULL;
 917                 }
 918
 919                 popup = _bt_create_popup(ugd->win_main, BT_STR_INFORMATION,
 920                                 msg,
 921                                 _bt_main_popup_del_cb, ugd, 0);
 922
 923                 if (popup == NULL)
 924                         return;
 925
 926                 ugd->popup = popup;
 927
 928                 popup_btn = elm_button_add(popup);
 929                 elm_object_text_set(popup_btn, BT_STR_OK);
 930                 elm_object_part_content_set(popup, "button1", popup_btn);
 931                 evas_object_smart_callback_add(popup_btn, "clicked",
 932                                         __bt_profile_media_disconnect_cb, dev);
 933
 934                 popup_btn = elm_button_add(popup);
 935                 elm_object_text_set(popup_btn, BT_STR_CANCEL);
 936                 elm_object_part_content_set(popup, "button2", popup_btn);
 937                 evas_object_smart_callback_add(popup_btn, "clicked",
 938                                         _bt_main_popup_del_cb, ugd);
 939         } else {
 940                 ret = __bt_profile_connect_option((bt_ug_data *)dev->ugd,
 941                                                 dev, BT_STEREO_HEADSET_DEVICE);
 942         }
 943
 944         elm_genlist_item_update(item);
 945
 946         FN_END;
 947 }
 948
 949 static void __bt_profile_hid_disconnect_cb(void *data, Evas_Object *obj,
 950                                     void *event_info)
 951 {
 952         FN_START;
 953
 954         bt_dev_t *dev = NULL;
 955         bt_ug_data *ugd = NULL;
 956
 957         retm_if(data == NULL, "Invalid argument: data is NULL\n");
 958
 959         dev = (bt_dev_t *)data;
 960         retm_if(dev->ugd == NULL, "ugd is NULL\n");
 961
 962         ugd = dev->ugd;
 963
 964         if (ugd->popup) {
 965                 evas_object_del(ugd->popup);
 966                 ugd->popup = NULL;
 967         }
 968
 969         __bt_profile_disconnect_option((bt_ug_data *)dev->ugd,
 970                                 dev, BT_HID_DEVICE);
 971
 972         FN_END;
 973 }
 974
 975 static void __bt_profile_network_disconnect_cb(void *data, Evas_Object *obj,
 976                                     void *event_info)
 977 {
 978         FN_START;
 979
 980         bt_dev_t *dev = NULL;
 981         bt_ug_data *ugd = NULL;
 982
 983         retm_if(data == NULL, "Invalid argument: data is NULL\n");
 984
 985         dev = (bt_dev_t *)data;
 986         retm_if(dev->ugd == NULL, "ugd is NULL\n");
 987
 988         ugd = dev->ugd;
 989
 990         if (ugd->popup) {
 991                 evas_object_del(ugd->popup);
 992                 ugd->popup = NULL;
 993         }
 994
 995         __bt_profile_disconnect_option((bt_ug_data *)dev->ugd,
 996                                 dev, BT_NETWORK_DEVICE);
 997
 998         FN_END;
 999 }
1000
1001 static void __bt_profile_hid_option_item_sel(void *data, Evas_Object *obj,
1002                                       void *event_info)
1003 {
1004         FN_START;
1005
1006         int ret = BT_UG_ERROR_NONE;
1007         bt_dev_t *dev = NULL;
1008         bt_ug_data *ugd = NULL;
1009         Elm_Object_Item *item = NULL;
1010         Evas_Object *popup = NULL;
1011         Evas_Object *popup_btn = NULL;
1012         char msg[BT_DISCONNECT_TEXT_LENGTH] = { 0 };
1013
1014         ret_if(event_info == NULL);
1015
1016         item = (Elm_Object_Item *)event_info;
1017         elm_genlist_item_selected_set(item, EINA_FALSE);
1018
1019         ret_if(data == NULL);
1020
1021         dev = (bt_dev_t *)data;
1022         ret_if(dev->ugd == NULL);
1023
1024         ugd = dev->ugd;
1025
1026         if (dev->hid_checked) {
1027                 /* connected case */
1028                 snprintf(msg, sizeof(msg), "%s %s<br>%s", BT_STR_END_CONNECTION,
1029                                                 dev->name,
1030                                                 BT_STR_DISCONNECT_Q);
1031                 if (ugd->popup) {
1032                         evas_object_del(ugd->popup);
1033                         ugd->popup = NULL;
1034                 }
1035
1036                 popup = _bt_create_popup(ugd->win_main, BT_STR_INFORMATION,
1037                                 msg,
1038                                 _bt_main_popup_del_cb, ugd, 0);
1039
1040                 if (popup == NULL)
1041                         return;
1042
1043                 ugd->popup = popup;
1044
1045                 popup_btn = elm_button_add(popup);
1046                 elm_object_text_set(popup_btn, BT_STR_OK);
1047                 elm_object_part_content_set(popup, "button1", popup_btn);
1048                 evas_object_smart_callback_add(popup_btn, "clicked",
1049                                         __bt_profile_hid_disconnect_cb, dev);
1050
1051                 popup_btn = elm_button_add(popup);
1052                 elm_object_text_set(popup_btn, BT_STR_CANCEL);
1053                 elm_object_part_content_set(popup, "button2", popup_btn);
1054                 evas_object_smart_callback_add(popup_btn, "clicked",
1055                                         _bt_main_popup_del_cb, ugd);
1056         } else {
1057                 ret = __bt_profile_connect_option((bt_ug_data *)dev->ugd,
1058                                                 dev, BT_HID_DEVICE);
1059         }
1060
1061         elm_genlist_item_update(item);
1062
1063         FN_END;
1064 }
1065
1066 static void __bt_profile_nap_option_item_sel(void *data, Evas_Object *obj,
1067                                       void *event_info)
1068 {
1069         FN_START;
1070
1071         int ret = BT_UG_ERROR_NONE;
1072         bt_dev_t *dev = NULL;
1073         bt_ug_data *ugd = NULL;
1074         Elm_Object_Item *item = NULL;
1075         Evas_Object *popup = NULL;
1076         Evas_Object *popup_btn = NULL;
1077         char msg[BT_DISCONNECT_TEXT_LENGTH] = { 0 };
1078
1079         ret_if(event_info == NULL);
1080
1081         item = (Elm_Object_Item *)event_info;
1082         elm_genlist_item_selected_set(item, EINA_FALSE);
1083
1084         ret_if(data == NULL);
1085
1086         dev = (bt_dev_t *)data;
1087         ret_if(dev->ugd == NULL);
1088
1089         ugd = dev->ugd;
1090
1091         if (dev->network_checked) {
1092                 /* connected case */
1093                 snprintf(msg, sizeof(msg), "%s %s<br>%s", BT_STR_END_CONNECTION,
1094                                                 dev->name,
1095                                                 BT_STR_DISCONNECT_Q);
1096                 if (ugd->popup) {
1097                         evas_object_del(ugd->popup);
1098                         ugd->popup = NULL;
1099                 }
1100
1101                 popup = _bt_create_popup(ugd->win_main, BT_STR_INFORMATION,
1102                                 msg,
1103                                 _bt_main_popup_del_cb, ugd, 0);
1104
1105                 if (popup == NULL)
1106                         return;
1107
1108                 ugd->popup = popup;
1109
1110                 popup_btn = elm_button_add(popup);
1111                 elm_object_text_set(popup_btn, BT_STR_OK);
1112                 elm_object_part_content_set(popup, "button1", popup_btn);
1113                 evas_object_smart_callback_add(popup_btn, "clicked",
1114                                         __bt_profile_network_disconnect_cb, dev);
1115
1116                 popup_btn = elm_button_add(popup);
1117                 elm_object_text_set(popup_btn, BT_STR_CANCEL);
1118                 elm_object_part_content_set(popup, "button2", popup_btn);
1119                 evas_object_smart_callback_add(popup_btn, "clicked",
1120                                         _bt_main_popup_del_cb, ugd);
1121         } else {
1122                 ret = __bt_profile_connect_option((bt_ug_data *)dev->ugd,
1123                                                 dev, BT_NETWORK_DEVICE);
1124         }
1125
1126         elm_genlist_item_update(item);
1127
1128         FN_END;
1129 }
1130
1131 static int __bt_profile_get_item_type(bt_profile_view_data *vd, Elm_Object_Item *item)
1132 {
1133         int i = 0;
1134         int type = BT_ITEM_NO_TYPE;
1135         Elm_Object_Item *current = NULL;
1136         Elm_Object_Item *next = NULL;
1137
1138         retv_if(vd == NULL, BT_ITEM_NO_TYPE);
1139         retv_if(item == NULL, BT_ITEM_NO_TYPE);
1140
1141         if (item == vd->name_item) {
1142                 return BT_ITEM_TOP;
1143         } else if (item == vd->unpair_item) {
1144                 return BT_ITEM_BOTTOM;
1145         }
1146
1147         current = elm_genlist_item_next_get(vd->title_item);
1148
1149         while (current != NULL) {
1150                 next = elm_genlist_item_next_get(current);
1151
1152                 if (current == item) {
1153                         if (next == NULL) {
1154                                 type = (i == 0) ? BT_ITEM_NO_TYPE : BT_ITEM_BOTTOM;
1155                         } else {
1156                                 type = (i == 0) ? BT_ITEM_TOP : BT_ITEM_CENTER;
1157                         }
1158                         return type;
1159                 }
1160
1161                 current = next;
1162                 i++;
1163         }
1164
1165         return BT_ITEM_NO_TYPE;
1166 }
1167
1168 static void __bt_profile_gl_realized(void *data, Evas_Object *obj, void *event_info)
1169 {
1170         FN_START;
1171
1172         int item_type;
1173         bt_ug_data *ugd;
1174         bt_profile_view_data *vd;
1175         Elm_Object_Item *item = (Elm_Object_Item *)event_info;
1176
1177         ret_if(data == NULL);
1178         ret_if(item == NULL);
1179
1180         ugd = (bt_ug_data *)data;
1181
1182         vd = ugd->profile_vd;
1183         ret_if(vd == NULL);
1184
1185         item_type = __bt_profile_get_item_type(vd, item);
1186
1187         BT_DBG("type: %d", item_type);
1188
1189         switch (item_type) {
1190         case BT_ITEM_TOP:
1191                 elm_object_item_signal_emit(item, "elm,state,top", "");
1192                 break;
1193         case BT_ITEM_CENTER:
1194                 elm_object_item_signal_emit(item, "elm,state,center", "");
1195                 break;
1196         case BT_ITEM_BOTTOM:
1197                 elm_object_item_signal_emit(item, "elm,state,bottom", "");
1198                 break;
1199         default:
1200                 elm_object_item_signal_emit(item, "elm,state,default", "");
1201                 break;
1202         }
1203
1204         FN_END;
1205 }
1206
1207
1208 /* Create genlist and append items */
1209 static Evas_Object *__bt_profile_draw_genlist(bt_ug_data *ugd, bt_dev_t *dev_info)
1210 {
1211         FN_START;
1212
1213         bt_profile_view_data *vd = NULL;
1214         Evas_Object *genlist = NULL;
1215         Elm_Object_Item *git = NULL;
1216
1217         retv_if(ugd == NULL, NULL);
1218         retv_if(ugd->profile_vd == NULL, NULL);
1219
1220         vd = ugd->profile_vd;
1221
1222         /* Set item class for dialogue normal items */
1223         vd->name_itc = elm_genlist_item_class_new();
1224         retv_if (vd->name_itc == NULL, NULL);
1225
1226         vd->name_itc->item_style = "dialogue/1icon";
1227         vd->name_itc->func.text_get = NULL;
1228         vd->name_itc->func.content_get = __bt_profile_name_icon_get;
1229         vd->name_itc->func.state_get = NULL;
1230         vd->name_itc->func.del = NULL;
1231
1232         vd->unpair_itc = elm_genlist_item_class_new();
1233         retv_if (vd->unpair_itc == NULL, NULL);
1234
1235         vd->unpair_itc->item_style = "dialogue/1text";
1236         vd->unpair_itc->func.text_get = __bt_profile_unpair_label_get;
1237         vd->unpair_itc->func.content_get = NULL;
1238         vd->unpair_itc->func.state_get = NULL;
1239         vd->unpair_itc->func.del = NULL;
1240
1241         /* Create genlist */
1242         genlist = elm_genlist_add(ugd->navi_bar);
1243
1244         evas_object_smart_callback_add(genlist, "realized",
1245                                 __bt_profile_gl_realized, ugd);
1246
1247         /* Seperator */
1248         git = elm_genlist_item_append(genlist, ugd->sp_itc, NULL, NULL,
1249                                     ELM_GENLIST_ITEM_NONE, NULL, NULL);
1250
1251         elm_genlist_item_select_mode_set(git, ELM_OBJECT_SELECT_MODE_DISPLAY_ONLY);
1252
1253         /* device name item */
1254         git = elm_genlist_item_append(genlist, vd->name_itc, dev_info, NULL,
1255                                     ELM_GENLIST_ITEM_NONE,
1256                                     __bt_profile_name_item_sel, ugd);
1257         vd->name_item = git;
1258
1259         /* unpair item */
1260         git = elm_genlist_item_append(genlist, vd->unpair_itc, NULL, NULL,
1261                                     ELM_GENLIST_ITEM_NONE,
1262                                     __bt_profile_unpair_item_sel, dev_info);
1263
1264         vd->unpair_item = git;
1265
1266         /* If the device has no headset profile, exit this function */
1267         if (!(dev_info->service_list & BT_SC_HFP_SERVICE_MASK) &&
1268              !(dev_info->service_list & BT_SC_HSP_SERVICE_MASK) &&
1269               !(dev_info->service_list & BT_SC_A2DP_SERVICE_MASK) &&
1270                !(dev_info->service_list & BT_SC_HID_SERVICE_MASK) &&
1271                 !(dev_info->service_list & BT_SC_NAP_SERVICE_MASK)) {
1272                 return genlist;
1273         }
1274
1275         vd->title_itc = elm_genlist_item_class_new();
1276         retv_if (vd->title_itc == NULL, NULL);
1277
1278         vd->title_itc->item_style = "dialogue/title";
1279         vd->title_itc->func.text_get = __bt_proflie_title_label_get;
1280         vd->title_itc->func.content_get = NULL;
1281         vd->title_itc->func.state_get = NULL;
1282         vd->title_itc->func.del = NULL;
1283
1284         vd->call_itc = elm_genlist_item_class_new();
1285         retv_if (vd->call_itc == NULL, NULL);
1286
1287         vd->call_itc->item_style = "dialogue/1text.1icon.2";
1288         vd->call_itc->func.text_get = __bt_proflie_call_option_label_get;
1289         vd->call_itc->func.content_get = __bt_profile_call_option_icon_get;
1290         vd->call_itc->func.state_get = NULL;
1291         vd->call_itc->func.del = NULL;
1292
1293         vd->media_itc = elm_genlist_item_class_new();
1294         retv_if (vd->media_itc == NULL, NULL);
1295
1296         vd->media_itc->item_style = "dialogue/1text.1icon.2";
1297         vd->media_itc->func.text_get = __bt_proflie_media_option_label_get;
1298         vd->media_itc->func.content_get = __bt_profile_media_option_icon_get;
1299         vd->media_itc->func.state_get = NULL;
1300         vd->media_itc->func.del = NULL;
1301
1302         vd->hid_itc = elm_genlist_item_class_new();
1303         retv_if (vd->hid_itc == NULL, NULL);
1304
1305         vd->hid_itc->item_style = "dialogue/1text.1icon.2";
1306         vd->hid_itc->func.text_get = __bt_proflie_hid_option_label_get;
1307         vd->hid_itc->func.content_get = __bt_profile_hid_option_icon_get;
1308         vd->hid_itc->func.state_get = NULL;
1309         vd->hid_itc->func.del = NULL;
1310
1311         vd->network_itc = elm_genlist_item_class_new();
1312         retv_if (vd->network_itc == NULL, NULL);
1313
1314         vd->network_itc->item_style = "dialogue/1text.1icon.2";
1315         vd->network_itc->func.text_get = __bt_proflie_nap_option_label_get;
1316         vd->network_itc->func.content_get = __bt_profile_nap_option_icon_get;
1317         vd->network_itc->func.state_get = NULL;
1318         vd->network_itc->func.del = NULL;
1319
1320         /* Connection options title */
1321         git = elm_genlist_item_append(genlist, vd->title_itc, NULL, NULL,
1322                                     ELM_GENLIST_ITEM_NONE,
1323                                     NULL, NULL);
1324
1325         elm_genlist_item_select_mode_set(git,
1326                                 ELM_OBJECT_SELECT_MODE_DISPLAY_ONLY);
1327
1328         vd->title_item = git;
1329
1330         if (dev_info->service_list & BT_SC_HFP_SERVICE_MASK ||
1331              dev_info->service_list & BT_SC_HSP_SERVICE_MASK) {
1332                 /* Call audio */
1333                 elm_genlist_item_append(genlist, vd->call_itc,
1334                                         dev_info, NULL,
1335                                         ELM_GENLIST_ITEM_NONE,
1336                                         __bt_profile_call_option_item_sel,
1337                                         dev_info);
1338         }
1339
1340         if (dev_info->service_list & BT_SC_A2DP_SERVICE_MASK) {
1341                 /* Media audio */
1342                 elm_genlist_item_append(genlist, vd->media_itc,
1343                                         dev_info, NULL,
1344                                         ELM_GENLIST_ITEM_NONE,
1345                                         __bt_profile_media_option_item_sel,
1346                                         dev_info);
1347         }
1348
1349         BT_DBG("service list: %x", dev_info->service_list);
1350         BT_DBG("is hid: %d", dev_info->service_list & BT_SC_HID_SERVICE_MASK);
1351
1352         if (dev_info->service_list & BT_SC_HID_SERVICE_MASK) {
1353                 /* HID device */
1354                 elm_genlist_item_append(genlist, vd->hid_itc,
1355                                         dev_info, NULL,
1356                                         ELM_GENLIST_ITEM_NONE,
1357                                         __bt_profile_hid_option_item_sel,
1358                                         dev_info);
1359         }
1360
1361         if (dev_info->service_list & BT_SC_NAP_SERVICE_MASK) {
1362                 /* NAP device */
1363                 elm_genlist_item_append(genlist, vd->network_itc,
1364                                         dev_info, NULL,
1365                                         ELM_GENLIST_ITEM_NONE,
1366                                         __bt_profile_nap_option_item_sel,
1367                                         dev_info);
1368         }
1369
1370         FN_END;
1371
1372         return genlist;
1373 }
1374
1375 static void __bt_profile_back_cb(void *data, Evas_Object *obj,
1376                                   void *event_info)
1377 {
1378         FN_START;
1379
1380         bt_dev_t *dev_info = NULL;
1381         bt_ug_data *ugd = NULL;
1382         bt_profile_view_data *vd = NULL;
1383
1384         ret_if(data == NULL);
1385
1386         dev_info = (bt_dev_t *)data;
1387         ret_if(dev_info == NULL);
1388         ret_if(dev_info->ugd == NULL);
1389
1390         ugd = dev_info->ugd;
1391         ret_if(ugd->profile_vd == NULL);
1392
1393         vd = ugd->profile_vd;
1394
1395         if (vd->genlist) {
1396                 evas_object_data_set(vd->genlist, "view_data", NULL);
1397                 elm_genlist_clear(vd->genlist);
1398                 vd->genlist = NULL;
1399         }
1400
1401         if (vd->name_itc) {
1402                 elm_genlist_item_class_free(vd->name_itc);
1403                 vd->name_itc = NULL;
1404         }
1405
1406         if (vd->unpair_itc) {
1407                 elm_genlist_item_class_free(vd->unpair_itc);
1408                 vd->unpair_itc = NULL;
1409         }
1410
1411         if (vd->title_itc) {
1412                 elm_genlist_item_class_free(vd->title_itc);
1413                 vd->title_itc = NULL;
1414         }
1415
1416         if (vd->call_itc) {
1417                 elm_genlist_item_class_free(vd->call_itc);
1418                 vd->call_itc = NULL;
1419         }
1420
1421         if (vd->media_itc) {
1422                 elm_genlist_item_class_free(vd->media_itc);
1423                 vd->media_itc = NULL;
1424         }
1425
1426         if (vd->hid_itc) {
1427                 elm_genlist_item_class_free(vd->hid_itc);
1428                 vd->hid_itc = NULL;
1429         }
1430
1431         vd->save_btn = NULL;
1432         vd->cancel_btn = NULL;
1433
1434         free(vd);
1435         ugd->profile_vd = NULL;
1436
1437         elm_naviframe_item_pop(ugd->navi_bar);
1438
1439         FN_END;
1440 }
1441
1442
1443 /**********************************************************************
1444 *                                              Common Functions
1445 ***********************************************************************/
1446
1447 void _bt_profile_create_view(bt_dev_t *dev_info)
1448 {
1449         FN_START;
1450
1451         bt_profile_view_data *vd = NULL;
1452         bt_ug_data *ugd = NULL;
1453         Evas_Object *layout = NULL;
1454         Evas_Object *genlist = NULL;
1455         Elm_Object_Item *navi_it;
1456         Evas_Object *back_btn = NULL;
1457
1458         ret_if(dev_info == NULL);
1459         ret_if(dev_info->ugd == NULL);
1460
1461         ugd = dev_info->ugd;
1462         dev_info->layout = NULL;
1463
1464         vd = calloc(1, sizeof(bt_profile_view_data));
1465         ret_if(vd == NULL);
1466
1467         ugd->profile_vd = vd;
1468         vd->win_main = ugd->win_main;
1469         vd->navi_bar = ugd->navi_bar;
1470
1471         _bt_create_bg(ugd->navi_bar, "group_list");
1472
1473         layout = _bt_create_layout(ugd->navi_bar, NULL, NULL);
1474         vd->layout = layout;
1475
1476         genlist = __bt_profile_draw_genlist(ugd, dev_info);
1477         vd->genlist = genlist;
1478
1479         /* Set ugd as genlist object data. */
1480         /* We can get this data from genlist object anytime. */
1481         evas_object_data_set(genlist, "view_data", vd);
1482
1483         /* create back button */
1484         back_btn = elm_button_add(layout);
1485
1486         navi_it = elm_naviframe_item_push(ugd->navi_bar, BT_STR_DETAILS,
1487                                         back_btn, NULL, genlist, NULL);
1488
1489         /* Style set should be called after elm_naviframe_item_push(). */
1490         elm_object_style_set(back_btn, "naviframe/back_btn/default");
1491         evas_object_smart_callback_add(back_btn, "clicked",
1492                                        __bt_profile_back_cb, (void *)dev_info);
1493
1494         vd->navi_it = navi_it;
1495
1496         FN_END;
1497
1498         return;
1499 }
1500
1501 void _bt_profile_delete_view(void *data)
1502 {
1503         FN_START;
1504
1505         __bt_profile_back_cb(data, NULL, NULL);
1506
1507         FN_END;
1508 }
1509