ug-wifidirect/src/wfd_ug_view.c

   1 /*
   2  * Copyright 2012  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://www.tizenopensource.org/license
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * 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 /*
  18  * This file implements view of Wi-Fi direct UI Gadget.
  19  *
  20  * @file    wfd_ug_view.c
  21  * @author  Gibyoung Kim (lastkgb.kim@samsung.com)
  22  * @version 0.1
  23  */
  24
  25
  26 #include <libintl.h>
  27
  28 #include <assert.h>
  29 #include <glib.h>
  30
  31 #include <Elementary.h>
  32 #include <vconf.h>
  33 #include <ui-gadget-module.h>
  34 #include <wifi-direct.h>
  35
  36 #include "wfd_ug.h"
  37 #include "wfd_ug_view.h"
  38 #include "wfd_client.h"
  39
  40
  41 Elm_Gen_Item_Class sep_itc;
  42 Elm_Gen_Item_Class head_itc;
  43 Elm_Gen_Item_Class name_itc;
  44 Elm_Gen_Item_Class title_itc;
  45 Elm_Gen_Item_Class peer_itc;
  46 Elm_Gen_Item_Class noitem_itc;
  47 Elm_Gen_Item_Class help_itc;
  48
  49
  50 void _back_btn_cb(void *data, Evas_Object * obj, void *event_info)
  51 {
  52     __FUNC_ENTER__;
  53     struct ug_data *ugd = (struct ug_data*) data;
  54
  55     if (!ugd)
  56     {
  57         DBG(LOG_ERROR, "The param is NULL\n");
  58         return;
  59     }
  60
  61     wfd_ug_view_free_peers(ugd);
  62
  63     ug_destroy_me(ugd->ug);
  64
  65     __FUNC_EXIT__;
  66     return;
  67 }
  68
  69 void _scan_btn_cb(void *data, Evas_Object * obj, void *event_info)
  70 {
  71     __FUNC_ENTER__;
  72     struct ug_data *ugd = (struct ug_data*) data;
  73     int res;
  74
  75     res = wfd_client_start_discovery(ugd);
  76
  77     __FUNC_EXIT__;
  78     return;
  79 }
  80
  81 Eina_Bool _is_wifi_on()
  82 {
  83     __FUNC_ENTER__;
  84     int wifi_state;
  85
  86     vconf_get_int(VCONFKEY_WIFI_STATE, &wifi_state);
  87
  88     if (wifi_state >= VCONFKEY_WIFI_CONNECTED)
  89     {
  90         return TRUE;
  91     }
  92     else
  93     {
  94         return FALSE;
  95     }
  96     __FUNC_EXIT__;
  97 }
  98
  99 static void _wfd_onoff_btn_cb(void *data, Evas_Object *obj, void *event_info)
 100 {
 101     __FUNC_ENTER__;
 102     struct ug_data *ugd = (struct ug_data*) data;
 103
 104     ugd->wfd_status = wfd_client_get_link_status();
 105     DBG(LOG_VERBOSE, "WFD state is [%d]", ugd->wfd_status);
 106
 107     if (!ugd->wfd_onoff)
 108     {
 109         if(ugd->wfd_status < 0)
 110         {
 111             DBG(LOG_VERBOSE, "bad wfd status\n");
 112             wfd_ug_warn_popup(ugd, _("IDS_WFD_POP_ACTIVATE_FAIL"), POPUP_TYPE_TERMINATE);
 113
 114             ugd->head_text_mode = HEAD_TEXT_TYPE_DIRECT;
 115             wfd_ug_view_refresh_glitem(ugd->head);
 116             return;
 117         }
 118
 119         ugd->head_text_mode = HEAD_TEXT_TYPE_ACTIVATING;
 120         wfd_client_switch_on(ugd);
 121     }
 122     else
 123     {
 124         if(ugd->wfd_status < 0)
 125         {
 126             DBG(LOG_VERBOSE, "bad wfd status\n");
 127             wfd_ug_warn_popup(ugd, _("IDS_WFD_POP_DEACTIVATE_FAIL"), POPUP_TYPE_TERMINATE);
 128
 129             ugd->head_text_mode = HEAD_TEXT_TYPE_DIRECT;
 130             wfd_ug_view_refresh_glitem(ugd->head);
 131             return;
 132         }
 133
 134         ugd->head_text_mode = HEAD_TEXT_TYPE_DEACTIVATING;
 135         wfd_client_switch_off(ugd);
 136     }
 137     wfd_ug_view_refresh_glitem(ugd->head);
 138
 139     __FUNC_EXIT__;
 140 }
 141
 142 static void _gl_header_sel(void *data, Evas_Object *obj, void *event_info)
 143 {
 144     __FUNC_ENTER__;
 145     struct ug_data *ugd = (struct ug_data*) data;
 146     Elm_Object_Item *item = (Elm_Object_Item *)event_info;
 147     int res;
 148
 149     if(data == NULL)
 150     {
 151         DBG(LOG_ERROR, "Incorrect parameter(NULL)\n");
 152         return;
 153     }
 154
 155     if(item != NULL)
 156         elm_genlist_item_selected_set(item, EINA_FALSE);
 157
 158     _wfd_onoff_btn_cb(ugd, NULL, NULL);
 159
 160     __FUNC_EXIT__;
 161 }
 162
 163 static char *_gl_header_label_get(void *data, Evas_Object * obj,
 164                                   const char *part)
 165 {
 166     __FUNC_ENTER__;
 167     struct ug_data *ugd = (struct ug_data *) data;
 168     DBG(LOG_VERBOSE, "%s", part);
 169
 170     if (data == NULL)
 171     {
 172         DBG(LOG_ERROR, "Incorrect parameter(NULL)\n");
 173         return NULL;
 174     }
 175
 176     if (!strcmp(part, "elm.text"))
 177     {
 178         DBG(LOG_VERBOSE, "Current text mode [%d]\n", ugd->head_text_mode);
 179         switch (ugd->head_text_mode)
 180         {
 181         case HEAD_TEXT_TYPE_DIRECT:
 182             return strdup(dgettext("sys_string", "IDS_COM_OPT1_WI_FI_DIRECT"));
 183             break;
 184         case HEAD_TEXT_TYPE_DEACTIVATING:
 185             return strdup(_("IDS_WFD_BODY_DEACTIVATING"));
 186             break;
 187         case HEAD_TEXT_TYPE_ACTIVATING:
 188             return strdup(_("IDS_WFD_BODY_ACTIVATING"));
 189             break;
 190         case HEAD_TEXT_TYPE_ACTIVATED:
 191             return strdup(_("IDS_WFD_BODY_ACTIVATED"));
 192             break;
 193         case HEAD_TEXT_TYPE_SCANING:
 194             return strdup(_("IDS_WFD_BODY_SCANNING"));
 195             break;
 196         default:
 197             break;
 198         }
 199     }
 200
 201     __FUNC_EXIT__;
 202     return NULL;
 203 }
 204
 205 static Evas_Object *_gl_header_icon_get(void *data, Evas_Object * obj,
 206                                         const char *part)
 207 {
 208     __FUNC_ENTER__;
 209     struct ug_data *ugd = (struct ug_data *) data;
 210     Evas_Object *onoff = NULL;
 211
 212     if (data == NULL)
 213     {
 214         DBG(LOG_ERROR, "Incorrect parameter(NULL)\n");
 215         return NULL;
 216     }
 217
 218     if (ugd->head_text_mode == HEAD_TEXT_TYPE_ACTIVATING ||
 219         ugd->head_text_mode == HEAD_TEXT_TYPE_DEACTIVATING)
 220         return NULL;
 221
 222     DBG(LOG_VERBOSE, "%s", part);
 223     onoff = elm_check_add(obj);
 224     elm_object_style_set(onoff, "on&off");
 225     elm_check_state_set(onoff, ugd->wfd_onoff);
 226     evas_object_smart_callback_add(onoff, "changed", _wfd_onoff_btn_cb, ugd);
 227     evas_object_show(onoff);
 228
 229     __FUNC_EXIT__;
 230
 231     return onoff;
 232 }
 233
 234 static char *_gl_name_label_get(void *data, Evas_Object * obj, const char *part)
 235 {
 236     __FUNC_ENTER__;
 237     struct ug_data *ugd = (struct ug_data *) data;
 238
 239     if (data == NULL)
 240     {
 241         DBG(LOG_ERROR, "Incorrect parameter(NULL)\n");
 242         return NULL;
 243     }
 244
 245     DBG(LOG_VERBOSE, "%s", part);
 246
 247     if (!strcmp(part, "elm.text.1"))
 248     {
 249         return strdup(_("IDS_WFD_BODY_DEVICE_NAME"));
 250     }
 251     else if (!strcmp(part, "elm.text.2"))
 252     {
 253         return strdup(ugd->dev_name);
 254     }
 255
 256     __FUNC_EXIT__;
 257
 258     return NULL;
 259 }
 260
 261 static char *_gl_title_label_get(void *data, Evas_Object * obj,
 262                                  const char *part)
 263 {
 264     __FUNC_ENTER__;
 265     struct ug_data *ugd = (struct ug_data *) data;
 266
 267     if (data == NULL)
 268     {
 269         DBG(LOG_ERROR, "Incorrect parameter(NULL)\n");
 270         return NULL;
 271     }
 272
 273     if (!strcmp(part, "elm.text"))
 274     {
 275         if (ugd->peer_cnt)
 276             return strdup(_("IDS_WFD_BODY_AVAILABLE_DEVICES"));
 277         else
 278             return strdup(_("IDS_WFD_BODY_WIFI_DIRECT_DEVICES"));
 279     }
 280
 281     __FUNC_EXIT__;
 282
 283     return NULL;
 284 }
 285
 286 static Evas_Object *_gl_noitem_icon_get(void *data, Evas_Object * obj,
 287                                         const char *part)
 288 {
 289     __FUNC_ENTER__;
 290     Evas_Object *nocontent;
 291
 292     if (data == NULL)
 293     {
 294         DBG(LOG_ERROR, "Incorrect parameter(NULL)\n");
 295         return NULL;
 296     }
 297
 298     nocontent = elm_layout_add(obj);
 299     if (nocontent == NULL)
 300     {
 301         DBG(LOG_ERROR, "Failed to add nocontent");
 302         return NULL;
 303     }
 304     elm_layout_theme_set(nocontent, "layout", "nocontents", "unnamed");
 305     elm_object_part_text_set(nocontent, "elm.text",
 306                              _("IDS_WFD_BODY_NO_DEVICES"));
 307     evas_object_size_hint_min_set(nocontent, 400, 200);
 308     evas_object_size_hint_max_set(nocontent, 400, 200);
 309     evas_object_resize(nocontent, 400, 200);
 310
 311     __FUNC_EXIT__;
 312
 313     return nocontent;
 314 }
 315
 316 static void _gl_noitem_del(void *data, Evas_Object * obj)
 317 {
 318     __FUNC_ENTER__;
 319
 320     __FUNC_EXIT__;
 321     return;
 322 }
 323
 324 static char *_gl_peer_label_get(void *data, Evas_Object * obj, const char *part)
 325 {
 326     __FUNC_ENTER__;
 327     assertm_if(NULL == obj, "NULL!!");
 328     assertm_if(NULL == part, "NULL!!");
 329
 330     device_type_s *peer = (device_type_s *) data;
 331
 332     if (data == NULL)
 333     {
 334         DBG(LOG_ERROR, "Incorrect parameter(NULL)\n");
 335         return NULL;
 336     }
 337
 338     __FUNC_EXIT__;
 339     return strdup(peer->ssid);
 340 }
 341
 342 static Evas_Object *_gl_peer_icon_get(void *data, Evas_Object * obj,
 343                                       const char *part)
 344 {
 345     __FUNC_ENTER__;
 346     assertm_if(NULL == obj, "NULL!!");
 347     assertm_if(NULL == part, "NULL!!");
 348
 349     device_type_s *peer = (device_type_s *) data;
 350     Evas_Object *icon = NULL;
 351
 352     if (data == NULL)
 353     {
 354         DBG(LOG_ERROR, "Incorrect parameter(NULL)\n");
 355         return NULL;
 356     }
 357
 358     if (!strcmp(part, "elm.icon.2"))
 359     {
 360         DBG(LOG_VERBOSE, "elm.icon.2 - connection status [%d]\n",
 361             peer->conn_status);
 362         if (peer->conn_status == PEER_CONN_STATUS_CONNECTING)
 363         {
 364             icon = elm_progressbar_add(obj);
 365             elm_object_style_set(icon, "list_process");
 366             elm_progressbar_pulse(icon, EINA_TRUE);
 367         }
 368         else if (peer->conn_status == PEER_CONN_STATUS_CONNECTED)
 369         {
 370             icon = elm_icon_add(obj);
 371             elm_icon_file_set(icon, WFD_ICON_CONNECTED, NULL);
 372         }
 373
 374         evas_object_size_hint_aspect_set(icon, EVAS_ASPECT_CONTROL_VERTICAL, 1, 1);
 375         elm_icon_resizable_set(icon, 1, 1);
 376         evas_object_show(icon);
 377     }
 378     else if (!strcmp(part, "elm.icon.1"))
 379     {
 380         DBG(LOG_VERBOSE, "elm.icon.1 - category [%d]\n", peer->category);
 381         char *img_path = NULL;
 382         switch (peer->category)
 383         {
 384         case WFD_DEVICE_TYPE_COMPUTER:
 385             img_path = WFD_ICON_DEVICE_PC;
 386             break;
 387         case WFD_DEVICE_TYPE_INPUT_DEVICE:
 388             img_path = WFD_ICON_DEVICE_KEYBOARD;
 389             break;
 390         case WFD_DEVICE_TYPE_PRINTER:
 391             img_path = WFD_ICON_DEVICE_PRINTER;
 392             break;
 393         case WFD_DEVICE_TYPE_CAMERA:
 394             img_path = WFD_ICON_DEVICE_UNKNOWN;
 395             break;
 396         case WFD_DEVICE_TYPE_STORAGE:
 397         case WFD_DEVICE_TYPE_NW_INFRA:
 398         case WFD_DEVICE_TYPE_DISPLAYS:
 399         case WFD_DEVICE_TYPE_MM_DEVICES:
 400         case WFD_DEVICE_TYPE_GAME_DEVICES:
 401         case WFD_DEVICE_TYPE_OTHER:
 402             img_path = WFD_ICON_DEVICE_UNKNOWN;
 403             break;
 404         case WFD_DEVICE_TYPE_TELEPHONE:
 405             img_path = WFD_ICON_DEVICE_PHONE;
 406             break;
 407         case WFD_DEVICE_TYPE_AUDIO:
 408             img_path = WFD_ICON_DEVICE_HEADSET;
 409             break;
 410         default:
 411             break;
 412         }
 413
 414         if (img_path != NULL)
 415         {
 416             icon = elm_icon_add(obj);
 417             elm_icon_file_set(icon, img_path, NULL);
 418             evas_object_size_hint_aspect_set(icon, EVAS_ASPECT_CONTROL_VERTICAL,
 419                                              1, 1);
 420             elm_icon_resizable_set(icon, 1, 1);
 421             evas_object_show(icon);
 422         }
 423     }
 424
 425     __FUNC_EXIT__;
 426     return icon;
 427 }
 428
 429 static void _gl_peer_del(void *data, Evas_Object * obj)
 430 {
 431     __FUNC_ENTER__;
 432     assertm_if(NULL == obj, "NULL!!");
 433     assertm_if(NULL == data, "NULL!!");
 434
 435     __FUNC_EXIT__;
 436     return;
 437 }
 438
 439 static void _gl_peer_sel(void *data, Evas_Object * obj, void *event_info)
 440 {
 441     __FUNC_ENTER__;
 442     assertm_if(NULL == obj, "NULL!!");
 443     assertm_if(NULL == data, "NULL!!");
 444     device_type_s *peer = (device_type_s *) data;
 445     Elm_Object_Item *item = (Elm_Object_Item *) event_info;
 446     int res;
 447
 448     if (data == NULL)
 449     {
 450         DBG(LOG_ERROR, "Incorrect parameter(NULL)\n");
 451         return;
 452     }
 453
 454     if (item != NULL)
 455         elm_genlist_item_selected_set(item, EINA_FALSE);
 456
 457     if (peer->conn_status == PEER_CONN_STATUS_DISCONNECTED)
 458     {
 459         DBG(LOG_VERBOSE, "Connect with peer [%s]\n", peer->mac_addr);
 460         res = wfd_client_connect((const char *) peer->mac_addr);
 461         if (res != 0)
 462         {
 463             DBG(LOG_ERROR, "Failed to send connection request. [%d]\n", res);
 464             return;
 465         }
 466         peer->conn_status = PEER_CONN_STATUS_CONNECTING;
 467     }
 468     else
 469     {
 470         res = wfd_client_disconnect((const char *) peer->mac_addr);
 471         if (res != 0)
 472         {
 473             DBG(LOG_ERROR, "Failed to send disconnection request. [%d]\n", res);
 474             return;
 475         }
 476         peer->conn_status = PEER_CONN_STATUS_DISCONNECTED;
 477     }
 478
 479     wfd_ug_view_refresh_glitem(peer->gl_item);
 480
 481     __FUNC_EXIT__;
 482     return;
 483 }
 484
 485 static char *_gl_help_label_get(void *data, Evas_Object * obj, const char *part)
 486 {
 487     __FUNC_ENTER__;
 488     DBG(LOG_VERBOSE, "%s", part);
 489     __FUNC_ENTER__;
 490     return strdup("Help");
 491 }
 492
 493 static Evas_Object *_create_basic_genlist(void *data)
 494 {
 495     __FUNC_ENTER__;
 496
 497     struct ug_data *ugd = (struct ug_data *) data;
 498     Evas_Object *genlist;
 499
 500     genlist = elm_genlist_add(ugd->naviframe);
 501
 502     sep_itc.item_style = "grouptitle.dialogue.seperator";
 503     sep_itc.func.text_get = NULL;
 504     sep_itc.func.content_get = NULL;
 505     sep_itc.func.state_get = NULL;
 506     sep_itc.func.del = NULL;
 507
 508     head_itc.item_style = "dialogue/1text.1icon";
 509     head_itc.func.text_get = _gl_header_label_get;
 510     head_itc.func.content_get = _gl_header_icon_get;
 511     head_itc.func.state_get = NULL;
 512
 513     name_itc.item_style = "dialogue/2text.3";
 514     name_itc.func.text_get = _gl_name_label_get;
 515     name_itc.func.content_get = NULL;
 516     name_itc.func.state_get = NULL;
 517     name_itc.func.del = NULL;
 518
 519     Elm_Object_Item *item;
 520     elm_genlist_item_append(genlist, &sep_itc, NULL, NULL,
 521                             ELM_GENLIST_ITEM_NONE, NULL, NULL);
 522     ugd->head =
 523         elm_genlist_item_append(genlist, &head_itc, ugd, NULL,
 524                                 ELM_GENLIST_ITEM_NONE, _gl_header_sel, (void*) ugd);
 525     item =
 526         elm_genlist_item_append(genlist, &name_itc, ugd, NULL,
 527                                 ELM_GENLIST_ITEM_NONE, NULL, NULL);
 528     elm_genlist_item_select_mode_set(item, ELM_OBJECT_SELECT_MODE_DISPLAY_ONLY);
 529
 530     __FUNC_EXIT__;
 531
 532     return genlist;
 533 }
 534
 535 static int _create_device_genlist(void *data)
 536 {
 537     __FUNC_ENTER__;
 538     struct ug_data *ugd = (struct ug_data *) data;
 539
 540     title_itc.item_style = "dialogue/title";
 541     title_itc.func.text_get = _gl_title_label_get;
 542     title_itc.func.content_get = NULL;
 543     title_itc.func.state_get = NULL;
 544     title_itc.func.del = NULL;
 545
 546     peer_itc.item_style = "dialogue/1text.2icon.2";
 547     peer_itc.func.text_get = _gl_peer_label_get;
 548     peer_itc.func.content_get = _gl_peer_icon_get;
 549     peer_itc.func.state_get = NULL;
 550     peer_itc.func.del = _gl_peer_del;
 551
 552     noitem_itc.item_style = "dialogue/bg/1icon";
 553     noitem_itc.func.text_get = NULL;
 554     noitem_itc.func.content_get = _gl_noitem_icon_get;
 555     noitem_itc.func.state_get = NULL;
 556     noitem_itc.func.del = _gl_noitem_del;
 557
 558     sep_itc.item_style = "grouptitle.dialogue.seperator";
 559     sep_itc.func.text_get = NULL;
 560     sep_itc.func.content_get = NULL;
 561     sep_itc.func.state_get = NULL;
 562     sep_itc.func.del = NULL;
 563
 564     help_itc.item_style = "dialogue/1text";
 565     help_itc.func.text_get = _gl_help_label_get;
 566     help_itc.func.content_get = NULL;
 567     help_itc.func.state_get = NULL;
 568     help_itc.func.del = NULL;
 569
 570     Elm_Object_Item *item;
 571     item =
 572         elm_genlist_item_append(ugd->genlist, &title_itc, (void *) ugd, NULL,
 573                                 ELM_GENLIST_ITEM_NONE, NULL, NULL);
 574     elm_genlist_item_select_mode_set(item, ELM_OBJECT_SELECT_MODE_DISPLAY_ONLY);
 575     ugd->noitem =
 576         elm_genlist_item_append(ugd->genlist, &noitem_itc, (void *) ugd, NULL,
 577                                 ELM_GENLIST_ITEM_NONE, NULL, NULL);
 578     elm_genlist_item_select_mode_set(ugd->noitem,
 579                                      ELM_OBJECT_SELECT_MODE_DISPLAY_ONLY);
 580
 581     __FUNC_EXIT__;
 582     return 0;
 583 }
 584
 585 void create_wfd_ug_view(void *data)
 586 {
 587     __FUNC_ENTER__;
 588
 589     struct ug_data *ugd = (struct ug_data *) data;
 590     Evas_Object *back_btn = NULL;
 591     Elm_Object_Item *navi_item = NULL;
 592     Evas_Object *control_bar = NULL;
 593
 594     if (ugd == NULL)
 595     {
 596         DBG(LOG_ERROR, "Incorrect parameter(NULL)");
 597         return;
 598     }
 599
 600     ugd->naviframe = elm_naviframe_add(ugd->base);
 601     elm_object_part_content_set(ugd->base, "elm.swallow.content",
 602                                 ugd->naviframe);
 603     evas_object_show(ugd->naviframe);
 604
 605     back_btn = elm_button_add(ugd->naviframe);
 606     elm_object_style_set(back_btn, "naviframe/back_btn/default");
 607     evas_object_smart_callback_add(back_btn, "clicked", _back_btn_cb,
 608                                    (void *) ugd);
 609     elm_object_focus_allow_set(back_btn, EINA_FALSE);
 610
 611     ugd->genlist = _create_basic_genlist(ugd);
 612     if (ugd->genlist == NULL)
 613     {
 614         DBG(LOG_ERROR, "Failed to create basic genlist");
 615         return;
 616     }
 617     evas_object_show(ugd->genlist);
 618     _create_device_genlist(ugd);
 619
 620     back_btn = elm_button_add(ugd->naviframe);
 621     elm_object_style_set(back_btn, "naviframe/back_btn/default");
 622     evas_object_smart_callback_add(back_btn, "clicked", _back_btn_cb,
 623                                    (void *) ugd);
 624     elm_object_focus_allow_set(back_btn, EINA_FALSE);
 625
 626     navi_item =
 627         elm_naviframe_item_push(ugd->naviframe, _("IDS_WFD_HEADER_WIFI_DIRECT"),
 628                                 back_btn, NULL, ugd->genlist, NULL);
 629
 630     control_bar = elm_toolbar_add(ugd->naviframe);
 631     elm_toolbar_shrink_mode_set(control_bar, ELM_TOOLBAR_SHRINK_EXPAND);
 632     evas_object_show(control_bar);
 633
 634     ugd->scan_btn =
 635         elm_toolbar_item_append(control_bar, NULL, _("IDS_WFD_BUTTON_SCAN"),
 636                                 _scan_btn_cb, (void *) ugd);
 637     elm_object_item_disabled_set(ugd->scan_btn, !ugd->wfd_onoff);
 638
 639     elm_object_item_part_content_set(navi_item, "controlbar", control_bar);
 640
 641     __FUNC_EXIT__;
 642 }
 643
 644 void destroy_wfd_ug_view(void *data)
 645 {
 646     __FUNC_ENTER__;
 647
 648     struct ug_data *ugd = (struct ug_data *) data;
 649
 650     if (ugd->genlist)
 651     {
 652         evas_object_del(ugd->genlist);
 653         ugd->genlist = NULL;
 654     }
 655
 656     if (ugd->naviframe)
 657     {
 658         evas_object_del(ugd->naviframe);
 659         ugd->naviframe = NULL;
 660     }
 661
 662     __FUNC_EXIT__;
 663 }
 664
 665 void wfd_ug_view_refresh_glitem(void *obj)
 666 {
 667     __FUNC_ENTER__;
 668     elm_genlist_item_update(obj);
 669     __FUNC_EXIT__;
 670 }
 671
 672 void wfd_ug_view_refresh_button(void *obj, int enable)
 673 {
 674     __FUNC_ENTER__;
 675     DBG(LOG_VERBOSE, "scan button is enabling. [%d]\n", enable);
 676     elm_object_item_disabled_set(obj, !enable);
 677     __FUNC_EXIT__;
 678 }
 679
 680 void wfd_ug_view_update_peers(void *data)
 681 {
 682     __FUNC_ENTER__;
 683     struct ug_data *ugd = (struct ug_data *) data;
 684     int i;
 685
 686     DBG(LOG_VERBOSE, "peer count [%d], peer instance [%x]\n", ugd->peer_cnt,
 687         ugd->peers);
 688
 689     if (ugd->peer_cnt == 0)
 690     {
 691         DBG(LOG_ERROR, "There are No peers\n");
 692         if (ugd->noitem == NULL)
 693             ugd->noitem =
 694                 elm_genlist_item_append(ugd->genlist, &noitem_itc, (void *) ugd,
 695                                         NULL, ELM_GENLIST_ITEM_NONE, NULL,
 696                                         NULL);
 697         return;
 698     }
 699     else if (ugd->peer_cnt > 0)
 700     {
 701         if (ugd->noitem)
 702         {
 703             elm_object_item_del(ugd->noitem);
 704             ugd->noitem = NULL;
 705             DBG(LOG_VERBOSE, "Noitem list is removed\n");
 706         }
 707
 708         for (i = 0; i < ugd->peer_cnt; i++)
 709         {
 710             DBG(LOG_VERBOSE, "%dth peer being added on genlist\n", i);
 711             ugd->peers[i].gl_item =
 712                 elm_genlist_item_append(ugd->genlist, &peer_itc,
 713                                         (void *) &(ugd->peers[i]), NULL,
 714                                         ELM_GENLIST_ITEM_NONE, _gl_peer_sel,
 715                                         (void *) &(ugd->peers[i]));
 716         }
 717     }
 718
 719     __FUNC_EXIT__;
 720 }
 721
 722 void wfd_ug_view_free_peers(void *data)
 723 {
 724     __FUNC_ENTER__;
 725     struct ug_data *ugd = (struct ug_data *) data;
 726     int i;
 727
 728     for (i = 0; i < ugd->peer_cnt; i++)
 729     {
 730         DBG(LOG_VERBOSE, "%dth peer is deleted\n", i);
 731         elm_object_item_del(ugd->peers[i].gl_item);
 732     }
 733
 734     if (ugd->peer_cnt > 0 && ugd->peers != NULL)
 735     {
 736         DBG(LOG_VERBOSE, "peers will be destroyed\n");
 737         free(ugd->peers);
 738         ugd->peers = NULL;
 739         ugd->peer_cnt = 0;
 740     }
 741
 742     __FUNC_EXIT__;
 743 }
 744
 745 static void _wfd_ug_act_popup_wifi_ok_cb(void *data, Evas_Object * obj,
 746                                          void *event_info)
 747 {
 748     __FUNC_ENTER__;
 749     struct ug_data *ugd = (struct ug_data *) data;
 750
 751     ugd->wfd_status = WFD_LINK_STATUS_DEACTIVATED;
 752     wfd_wifi_off();
 753
 754     evas_object_del(ugd->act_popup);
 755     ugd->act_popup = NULL;
 756     __FUNC_EXIT__;
 757 }
 758
 759 static void _wfd_ug_act_popup_wifi_cancel_cb(void *data, Evas_Object * obj,
 760                                              void *event_info)
 761 {
 762     __FUNC_ENTER__;
 763     struct ug_data *ugd = (struct ug_data *) data;
 764
 765     ugd->head_text_mode = HEAD_TEXT_TYPE_DIRECT;
 766     wfd_ug_view_refresh_glitem(ugd->head);
 767
 768     evas_object_del(ugd->act_popup);
 769     ugd->act_popup = NULL;
 770     __FUNC_EXIT__;
 771 }
 772
 773 void wfd_ug_act_popup(void *data, const char *message, int popup_type)
 774 {
 775     __FUNC_ENTER__;
 776     struct ug_data *ugd = (struct ug_data *) data;
 777     Evas_Object *popup = NULL;
 778     Evas_Object *btn1 = NULL, *btn2 = NULL;
 779
 780     popup = elm_popup_add(ugd->base);
 781     evas_object_size_hint_weight_set(popup, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
 782     elm_object_text_set(popup, message);
 783
 784     btn1 = elm_button_add(popup);
 785     elm_object_text_set(btn1, S_("IDS_COM_SK_YES"));
 786     elm_object_part_content_set(popup, "button1", btn1);
 787     evas_object_smart_callback_add(btn1, "clicked",
 788                                    _wfd_ug_act_popup_wifi_ok_cb, (void *) ugd);
 789
 790     btn2 = elm_button_add(popup);
 791     elm_object_text_set(btn2, S_("IDS_COM_SK_NO"));
 792     elm_object_part_content_set(popup, "button2", btn2);
 793     evas_object_smart_callback_add(btn2, "clicked",
 794                                    _wfd_ug_act_popup_wifi_cancel_cb,
 795                                    (void *) ugd);
 796
 797     evas_object_show(popup);
 798     ugd->act_popup = popup;
 799     __FUNC_EXIT__;
 800 }
 801
 802 void wfg_ug_act_popup_remove(void *data)
 803 {
 804     __FUNC_ENTER__;
 805     struct ug_data *ugd = (struct ug_data *) data;
 806
 807     if (ugd->act_popup)
 808     {
 809         evas_object_del(ugd->act_popup);
 810         ugd->act_popup = NULL;
 811     }
 812     __FUNC_EXIT__;
 813 }
 814
 815 static void _wfd_ug_terminate_popup_cb(void *data, Evas_Object *obj, void *event_info)
 816 {
 817     __FUNC_ENTER__;
 818     struct ug_data *ugd = (struct ug_data*) data;
 819
 820     evas_object_del(ugd->warn_popup);
 821     ugd->warn_popup = NULL;
 822
 823     wfd_ug_view_free_peers(ugd);
 824
 825     ug_destroy_me(ugd->ug);
 826     __FUNC_EXIT__;
 827 }
 828
 829 static void _wfd_ug_warn_popup_cb(void *data, Evas_Object *obj, void *event_info)
 830 {
 831     __FUNC_ENTER__;
 832     struct ug_data *ugd = (struct ug_data*) data;
 833
 834     evas_object_del(ugd->warn_popup);
 835     ugd->warn_popup = NULL;
 836     __FUNC_EXIT__;
 837 }
 838
 839 void wfd_ug_warn_popup(void *data, const char *message, int popup_type)
 840 {
 841     __FUNC_ENTER__;
 842     struct ug_data *ugd = (struct ug_data *) data;
 843     Evas_Object *popup = NULL;
 844     Evas_Object *btn = NULL;
 845
 846     popup = elm_popup_add(ugd->base);
 847     evas_object_size_hint_weight_set(popup, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
 848     elm_object_text_set(popup, message);
 849
 850     btn = elm_button_add(popup);
 851     elm_object_text_set(btn, S_("IDS_COM_SK_OK"));
 852     elm_object_part_content_set(popup, "button1", btn);
 853     if(popup_type == POPUP_TYPE_TERMINATE)
 854         evas_object_smart_callback_add(btn, "clicked", _wfd_ug_terminate_popup_cb, (void*) ugd);
 855     else
 856         evas_object_smart_callback_add(btn, "clicked", _wfd_ug_warn_popup_cb, (void*) ugd);
 857
 858     evas_object_show(popup);
 859     ugd->warn_popup = popup;
 860     __FUNC_EXIT__;
 861 }
 862
 863 void wfg_ug_warn_popup_remove(void *data)
 864 {
 865     __FUNC_ENTER__;
 866     struct ug_data *ugd = (struct ug_data *) data;
 867
 868     if (ugd->warn_popup)
 869     {
 870         evas_object_del(ugd->warn_popup);
 871         ugd->warn_popup = NULL;
 872     }
 873     __FUNC_EXIT__;
 874 }