ug-wifidirect/src/wfd_ug_main_view.c

   1 /*
   2 *  WiFi-Direct UG
   3 *
   4 * Copyright 2012  Samsung Electronics Co., Ltd
   5
   6 * Licensed under the Flora License, Version 1.0 (the "License");
   7 * you may not use this file except in compliance with the License.
   8 * You may obtain a copy of the License at
   9
  10 * http://www.tizenopensource.org/license
  11
  12 * Unless required by applicable law or agreed to in writing, software
  13 * distributed under the License is distributed on an "AS IS" BASIS,
  14 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  15 * See the License for the specific language governing permissions and
  16 * limitations under the License.
  17 *
  18 */
  19
  20
  21 #include <libintl.h>
  22
  23 #include <assert.h>
  24 #include <glib.h>
  25
  26 #include <Elementary.h>
  27 #include <vconf.h>
  28 #include <ui-gadget-module.h>
  29 #include <wifi-direct.h>
  30
  31 #include "wfd_ug.h"
  32 #include "wfd_ug_view.h"
  33 #include "wfd_client.h"
  34
  35 void _wfd_onoff_btn_cb(void *data, Evas_Object *obj, void *event_info);
  36
  37
  38 void _back_btn_cb(void *data, Evas_Object * obj, void *event_info)
  39 {
  40     __FUNC_ENTER__;
  41     struct ug_data *ugd = (struct ug_data*) data;
  42
  43     if(!ugd)
  44     {
  45         DBG(LOG_ERROR, "The param is NULL\n");
  46         return;
  47     }
  48
  49     wfd_ug_view_free_peers(ugd);
  50 #if 0
  51     bundle *b;
  52     b = bundle_create();
  53     if(!b)
  54     {
  55         DBG(LOG_ERROR, "Failed to create bundle");
  56         return;
  57     }
  58
  59     wfd_refresh_wifi_direct_state(ugd);
  60     if (ugd->wfd_status > WIFI_DIRECT_STATE_CONNECTING)
  61         bundle_add(b, "Connection", "TRUE");
  62     else
  63         bundle_add(b, "Connection", "FALSE");
  64
  65     ug_send_result(ugd->ug, b);
  66
  67     bundle_free(b);
  68 #else
  69         int ret = -1;
  70         service_h service = NULL;
  71         ret = service_create(&service);
  72         if(ret)
  73         {
  74                 DBG(LOG_ERROR, "Failed to create service");
  75                 return;
  76         }
  77
  78         wfd_refresh_wifi_direct_state(ugd);
  79         if (ugd->wfd_status > WIFI_DIRECT_STATE_CONNECTING)
  80                 service_add_extra_data(service, "Connection", "TRUE");
  81         else
  82                 service_add_extra_data(service, "Connection", "FALSE");
  83
  84         ug_send_result(ugd->ug, service);
  85         service_destroy(service);
  86 #endif
  87     ug_destroy_me(ugd->ug);
  88
  89     __FUNC_EXIT__;
  90     return;
  91 }
  92
  93 void _scan_btn_cb(void *data, Evas_Object * obj, void *event_info)
  94 {
  95     __FUNC_ENTER__;
  96
  97     struct ug_data *ugd = (struct ug_data*) data;
  98     Elm_Object_Item *btn = event_info;
  99     char *btn_text = NULL;
 100
 101     if (NULL == ugd || NULL == btn) {
 102         DBG(LOG_ERROR, "Incorrect parameter(NULL)\n");
 103         return;
 104     }
 105
 106     btn_text = elm_object_item_text_get(btn);
 107     if (0 == strcmp(btn_text, _("IDS_WFD_BUTTON_SCAN"))) {
 108         wfd_refresh_wifi_direct_state(ugd);
 109         DBG(LOG_VERBOSE, "Start discovery again, status: %d\n", ugd->wfd_status);
 110
 111         /* if connected, show the popup*/
 112         if (ugd->wfd_status >= WIFI_DIRECT_STATE_CONNECTED) {
 113                 wfd_ug_act_popup(ugd, IDS_WFD_POP_SCAN_AGAIN, POP_TYPE_SCAN_AGAIN);
 114         } else if (WIFI_DIRECT_STATE_ACTIVATED == ugd->wfd_status) {
 115                 wfd_client_start_discovery(ugd);
 116         } else if (WIFI_DIRECT_STATE_DEACTIVATED == ugd->wfd_status) {
 117                 _wfd_onoff_btn_cb(ugd, NULL, NULL);
 118                 __FUNC_EXIT__;
 119                 return;
 120         }
 121
 122         if (ugd->scan_btn) {
 123                 wfd_ug_view_refresh_button(ugd->scan_btn, _("IDS_WFD_BUTTON_STOPSCAN"), TRUE);
 124         }
 125
 126         if (ugd->multi_scan_btn) {
 127                 wfd_ug_view_refresh_button(ugd->multi_scan_btn, _("IDS_WFD_BUTTON_STOPSCAN"), TRUE);
 128         }
 129     } else if (0 == strcmp(btn_text, _("IDS_WFD_BUTTON_STOPSCAN"))) {
 130         DBG(LOG_VERBOSE, "Stop discoverying.\n");
 131         ugd->wfd_status = WIFI_DIRECT_STATE_ACTIVATED;
 132         wfd_refresh_wifi_direct_state(ugd);
 133         ugd->head_text_mode = HEAD_TEXT_TYPE_DIRECT;
 134         wfd_ug_view_refresh_glitem(ugd->head);
 135         wifi_direct_cancel_discovery();
 136     }
 137
 138     __FUNC_EXIT__;
 139     return;
 140 }
 141
 142 Eina_Bool _is_wifi_on()
 143 {
 144     __FUNC_ENTER__;
 145     int wifi_state;
 146
 147     vconf_get_int(VCONFKEY_WIFI_STATE, &wifi_state);
 148
 149     if (wifi_state >= VCONFKEY_WIFI_CONNECTED)
 150     {
 151         return TRUE;
 152     }
 153     else
 154     {
 155         return FALSE;
 156     }
 157     __FUNC_EXIT__;
 158 }
 159
 160 void _wfd_onoff_btn_cb(void *data, Evas_Object *obj, void *event_info)
 161 {
 162     __FUNC_ENTER__;
 163     struct ug_data *ugd = (struct ug_data*) data;
 164
 165     wfd_refresh_wifi_direct_state(ugd);
 166
 167     if(!ugd->wfd_onoff)
 168     {
 169         if(ugd->wfd_status < 0)
 170         {
 171             DBG(LOG_VERBOSE, "bad wfd status\n");
 172             wfd_ug_warn_popup(ugd, _("IDS_WFD_POP_ACTIVATE_FAIL"), POPUP_TYPE_TERMINATE);
 173
 174             ugd->head_text_mode = HEAD_TEXT_TYPE_DIRECT;
 175             wfd_ug_view_refresh_glitem(ugd->head);
 176             return;
 177         }
 178         DBG(LOG_VERBOSE, "wifi-direct switch on\n");
 179         ugd->head_text_mode = HEAD_TEXT_TYPE_ACTIVATING;
 180         wfd_client_switch_on(ugd);
 181     }
 182     else
 183     {
 184         if(ugd->wfd_status < 0)
 185         {
 186             DBG(LOG_VERBOSE, "bad wfd status\n");
 187             wfd_ug_warn_popup(ugd, _("IDS_WFD_POP_DEACTIVATE_FAIL"), POPUP_TYPE_TERMINATE);
 188
 189             ugd->head_text_mode = HEAD_TEXT_TYPE_DIRECT;
 190             wfd_ug_view_refresh_glitem(ugd->head);
 191             return;
 192         }
 193         DBG(LOG_VERBOSE, "wifi-direct switch off\n");
 194         ugd->head_text_mode = HEAD_TEXT_TYPE_DEACTIVATING;
 195         wfd_client_switch_off(ugd);
 196     }
 197
 198     wfd_ug_view_refresh_glitem(ugd->head);
 199
 200     if (ugd->scan_btn) {
 201         wfd_ug_view_refresh_button(ugd->scan_btn, _("IDS_WFD_BUTTON_SCAN"), FALSE);
 202     }
 203
 204     if (ugd->multi_scan_btn) {
 205         wfd_ug_view_refresh_button(ugd->multi_scan_btn, _("IDS_WFD_BUTTON_SCAN"), FALSE);
 206     }
 207
 208
 209     __FUNC_EXIT__;
 210 }
 211
 212
 213 static void _gl_header_sel(void *data, Evas_Object *obj, void *event_info)
 214 {
 215     __FUNC_ENTER__;
 216     struct ug_data *ugd = (struct ug_data*) data;
 217     Elm_Object_Item *item = (Elm_Object_Item *)event_info;
 218
 219     if(data == NULL)
 220     {
 221         DBG(LOG_ERROR, "Incorrect parameter(NULL)\n");
 222         return;
 223     }
 224
 225     if(item != NULL)
 226         elm_genlist_item_selected_set(item, EINA_FALSE);
 227
 228     _wfd_onoff_btn_cb(ugd, NULL, NULL);
 229
 230     __FUNC_EXIT__;
 231 }
 232
 233 #if 0
 234 static Evas_Object *_gl_noitem_icon_get(void *data, Evas_Object * obj,
 235                                           const char *part)
 236 {
 237     __FUNC_ENTER__;
 238     Evas_Object *nocontent;
 239
 240     if(data == NULL)
 241     {
 242         DBG(LOG_ERROR, "Incorrect parameter(NULL)\n");
 243         return NULL;
 244     }
 245
 246 #if 1   // use nocontent
 247     nocontent = elm_layout_add(obj);
 248     if(nocontent == NULL)
 249     {
 250         DBG(LOG_ERROR, "Failed to add nocontent");
 251         return NULL;
 252     }
 253     elm_layout_theme_set(nocontent, "layout", "nocontents", "unnamed");
 254     elm_object_part_text_set(nocontent, "elm.text", _("IDS_WFD_BODY_NO_DEVICES"));
 255     evas_object_size_hint_min_set(nocontent, 400, 200);
 256     evas_object_size_hint_max_set(nocontent, 400, 200);
 257     evas_object_resize(nocontent, 400, 200);
 258
 259     __FUNC_EXIT__;
 260
 261     return nocontent;
 262 #else   // use image
 263     Evas_Object *icon;
 264     icon = elm_icon_add(obj);
 265     elm_icon_file_set(icon, "/usr/ug/res/images/ug-wifi-direct/A09_NoDevice.png", NULL);
 266     evas_object_size_hint_min_set(icon, 400, 200);
 267     evas_object_size_hint_max_set(icon, 400, 200);
 268     evas_object_resize(icon, 400, 200);
 269
 270     return icon;
 271 #endif
 272 }
 273 #endif
 274
 275 static void _gl_peer_sel(void *data, Evas_Object *obj, void *event_info)
 276 {
 277     __FUNC_ENTER__;
 278     assertm_if(NULL == obj, "NULL!!");
 279     assertm_if(NULL == data, "NULL!!");
 280     device_type_s *peer = (device_type_s*) data;
 281     Elm_Object_Item *item = (Elm_Object_Item *)event_info;
 282     struct ug_data* ugd = wfd_get_ug_data();
 283     int res;
 284
 285     if(data == NULL)
 286     {
 287         DBG(LOG_ERROR, "Incorrect parameter(NULL)\n");
 288         return;
 289     }
 290
 291     if(item != NULL)
 292         elm_genlist_item_selected_set(item, EINA_FALSE);
 293
 294     if(peer->conn_status == PEER_CONN_STATUS_DISCONNECTED)
 295     {
 296 #if 0   // for new connection during link_status is CONNECTING
 297         wfd_refresh_wifi_direct_state(ugd);
 298         if(ugd->wfd_status == WFD_LINK_STATUS_CONNECTING)
 299         {
 300             res = wfd_client_disconnect(NULL);
 301             if(res != 0)
 302             {
 303                 DBG(LOG_ERROR, "Failed to send disconnection request. [%d]\n", res);
 304                 return;
 305             }
 306         }
 307 #endif
 308         DBG(LOG_VERBOSE, "Connect with peer [%s]\n", peer->mac_addr);
 309         res = wfd_client_connect((const char*) peer->mac_addr);
 310         if(res != 0)
 311         {
 312             DBG(LOG_ERROR, "Failed to send connection request. [%d]\n", res);
 313             return;
 314         }
 315         peer->conn_status = PEER_CONN_STATUS_CONNECTING;
 316     }
 317     else    // PEER_CONN_STATUS_CONNECTED or PEER_CONN_STATUS_CONNECTING)
 318     {
 319         res = wfd_client_disconnect((const char*) peer->mac_addr);
 320         if(res != 0)
 321         {
 322             DBG(LOG_ERROR, "Failed to send disconnection request. [%d]\n", res);
 323             return;
 324         }
 325         peer->conn_status = PEER_CONN_STATUS_DISCONNECTED;
 326     }
 327
 328     wfd_ug_view_refresh_glitem(peer->gl_item);
 329     wfd_ug_view_refresh_glitem(ugd->multi_button_item);
 330
 331     __FUNC_EXIT__;
 332     return;
 333 }
 334
 335 static void _gl_busy_peer_sel(void *data, Evas_Object *obj, void *event_info)
 336 {
 337     __FUNC_ENTER__;
 338
 339     struct ug_data *ugd = (struct ug_data*) data;
 340
 341     elm_genlist_item_selected_set((Elm_Object_Item *)event_info, EINA_FALSE);
 342
 343     DBG(LOG_VERBOSE, "Busy device is clicked");
 344
 345     wfd_ug_warn_popup(ugd, IDS_WFD_POP_WARN_BUSY_DEVICE, POP_TYPE_BUSY_DEVICE_POPUP);
 346
 347     __FUNC_EXIT__;
 348 }
 349
 350 static void _gl_about_wifi_sel(void *data, Evas_Object *obj, void *event_info)
 351 {
 352     struct ug_data *ugd = (struct ug_data*) data;
 353
 354     DBG(LOG_VERBOSE, "About wifi clicked");
 355
 356     _wifid_create_about_view(ugd);
 357     elm_genlist_item_selected_set((Elm_Object_Item *)event_info, EINA_FALSE);
 358 }
 359
 360 void _wifid_create_multibutton_cb(void *data, Evas_Object * obj, void *event_info)
 361 {
 362     struct ug_data *ugd = (struct ug_data*) data;
 363     const char *text_lbl = NULL;
 364
 365     text_lbl = elm_object_text_get(ugd->multi_btn);
 366     DBG(LOG_VERBOSE, "text_lbl = %s", text_lbl);
 367
 368     if (ugd->multi_connect_mode == WFD_MULTI_CONNECT_MODE_IN_PROGRESS)
 369     {
 370         ugd->multi_connect_mode = WFD_MULTI_CONNECT_MODE_NONE;
 371                 if (0 == strcmp(_("IDS_WFD_BUTTON_CANCEL"), text_lbl))
 372                 {
 373                         wfd_ug_act_popup(ugd, _("IDS_WFD_POP_CANCEL_CONNECT"), POP_TYPE_DISCONNECT_ALL);
 374                 }
 375                 else
 376                 {
 377                         DBG(LOG_VERBOSE, "Invalid Case\n");
 378                 }
 379     }
 380     else
 381     {
 382                 if (0 == strcmp(_("IDS_WFD_BUTTON_MULTI"), text_lbl))
 383                 {
 384                         _wifid_create_multiconnect_view(ugd);
 385                 }
 386                 else if (0 == strcmp(_("IDS_WFD_BUTTON_CANCEL"), text_lbl))
 387                 {
 388                         wfd_ug_act_popup(ugd, _("IDS_WFD_POP_CANCEL_CONNECT"), POP_TYPE_DISCONNECT_ALL);
 389                 }
 390                 else if (0 == strcmp(_("IDS_WFD_BUTTON_DISCONNECT_ALL"), text_lbl))
 391                 {
 392                         wfd_ug_act_popup(ugd, _("IDS_WFD_POP_DISCONNECT"), POP_TYPE_DISCONNECT_ALL);
 393                 }
 394                 else if (0 == strcmp(_("IDS_WFD_BUTTON_DISCONNECT"), text_lbl))
 395                 {
 396                         wfd_ug_act_popup(ugd, _("IDS_WFD_POP_DISCONNECT"), POP_TYPE_DISCONNECT);
 397                 }
 398                 else
 399                 {
 400                         DBG(LOG_VERBOSE, "Invalid Case\n");
 401                 }
 402     }
 403 }
 404
 405
 406 int _change_multi_button_title(void *data)
 407 {
 408     struct ug_data *ugd = (struct ug_data*) data;
 409
 410     if(ugd->multi_button_item == NULL) /*Needs to be check as the peer count is not getting updated*/
 411     {
 412         return -1;
 413     }
 414
 415         wfd_refresh_wifi_direct_state(ugd);
 416         if (ugd->wfd_status == WFD_LINK_STATUS_CONNECTING)
 417         {
 418                 //if (conn_prog_count > 0)
 419                 elm_object_text_set(ugd->multi_btn, _("IDS_WFD_BUTTON_CANCEL"));
 420         }
 421         else if (ugd->wfd_status > WFD_LINK_STATUS_CONNECTING)
 422         {
 423                 if (ugd->gl_connected_peer_cnt > 1)
 424                         elm_object_text_set(ugd->multi_btn, _("IDS_WFD_BUTTON_DISCONNECT_ALL"));
 425                 else
 426                         elm_object_text_set(ugd->multi_btn, _("IDS_WFD_BUTTON_DISCONNECT"));
 427         }
 428         else
 429         {
 430                 elm_object_text_set(ugd->multi_btn, _("IDS_WFD_BUTTON_MULTI"));
 431         }
 432
 433     evas_object_show(ugd->multi_btn);
 434
 435     return 0;
 436 }
 437
 438
 439 void wfd_ug_view_refresh_glitem(void *obj)
 440 {
 441     __FUNC_ENTER__;
 442     elm_genlist_item_update(obj);
 443     __FUNC_EXIT__;
 444 }
 445
 446 void wfd_ug_view_refresh_button(void *obj, const char *text, int enable)
 447 {
 448         __FUNC_ENTER__;
 449
 450         if (NULL == obj || NULL == text) {
 451                 DBG(LOG_ERROR, "Incorrect parameter(NULL)\n");
 452                 return;
 453         }
 454
 455         DBG(LOG_VERBOSE, "Set the attributes of button: text[%s], enabled[%d]\n", text, enable);
 456         elm_object_item_text_set(obj, text);
 457         elm_object_item_disabled_set(obj, !enable);
 458
 459         __FUNC_EXIT__;
 460 }
 461
 462 static bool __wfd_is_device_connected_with_me(struct ug_data *ugd, device_type_s *dev)
 463 {
 464         int i;
 465
 466         for(i=0; i<ugd->raw_connected_peer_cnt; i++)
 467         {
 468                 if (strncmp(ugd->raw_connected_peers[i].mac_addr, dev->mac_addr, strlen(ugd->raw_connected_peers[i].mac_addr)) == 0)
 469                         return TRUE;
 470         }
 471         return FALSE;
 472 }
 473
 474 static bool __wfd_is_device_busy(struct ug_data *ugd, device_type_s *dev)
 475 {
 476         if (__wfd_is_device_connected_with_me(ugd, dev) == TRUE)
 477                 return FALSE;
 478
 479         if (ugd->I_am_group_owner == TRUE)
 480         {
 481                 if (dev->is_connected || dev->is_group_owner)
 482                         return TRUE;
 483                 else
 484                         return FALSE;
 485         }
 486         else
 487         {
 488                 if (dev->is_connected == TRUE && dev->is_group_owner == TRUE)
 489                         return FALSE;
 490                 if (dev->is_connected == TRUE && dev->is_group_owner == FALSE)
 491                         return TRUE;
 492                 if (dev->is_connected == FALSE)
 493                         return FALSE;
 494         }
 495
 496         return FALSE;
 497 }
 498
 499 static bool __wfd_is_any_device_available(struct ug_data *ugd, int* no_of_available_dev)
 500 {
 501     int i =0 ;
 502     for (i = 0; i < ugd->raw_discovered_peer_cnt; i++)
 503     {
 504         if (!__wfd_is_device_busy(ugd, &ugd->raw_discovered_peers[i]) &&
 505                 ugd->raw_discovered_peers[i].conn_status == PEER_CONN_STATUS_DISCONNECTED)
 506                 (*no_of_available_dev)++;
 507     }
 508     return TRUE;
 509 }
 510
 511 static bool __wfd_is_any_device_busy(struct ug_data *ugd, int* no_of_busy_dev)
 512 {
 513     int i =0 ;
 514     for (i = 0; i < ugd->raw_discovered_peer_cnt; i++)
 515     {
 516         if (__wfd_is_device_busy(ugd, &ugd->raw_discovered_peers[i]))
 517             (*no_of_busy_dev)++;
 518     }
 519     return TRUE;
 520 }
 521
 522 static bool __wfd_is_any_device_connect_failed(struct ug_data *ugd, int* no_of_connect_failed_dev)
 523 {
 524     int i =0 ;
 525     for (i = 0; i < ugd->raw_discovered_peer_cnt; i++)
 526     {
 527         if (!__wfd_is_device_busy(ugd, &ugd->raw_discovered_peers[i]) &&
 528                 ugd->raw_discovered_peers[i].conn_status == PEER_CONN_STATUS_FAILED_TO_CONNECT)
 529                 (*no_of_connect_failed_dev)++;
 530
 531     }
 532     return TRUE;
 533 }
 534
 535 static Evas_Object *_create_basic_genlist(void *data)
 536 {
 537         __FUNC_ENTER__;
 538
 539         struct ug_data *ugd = (struct ug_data*) data;
 540         Evas_Object *genlist;
 541         Elm_Object_Item *separator_item;
 542
 543
 544         genlist = elm_genlist_add(ugd->naviframe);
 545
 546
 547         separator_item = elm_genlist_item_append(genlist, &sep_itc, NULL, NULL, ELM_GENLIST_ITEM_NONE, NULL, NULL);
 548         elm_genlist_item_select_mode_set(separator_item, ELM_OBJECT_SELECT_MODE_DISPLAY_ONLY);
 549
 550         ugd->head = elm_genlist_item_append(genlist, &head_itc, ugd, NULL, ELM_GENLIST_ITEM_NONE, _gl_header_sel, (void*) ugd);
 551
 552         //elm_genlist_item_select_mode_set(ugd->head, ELM_OBJECT_SELECT_MODE_DISPLAY_ONLY);
 553
 554         __FUNC_EXIT__;
 555
 556         return genlist;
 557 }
 558
 559 static Evas_Object *_create_about_genlist(void *data)
 560 {
 561     __FUNC_ENTER__;
 562
 563     struct ug_data *ugd = (struct ug_data*) data;
 564
 565     ugd->about_wfd_item = elm_genlist_item_append(ugd->genlist, &name_itc, ugd, NULL, ELM_GENLIST_ITEM_NONE, _gl_about_wifi_sel, (void*) ugd);
 566
 567     /* add end separator */
 568     ugd->about_wfdsp_sep_end_item = elm_genlist_item_append(ugd->genlist, &sep_itc_end, NULL, NULL, ELM_GENLIST_ITEM_NONE, NULL, NULL);
 569     elm_genlist_item_select_mode_set(ugd->about_wfdsp_sep_end_item, ELM_OBJECT_SELECT_MODE_DISPLAY_ONLY);
 570
 571     __FUNC_EXIT__;
 572
 573     return ugd->genlist;
 574 }
 575
 576 static Evas_Object *_create_no_device_genlist(void *data)
 577 {
 578     __FUNC_ENTER__;
 579
 580     struct ug_data *ugd = (struct ug_data*) data;
 581
 582     ugd->nodevice_title_item = elm_genlist_item_append(ugd->genlist, &title_itc, (void*)ugd, NULL,
 583                                                                         ELM_GENLIST_ITEM_NONE, NULL, NULL);
 584
 585     ugd->nodevice_item = elm_genlist_item_append(ugd->genlist, &noitem_itc, (void*)ugd, NULL,
 586                                                                         ELM_GENLIST_ITEM_NONE, NULL, NULL);
 587
 588         ugd->nodevice_sep_low_item = elm_genlist_item_append(ugd->genlist, &sep_itc, NULL, NULL,
 589                                                                                         ELM_GENLIST_ITEM_NONE, NULL, NULL);
 590
 591     elm_genlist_item_select_mode_set(ugd->nodevice_item, ELM_OBJECT_SELECT_MODE_DISPLAY_ONLY);
 592
 593     __FUNC_EXIT__;
 594     return ugd->genlist;
 595 }
 596
 597 int _create_multi_button_genlist(void *data)
 598 {
 599     __FUNC_ENTER__;
 600     struct ug_data *ugd = (struct ug_data*) data;
 601
 602         ugd->multi_button_sep_high_item = elm_genlist_item_append(ugd->genlist, &sep_itc, NULL, NULL,
 603                                                                                         ELM_GENLIST_ITEM_NONE, NULL, NULL);
 604
 605         /* if not connected and number of devices is less than 2, don't show the button */
 606         if (ugd->raw_multi_selected_peer_cnt > 1 ||
 607                 ugd->gl_available_peer_cnt > 1 ||
 608                 ugd->gl_connected_peer_cnt > 0) {
 609                 ugd->multi_button_item = elm_genlist_item_append(ugd->genlist, &button_itc, ugd, NULL,
 610                         ELM_GENLIST_ITEM_NONE, NULL, NULL);
 611                 ugd->multi_button_sep_low_item = elm_genlist_item_append(ugd->genlist, &sep_itc, NULL, NULL,
 612                         ELM_GENLIST_ITEM_NONE, NULL, NULL);
 613         }
 614
 615     evas_object_show(ugd->multi_btn);
 616     __FUNC_EXIT__;
 617     return 0;
 618 }
 619
 620
 621 int _create_busy_dev_list(void *data)
 622 {
 623     __FUNC_ENTER__;
 624     struct ug_data *ugd = (struct ug_data*) data;
 625
 626         ugd->busy_wfd_item = elm_genlist_item_append(ugd->genlist, &title_busy_itc, (void*)ugd, NULL,
 627                                                                         ELM_GENLIST_ITEM_NONE, NULL, NULL);
 628
 629     elm_genlist_item_select_mode_set(ugd->busy_wfd_item, ELM_OBJECT_SELECT_MODE_DISPLAY_ONLY);
 630
 631
 632     __FUNC_EXIT__;
 633     return 0;
 634 }
 635
 636 static int _create_available_dev_genlist(void *data)
 637 {
 638     __FUNC_ENTER__;
 639     struct ug_data *ugd = (struct ug_data*) data;
 640
 641     ugd->avlbl_wfd_item = elm_genlist_item_append(ugd->genlist, &title_itc, (void*)ugd, NULL,
 642                                                                         ELM_GENLIST_ITEM_NONE, NULL, NULL);
 643
 644     // elm_genlist_item_select_mode_set(ugd->avlbl_wfd_item, ELM_OBJECT_SELECT_MODE_DISPLAY_ONLY);
 645
 646     __FUNC_EXIT__;
 647     return 0;
 648 }
 649
 650 static int _create_multi_connect_dev_genlist(void *data)
 651 {
 652     __FUNC_ENTER__;
 653     struct ug_data *ugd = (struct ug_data*) data;
 654
 655     ugd->multi_connect_wfd_item = elm_genlist_item_append(ugd->genlist, &title_multi_connect_itc, (void*)ugd, NULL,
 656                                                                         ELM_GENLIST_ITEM_NONE, NULL, NULL);
 657
 658     // elm_genlist_item_select_mode_set(ugd->avlbl_wfd_item, ELM_OBJECT_SELECT_MODE_DISPLAY_ONLY);
 659
 660     __FUNC_EXIT__;
 661     return 0;
 662 }
 663
 664 int _create_connected_dev_genlist(void *data)
 665 {
 666     __FUNC_ENTER__;
 667     struct ug_data *ugd = (struct ug_data*) data;
 668
 669     ugd->conn_wfd_item = elm_genlist_item_append(ugd->genlist, &title_conn_itc, (void*)ugd, NULL,
 670                                                                         ELM_GENLIST_ITEM_NONE, NULL, NULL);
 671
 672     elm_genlist_item_select_mode_set(ugd->conn_wfd_item, ELM_OBJECT_SELECT_MODE_DISPLAY_ONLY);
 673     __FUNC_EXIT__;
 674     return 0;
 675 }
 676
 677 int _create_connected_failed_dev_genlist(void *data)
 678 {
 679     __FUNC_ENTER__;
 680     struct ug_data *ugd = (struct ug_data*) data;
 681
 682     ugd->conn_failed_wfd_item = elm_genlist_item_append(ugd->genlist, &title_conn_failed_itc, (void*)ugd, NULL,
 683                                                                         ELM_GENLIST_ITEM_NONE, NULL, NULL);
 684
 685     elm_genlist_item_select_mode_set(ugd->conn_failed_wfd_item, ELM_OBJECT_SELECT_MODE_DISPLAY_ONLY);
 686     __FUNC_EXIT__;
 687     return 0;
 688 }
 689
 690 static Eina_Bool _connect_failed_peers_display_cb(void *user_data)
 691 {
 692         int interval = 0;
 693         struct ug_data *ugd = (struct ug_data*) user_data;
 694
 695         if (NULL == ugd) {
 696                 DBG(LOG_ERROR, "NULL parameters.\n");
 697                 return ECORE_CALLBACK_CANCEL;
 698         }
 699
 700         /* check the timeout, if not timeout, keep the cb */
 701         interval = time(NULL) - ugd->last_display_time;
 702         if (interval < MAX_DISPLAY_TIME_OUT) {
 703                 return ECORE_CALLBACK_RENEW;
 704         }
 705
 706         /* re-discovery */
 707         wfd_client_start_discovery(ugd);
 708
 709         /* get peers and update the view */
 710         wfd_ug_get_discovered_peers(ugd);
 711         wfd_ug_get_connected_peers(ugd);
 712         wfd_ug_view_update_peers(ugd);
 713
 714         return ECORE_CALLBACK_CANCEL;
 715 }
 716
 717 void wfd_ug_view_free_peers(void *data)
 718 {
 719     __FUNC_ENTER__;
 720     struct ug_data *ugd = (struct ug_data*) data;
 721     int i;
 722
 723     for(i = 0; i < ugd->gl_connected_peer_cnt; i++)
 724     {
 725         DBG(LOG_VERBOSE, "%dth connected peer = %x is deleted\n", i, ugd->gl_connected_peers[i]);
 726         if (ugd->gl_connected_peers[i].gl_item != NULL)
 727         {
 728             elm_object_item_del(ugd->gl_connected_peers[i].gl_item);
 729             ugd->gl_connected_peers[i].gl_item = NULL;
 730             DBG(LOG_VERBOSE, "Deleted item\n");
 731         }
 732     }
 733         ugd->gl_connected_peer_cnt = 0;
 734
 735     for(i = 0; i < ugd->gl_connected_failed_peer_cnt; i++)
 736     {
 737         DBG(LOG_VERBOSE, "%dth connected failed peer = %x is deleted\n", i, ugd->gl_connected_failed_peers[i]);
 738         if (ugd->gl_connected_failed_peers[i].gl_item != NULL)
 739         {
 740             elm_object_item_del(ugd->gl_connected_failed_peers[i].gl_item);
 741             ugd->gl_connected_failed_peers[i].gl_item = NULL;
 742             DBG(LOG_VERBOSE, "Deleted item\n");
 743         }
 744     }
 745
 746     ugd->gl_connected_failed_peer_cnt = 0;
 747
 748     for(i = 0; i < ugd->gl_available_peer_cnt; i++)
 749     {
 750         DBG(LOG_VERBOSE, "%dth discovered peer = %x is deleted\n", i, ugd->gl_available_peers[i]);
 751         if (ugd->gl_available_peers[i].gl_item != NULL)
 752         {
 753             elm_object_item_del(ugd->gl_available_peers[i].gl_item);
 754             ugd->gl_available_peers[i].gl_item = NULL;
 755             DBG(LOG_VERBOSE, "Deleted item\n");
 756         }
 757     }
 758         ugd->gl_available_peer_cnt = 0;
 759
 760     for(i = 0; i < ugd->gl_busy_peer_cnt; i++)
 761     {
 762         DBG(LOG_VERBOSE, "%dth busy peer = %x is deleted\n", i, ugd->gl_busy_peers[i]);
 763         if (ugd->gl_busy_peers[i].gl_item != NULL)
 764         {
 765             elm_object_item_del(ugd->gl_busy_peers[i].gl_item);
 766             ugd->gl_busy_peers[i].gl_item = NULL;
 767             DBG(LOG_VERBOSE, "Deleted item\n");
 768         }
 769     }
 770         ugd->gl_busy_peer_cnt = 0;
 771
 772     for(i = 0; i < ugd->gl_multi_connect_peer_cnt; i++)
 773     {
 774         DBG(LOG_VERBOSE, "%dth busy peer = %x is deleted\n", i, ugd->gl_multi_connect_peers[i]);
 775         if (ugd->gl_multi_connect_peers[i].gl_item != NULL)
 776         {
 777             elm_object_item_del(ugd->gl_multi_connect_peers[i].gl_item);
 778             ugd->gl_multi_connect_peers[i].gl_item = NULL;
 779             DBG(LOG_VERBOSE, "Deleted item\n");
 780         }
 781     }
 782         ugd->gl_multi_connect_peer_cnt = 0;
 783
 784     if(ugd->nodevice_title_item != NULL)
 785     {
 786         elm_object_item_del(ugd->nodevice_title_item);
 787         ugd->nodevice_title_item = NULL;
 788     }
 789     if(ugd->nodevice_item != NULL)
 790     {
 791         elm_object_item_del(ugd->nodevice_item);
 792         ugd->nodevice_item = NULL;
 793     }
 794     if(ugd->nodevice_sep_low_item != NULL)
 795     {
 796         elm_object_item_del(ugd->nodevice_sep_low_item);
 797         ugd->nodevice_sep_low_item = NULL;
 798     }
 799     if(ugd->about_wfd_item != NULL)
 800     {
 801         elm_object_item_del(ugd->about_wfd_item);
 802         ugd->about_wfd_item = NULL;
 803     }
 804
 805     if(ugd->conn_wfd_item != NULL)
 806     {
 807         elm_object_item_del(ugd->conn_wfd_item);
 808         ugd->conn_wfd_item = NULL;
 809     }
 810     if(ugd->conn_failed_wfd_item != NULL)
 811     {
 812         elm_object_item_del(ugd->conn_failed_wfd_item);
 813         ugd->conn_failed_wfd_item = NULL;
 814     }
 815     if(ugd->conn_failed_wfd_sep_item != NULL)
 816     {
 817         elm_object_item_del(ugd->conn_failed_wfd_sep_item);
 818         ugd->conn_failed_wfd_sep_item = NULL;
 819     }
 820     if(ugd->display_timer != NULL)
 821     {
 822         elm_object_item_del(ugd->display_timer);
 823         ugd->display_timer = NULL;
 824     }
 825     if(ugd->multi_connect_wfd_item != NULL)
 826     {
 827         elm_object_item_del(ugd->multi_connect_wfd_item);
 828         ugd->multi_connect_wfd_item = NULL;
 829     }
 830     if(ugd->avlbl_wfd_item != NULL)
 831     {
 832         elm_object_item_del(ugd->avlbl_wfd_item);
 833         ugd->avlbl_wfd_item = NULL;
 834     }
 835     if(ugd->busy_wfd_item != NULL)
 836     {
 837         elm_object_item_del(ugd->busy_wfd_item);
 838         ugd->busy_wfd_item = NULL;
 839     }
 840     if(ugd->busy_wfd_sep_item != NULL)
 841     {
 842         elm_object_item_del(ugd->busy_wfd_sep_item);
 843         ugd->busy_wfd_sep_item = NULL;
 844     }
 845
 846     if(ugd->multi_button_item != NULL)
 847     {
 848         elm_object_item_del(ugd->multi_button_item);
 849         ugd->multi_button_item = NULL;
 850     }
 851     if(ugd->multi_button_sep_high_item != NULL)
 852     {
 853         elm_object_item_del(ugd->multi_button_sep_high_item);
 854         ugd->multi_button_sep_high_item = NULL;
 855     }
 856     if(ugd->multi_button_sep_low_item != NULL)
 857     {
 858         elm_object_item_del(ugd->multi_button_sep_low_item);
 859         ugd->multi_button_sep_low_item = NULL;
 860     }
 861     if(ugd->about_wfdsp_sep_end_item != NULL)
 862     {
 863         elm_object_item_del(ugd->about_wfdsp_sep_end_item);
 864         ugd->about_wfdsp_sep_end_item = NULL;
 865     }
 866
 867     __FUNC_EXIT__;
 868 }
 869
 870
 871 void wfd_ug_view_update_peers(void *data)
 872 {
 873     __FUNC_ENTER__;
 874
 875     struct ug_data *ugd = (struct ug_data*) data;
 876     int no_of_busy_dev = 0;
 877     int no_of_available_dev = 0;
 878     int no_of_conn_dev = 0;
 879     int no_of_conn_failed_dev = 0;
 880     int i = 0 ;
 881     int res = 0;
 882     bool is_group_owner = FALSE;
 883     int count = 0;
 884
 885     wfd_ug_view_free_peers(ugd);
 886
 887     if(ugd->wfd_status == WFD_LINK_STATUS_DEACTIVATED)
 888     {
 889         DBG(LOG_VERBOSE, "Device is deactivated, no need to update UI.");
 890         // Add seperator...
 891         ugd->multi_button_sep_high_item = elm_genlist_item_append(ugd->genlist, &sep_itc, NULL, NULL,
 892                                                                                         ELM_GENLIST_ITEM_NONE, NULL, NULL);
 893         _create_about_genlist(ugd);
 894         return;
 895     }
 896
 897     res = wifi_direct_is_group_owner(&is_group_owner);
 898     if (res != WIFI_DIRECT_ERROR_NONE)
 899     {
 900         DBG(LOG_VERBOSE, "Fail to get group_owner_state. ret=[%d]", res);
 901         ugd->I_am_group_owner = FALSE;
 902         // continue...
 903     }
 904     else
 905     {
 906         ugd->I_am_group_owner = is_group_owner;
 907     }
 908
 909     __wfd_is_any_device_busy(ugd, &no_of_busy_dev);
 910     __wfd_is_any_device_available(ugd, &no_of_available_dev);
 911     __wfd_is_any_device_connect_failed(ugd, &no_of_conn_failed_dev);
 912     no_of_conn_dev = ugd->raw_connected_peer_cnt;
 913
 914     ugd->gl_available_peer_cnt = no_of_available_dev;
 915     ugd->gl_connected_peer_cnt = no_of_conn_dev;
 916     ugd->gl_connected_failed_peer_cnt = no_of_conn_failed_dev;
 917     ugd->gl_busy_peer_cnt = no_of_busy_dev;
 918
 919     DBG(LOG_VERBOSE, "conn_dev=[%d], conn_failed_dev=[%d], avail_dev=[%d], busy_dev=[%d], GO=[%d]\n",
 920                         no_of_conn_dev, no_of_conn_failed_dev, no_of_available_dev, no_of_busy_dev, is_group_owner);
 921
 922     if (no_of_conn_dev == 0 && no_of_conn_failed_dev == 0 &&
 923         no_of_available_dev == 0 && no_of_busy_dev == 0)
 924     {
 925         DBG(LOG_ERROR, "There are No peers\n");
 926         _create_no_device_genlist(ugd);
 927         _create_about_genlist(ugd);
 928         return;
 929     }
 930
 931     if (no_of_conn_dev > 0)
 932     {
 933         if (!ugd->conn_wfd_item)
 934                 _create_connected_dev_genlist(ugd);
 935
 936         count = 0;
 937         for(i = 0;  i < ugd->raw_connected_peer_cnt; i++)
 938         {
 939                 if (ugd->gl_connected_peers[count].gl_item)
 940                         elm_object_item_del(ugd->gl_connected_peers[count].gl_item);
 941
 942                 memcpy(&ugd->gl_connected_peers[count], &ugd->raw_connected_peers[i], sizeof(device_type_s));
 943
 944             ugd->gl_connected_peers[count].gl_item =
 945                         elm_genlist_item_append(ugd->genlist, &peer_conn_itc, (void*) &(ugd->gl_connected_peers[i]), NULL,
 946                                                                 ELM_GENLIST_ITEM_NONE, NULL, NULL);
 947             elm_genlist_item_select_mode_set(ugd->gl_connected_peers[count].gl_item, ELM_OBJECT_SELECT_MODE_DISPLAY_ONLY);
 948             count++;
 949         }
 950     }
 951
 952     if (ugd->multi_connect_mode != WFD_MULTI_CONNECT_MODE_NONE)
 953     {
 954         if (ugd->raw_multi_selected_peer_cnt > 0)
 955         {
 956                         if (ugd->avlbl_wfd_item == NULL)
 957                                 _create_multi_connect_dev_genlist(ugd);
 958
 959                         count = 0;
 960                         for (i = 0; i < ugd->raw_multi_selected_peer_cnt; i++)
 961                         {
 962                                 if (ugd->raw_multi_selected_peers[i].conn_status != PEER_CONN_STATUS_CONNECTED)
 963                                 {
 964                                         if (ugd->gl_multi_connect_peers[count].gl_item)
 965                                                 elm_object_item_del(ugd->gl_multi_connect_peers[count].gl_item);
 966
 967                                         memcpy(&ugd->gl_multi_connect_peers[count], &ugd->raw_multi_selected_peers[i], sizeof(device_type_s));
 968
 969                                         ugd->gl_multi_connect_peers[count].gl_item =
 970                                                         elm_genlist_item_append(ugd->genlist, &peer_itc, (void*) &(ugd->gl_multi_connect_peers[count]), NULL,
 971                                                                                 ELM_GENLIST_ITEM_NONE, NULL, NULL);
 972                                         count++;
 973                                 }
 974                                 else
 975                                 {
 976                                         // device is connected..
 977                                         // skip it...
 978                                 }
 979                         }
 980                         ugd->gl_multi_connect_peer_cnt = count;
 981         }
 982
 983         _create_multi_button_genlist(ugd);
 984     }
 985     else
 986     {
 987         // Note that
 988         // If GC, no display available peers
 989         // Otherwise, display available peers
 990 #if 0
 991                 if (no_of_available_dev > 0 && (no_of_conn_dev == 0 || is_group_owner==TRUE))
 992 #else
 993                 // display available peers
 994                 if (no_of_available_dev > 0)
 995 #endif
 996                 {
 997                         if (ugd->avlbl_wfd_item == NULL)
 998                                 _create_available_dev_genlist(ugd);
 999
1000                         count = 0;
1001                         for (i = 0; i < ugd->raw_discovered_peer_cnt; i++)
1002                         {
1003                                 if (!__wfd_is_device_busy(ugd, &ugd->raw_discovered_peers[i]) &&
1004                                         ugd->raw_discovered_peers[i].conn_status == PEER_CONN_STATUS_DISCONNECTED)
1005                                 {
1006                                         if (ugd->gl_available_peers[count].gl_item)
1007                                                 elm_object_item_del(ugd->gl_available_peers[count].gl_item);
1008
1009                                         memcpy(&ugd->gl_available_peers[count], &ugd->raw_discovered_peers[i], sizeof(device_type_s));
1010
1011                                         ugd->gl_available_peers[count].gl_item =
1012                                                         elm_genlist_item_append(ugd->genlist, &peer_itc, (void*) &(ugd->gl_available_peers[count]), NULL,
1013                                                                                 ELM_GENLIST_ITEM_NONE, _gl_peer_sel, (void*) &(ugd->gl_available_peers[count]));
1014                                         count++;
1015                                 }
1016                                 else
1017                                 {
1018                                         // device is busy or connected..
1019                                         // skip it...
1020                                 }
1021                         }
1022                 }
1023
1024                 _create_multi_button_genlist(ugd);
1025
1026                 // If connected, not display busy device...
1027                 if (no_of_conn_dev == 0 && no_of_busy_dev > 0)
1028                 {
1029                         if (ugd->busy_wfd_item == NULL)
1030                                 _create_busy_dev_list(ugd);
1031
1032                         count = 0;
1033                         for (i = 0; i < ugd->raw_discovered_peer_cnt; i++)
1034                         {
1035                                 if (__wfd_is_device_busy(ugd, &ugd->raw_discovered_peers[i]) == TRUE)
1036                                 {
1037                                         if (ugd->gl_busy_peers[count].gl_item)
1038                                                 elm_object_item_del(ugd->gl_busy_peers[count].gl_item);
1039
1040                                         memcpy(&ugd->gl_busy_peers[count], &ugd->raw_discovered_peers[i], sizeof(device_type_s));
1041
1042                                         ugd->gl_busy_peers[count].gl_item =
1043                                                         elm_genlist_item_append(ugd->genlist, &peer_busy_itc, (void*) &(ugd->gl_busy_peers[count]), NULL,
1044                                                                                 ELM_GENLIST_ITEM_NONE, _gl_busy_peer_sel, ugd);
1045                                         //elm_genlist_item_select_mode_set(ugd->gl_busy_peers[count].gl_item, ELM_OBJECT_SELECT_MODE_DISPLAY_ONLY);
1046                                         count++;
1047                                 }
1048                                 else
1049                                 {
1050                                         // device is available or connected..
1051                                         // skip it...
1052                                 }
1053                         }
1054                         ugd->busy_wfd_sep_item = elm_genlist_item_append(ugd->genlist, &sep_itc, NULL, NULL,
1055                                         ELM_GENLIST_ITEM_NONE, NULL, NULL);
1056                 }
1057
1058                 /* display connect failed peers */
1059                 if (no_of_conn_failed_dev > 0)
1060                 {
1061                         if (!ugd->conn_failed_wfd_item)
1062                                 _create_connected_failed_dev_genlist(ugd);
1063
1064                         /* add timer for disappearing failed peers after N secs */
1065                         if (NULL == ugd->display_timer) {
1066                                 ugd->last_display_time = time(NULL);
1067                                 ugd->display_timer = ecore_timer_add(5.0, (Ecore_Task_Cb)_connect_failed_peers_display_cb, ugd);
1068                         }
1069
1070                         count = 0;
1071                         for (i = 0; i < ugd->raw_discovered_peer_cnt; i++)
1072                         {
1073                                 if (!__wfd_is_device_busy(ugd, &ugd->raw_discovered_peers[i]) &&
1074                                         ugd->raw_discovered_peers[i].conn_status == PEER_CONN_STATUS_FAILED_TO_CONNECT)
1075                                 {
1076                                         if (ugd->gl_connected_failed_peers[count].gl_item)
1077                                                 elm_object_item_del(ugd->gl_connected_failed_peers[count].gl_item);
1078
1079                                         memcpy(&ugd->gl_connected_failed_peers[count], &ugd->raw_discovered_peers[i], sizeof(device_type_s));
1080
1081                                         ugd->gl_connected_failed_peers[count].gl_item =
1082                                                         elm_genlist_item_append(ugd->genlist, &peer_conn_failed_itc, (void*) &(ugd->gl_connected_failed_peers[count]), NULL,
1083                                                                                 ELM_GENLIST_ITEM_NONE, NULL, ugd);
1084                                         elm_genlist_item_select_mode_set(ugd->gl_connected_failed_peers[count].gl_item, ELM_OBJECT_SELECT_MODE_DISPLAY_ONLY);
1085                                         count++;
1086                                 }
1087                         }
1088
1089                         ugd->conn_failed_wfd_sep_item = elm_genlist_item_append(ugd->genlist, &sep_itc, NULL, NULL,
1090                                         ELM_GENLIST_ITEM_NONE, NULL, NULL);
1091
1092                 }
1093     }
1094     _create_about_genlist(ugd);
1095
1096     __FUNC_EXIT__;
1097 }
1098
1099
1100 void create_wfd_ug_view(void *data)
1101 {
1102     __FUNC_ENTER__;
1103
1104     struct ug_data *ugd = (struct ug_data*) data;
1105     Evas_Object *back_btn = NULL;
1106     Elm_Object_Item *navi_item = NULL;
1107     Evas_Object *control_bar = NULL;
1108     Elm_Object_Item *item = NULL;
1109
1110     if(ugd == NULL)
1111     {
1112         DBG(LOG_ERROR, "Incorrect parameter(NULL)");
1113         return;
1114     }
1115
1116     ugd->naviframe = elm_naviframe_add(ugd->base);
1117     elm_object_part_content_set(ugd->base, "elm.swallow.content", ugd->naviframe);
1118     evas_object_show(ugd->naviframe);
1119
1120     back_btn = elm_button_add(ugd->naviframe);
1121     elm_object_style_set(back_btn, "naviframe/back_btn/default");
1122     evas_object_smart_callback_add(back_btn, "clicked", _back_btn_cb, (void*) ugd);
1123     elm_object_focus_allow_set(back_btn, EINA_FALSE);
1124
1125
1126     ugd->genlist = _create_basic_genlist(ugd);
1127     if(ugd->genlist == NULL)
1128     {
1129         DBG(LOG_ERROR, "Failed to create basic genlist");
1130         return;
1131     }
1132     elm_object_style_set (ugd->genlist, "dialogue");
1133     evas_object_show(ugd->genlist);
1134     wfd_refresh_wifi_direct_state(ugd);
1135     if (ugd->wfd_status > WIFI_DIRECT_STATE_ACTIVATING)
1136         ugd->wfd_onoff = TRUE;
1137
1138     navi_item = elm_naviframe_item_push(ugd->naviframe, _("IDS_WFD_HEADER_WIFI_DIRECT"), back_btn, NULL, ugd->genlist, NULL); // dgettext("sys_string", "IDS_COM_OPT1_WI_FI_DIRECT")
1139
1140     control_bar = elm_toolbar_add(ugd->naviframe);
1141     elm_toolbar_shrink_mode_set(control_bar, ELM_TOOLBAR_SHRINK_EXPAND);
1142     evas_object_show(control_bar);
1143
1144     ugd->scan_btn = elm_toolbar_item_append(control_bar, NULL, _("IDS_WFD_BUTTON_SCAN"), _scan_btn_cb, (void*) ugd);
1145     item = elm_toolbar_item_append(control_bar, NULL, NULL, NULL, NULL);
1146     elm_object_item_disabled_set(item, EINA_TRUE);
1147
1148     elm_object_item_disabled_set(ugd->scan_btn, !ugd->wfd_onoff);
1149
1150     elm_object_item_part_content_set(navi_item, "controlbar", control_bar);
1151
1152     __FUNC_EXIT__;
1153 }