ui-gadget/viewer_manager.c

   1 /*
   2  * Wi-Fi
   3  *
   4  * Copyright 2012 Samsung Electronics Co., Ltd
   5  *
   6  * Licensed under the Flora License, Version 1.1 (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 #include <vconf.h>
  21 #include <vconf-keys.h>
  22 #include <ui-gadget.h>
  23 #include <app_control_internal.h>
  24 #include <efl_extension.h>
  25 #include <wifi-manager.h>
  26
  27 #include "common.h"
  28 #include "ug_wifi.h"
  29 #include "viewer_list.h"
  30 #include "i18nmanager.h"
  31 #include "common_utils.h"
  32 #include "winset_popup.h"
  33 #include "viewer_manager.h"
  34 #include "view_ime_hidden.h"
  35 #include "view_advanced.h"
  36 #include "view_detail.h"
  37
  38 typedef struct {
  39         wifi_manager_security_type_e sec_mode;
  40         char *ssid;
  41         wifi_device_info_t *device_info;
  42         Evas_Object *confirm_popup;
  43 } hidden_ap_data_t;
  44
  45 typedef struct viewer_manager_object {
  46         Evas_Object *nav;
  47         Elm_Object_Item *navi_it;
  48         Evas_Object *scan_button;
  49         Evas_Object *next_button;
  50         Evas_Object *prev_button;
  51         Evas_Object *list;
  52
  53         Evas_Object *sw_hidden_btn;
  54         Evas_Object *sw_scan_btn;
  55
  56         Elm_Object_Item *item_wifi_onoff;
  57         char *item_wifi_onoff_text;
  58
  59         Elm_Object_Item *item_onoff_description;
  60         char *item_onoff_description_text;
  61
  62         HEADER_MODES header_mode;
  63         Evas_Object *ctxpopup;
  64         bool is_first_time_no_profiles;
  65
  66         int sort_type;
  67         hidden_ap_data_t *hidden_popup_data;
  68 } viewer_manager_object;
  69
  70 typedef struct {
  71         Evas_Object *list;
  72         Elm_Object_Item *last_appended_item;
  73         int total_items_added;
  74 } view_manager_list_update_info_t;
  75
  76 static viewer_manager_object *manager_object = NULL;
  77
  78 extern wifi_appdata *ug_app_state;
  79
  80 static Elm_Genlist_Item_Class wifi_onoff_itc;
  81 static Elm_Genlist_Item_Class onoff_description_itc;
  82
  83 static GList *wifi_device_list = NULL;
  84 static Eina_Bool rotate_flag = EINA_FALSE;
  85
  86 static bool show_more = TRUE;
  87
  88 static wifi_emulator_sample_s wifi_samples[] = {
  89                 {"datanetwork", WIFI_MANAGER_SECURITY_TYPE_WPA_PSK, 1},
  90                 {"ureadyinternet", WIFI_MANAGER_SECURITY_TYPE_EAP, 0},
  91                 {"uready", WIFI_MANAGER_SECURITY_TYPE_EAP, 1},
  92                 {"setup", WIFI_MANAGER_SECURITY_TYPE_NONE, 0},
  93                 {"Tizen", WIFI_MANAGER_SECURITY_TYPE_WPA2_PSK, 1},
  94 };
  95 static int wifi_sample_count = sizeof(wifi_samples) / sizeof(wifi_samples[0]);
  96
  97 static void _hidden_button_callback(void* data, Evas_Object* obj, void* event_info);
  98 static void viewer_manager_hidden_confirm_cleanup(void);
  99
 100 extern genlist_info_t g_genlist_info[WIFI_GENLIST_STYLE_MAX];
 101 extern content_size_info_t g_content_size_info;
 102
 103 #ifdef MODEL_BUILD_FEATURE_WLAN_CONCURRENT_MODE
 104 static void _launch_wifi_direct_app(void)
 105 {
 106         int ret = APP_CONTROL_ERROR_NONE;
 107         app_control_h app_control;
 108
 109         app_control_create(&app_control);
 110         app_control_set_operation(app_control, APP_CONTROL_OPERATION_DEFAULT);
 111         app_control_set_launch_mode(app_control, APP_CONTROL_LAUNCH_MODE_GROUP);
 112         app_control_set_app_id(app_control, "ug-setting-wifidirect-efl");
 113
 114         ret = app_control_send_launch_request(app_control, NULL, NULL);
 115         if (ret == APP_CONTROL_ERROR_NONE)
 116                 INFO_LOG(UG_NAME_NORMAL, "Launch Wi-Fi Direct successful");
 117         else
 118                 ERROR_LOG(UG_NAME_NORMAL, "Fail to launch Wi-Fi Direct");
 119
 120         app_control_destroy(app_control);
 121 }
 122 #endif
 123
 124 static gboolean viewer_manager_is_passwd_popup_exists(void)
 125 {
 126         if (ug_app_state->passpopup != NULL)
 127                 return TRUE;
 128
 129         return FALSE;
 130 }
 131
 132 void language_changed_refresh()
 133 {
 134         if (UG_VIEW_SETUP_WIZARD == ug_app_state->ug_type) {
 135                 elm_genlist_realized_items_update(manager_object->list);
 136                 viewer_manager_refresh();
 137         }
 138 }
 139
 140 void viewer_manager_update_item_favorite_status(wifi_manager_ap_h ap)
 141 {
 142         if (ap == NULL)
 143                 return;
 144
 145         Elm_Object_Item *target_item = item_get_for_ap(ap);
 146         if (target_item == NULL)
 147                 return;
 148
 149         ug_genlist_data_t *gdata = NULL;
 150
 151         gdata = (ug_genlist_data_t *)elm_object_item_data_get(target_item);
 152         if (gdata == NULL || gdata->device_info == NULL) {
 153                 INFO_LOG(COMMON_NAME_ERR, "gdata or device_info is NULL");
 154                 return;
 155         }
 156
 157         gdata->radio_mode = VIEWER_ITEM_RADIO_MODE_OFF;
 158         if (gdata->device_info->ap_status_txt) {
 159                 g_free(gdata->device_info->ap_status_txt);
 160                 gdata->device_info->ap_status_txt =
 161                         common_utils_get_ap_security_type_info_txt(PACKAGE,
 162                                         gdata->device_info, false);
 163         }
 164
 165         if (target_item != NULL)
 166                 elm_genlist_item_update(target_item);
 167 }
 168
 169 void power_control(void)
 170 {
 171         __COMMON_FUNC_ENTER__;
 172
 173         int cur_state = -1;
 174         cur_state = viewer_manager_header_mode_get();
 175
 176         INFO_LOG(UG_NAME_NORMAL, "current state %d\n", cur_state);
 177
 178         int ret;
 179
 180         switch (cur_state) {
 181         case HEADER_MODE_OFF:
 182         case HEADER_MODE_ACTIVATING:
 183                 ug_app_state->is_first_scan = true;
 184                 ret = wlan_manager_power_on();
 185                 switch (ret) {
 186                 case WLAN_MANAGER_ERR_NONE:
 187                         viewer_manager_show(VIEWER_WINSET_SEARCHING);
 188                         viewer_manager_header_mode_set(HEADER_MODE_ACTIVATING);
 189                         viewer_manager_create_scan_btn();
 190
 191                         if (_is_emulator()) {
 192                                 wifi_emulator_create_event_timer(WIFI_EMUL_EVENT_TIMER_ACTIVATE,
 193                                                 1000, wlan_manager_emulator_power_on, NULL);
 194                         }
 195                         break;
 196
 197 #if defined TIZEN_TETHERING_ENABLE
 198                 case WLAN_MANAGER_ERR_WIFI_TETHERING_OCCUPIED:
 199                         winset_popup_mode_set(ug_app_state->popup_manager,
 200                                         POPUP_OPTION_POWER_ON_FAILED_TETHERING_OCCUPIED, NULL);
 201                         break;
 202
 203                 case WLAN_MANAGER_ERR_WIFI_AP_TETHERING_OCCUPIED:
 204                         winset_popup_mode_set(ug_app_state->popup_manager,
 205                                         POPUP_OPTION_POWER_ON_FAILED_TETHERING_AP_OCCUPIED, NULL);
 206                         break;
 207 #endif
 208
 209                 default:
 210                         viewer_manager_header_mode_set(HEADER_MODE_OFF);
 211                         INFO_LOG(UG_NAME_NORMAL, "power on failed. ret = %d", ret);
 212                         break;
 213                 }
 214
 215                 break;
 216
 217         case HEADER_MODE_ON:
 218         case HEADER_MODE_CONNECTING:
 219         case HEADER_MODE_CONNECTED:
 220         case HEADER_MODE_SEARCHING:
 221                 ret = wlan_manager_power_off();
 222                 switch (ret) {
 223                 case WLAN_MANAGER_ERR_NONE:
 224                         viewer_manager_show(VIEWER_WINSET_SEARCHING);
 225                         viewer_manager_header_mode_set(HEADER_MODE_DEACTIVATING);
 226
 227                         // Lets ignore all the scan updates because we are powering off now.
 228                         wlan_manager_disable_scan_result_update();
 229                         if (_is_emulator()) {
 230                                 wifi_emulator_create_event_timer(WIFI_EMUL_EVENT_TIMER_DEACTIVATE,
 231                                                 500, wlan_manager_emulator_power_off, NULL);
 232                         }
 233                         break;
 234
 235                 default:
 236                         INFO_LOG(UG_NAME_NORMAL, "power off failed. ret = %d", ret);
 237                         break;
 238                 }
 239
 240                 break;
 241
 242         case HEADER_MODE_DEACTIVATING:
 243         default:
 244                 INFO_LOG(UG_NAME_NORMAL, "Powering off in progress. Let it complete. \n");
 245                 break;
 246         }
 247
 248         __COMMON_FUNC_EXIT__;
 249 }
 250
 251 static void _transition_finished_main_cb(void *data, Evas_Object *obj, void *event_info)
 252 {
 253         __COMMON_FUNC_ENTER__;
 254
 255         view_manager_view_type_t top_view_id;
 256
 257         top_view_id = (view_manager_view_type_t)evas_object_data_get(
 258                                 obj, SCREEN_TYPE_ID_KEY);
 259
 260         if (data == elm_naviframe_top_item_get(obj)) {
 261                 /* We are now in main view */
 262                 if (viewer_manager_is_passwd_popup_exists() == TRUE) {
 263                         top_view_id = VIEW_MANAGER_VIEW_TYPE_PASSWD_POPUP;
 264                 } else {
 265                         top_view_id = VIEW_MANAGER_VIEW_TYPE_MAIN;
 266                         if (wifi_is_scan_required() == true)
 267                                 viewer_manager_request_scan();
 268                 }
 269                 evas_object_data_set(obj, SCREEN_TYPE_ID_KEY,
 270                                 (void *)VIEW_MANAGER_VIEW_TYPE_MAIN);
 271
 272                 viewer_manager_rotate_top_setupwizard_layout();
 273         }
 274
 275         INFO_LOG(UG_NAME_NORMAL, "top view id = %d", top_view_id);
 276
 277         switch (top_view_id) {
 278         case VIEW_MANAGER_VIEW_TYPE_MAIN:
 279                 /* Lets enable the scan updates */
 280                 wlan_manager_enable_scan_result_update();
 281                 break;
 282
 283         case VIEW_MANAGER_VIEW_TYPE_DETAIL:
 284         case VIEW_MANAGER_VIEW_TYPE_EAP:
 285         case VIEW_MANAGER_VIEW_TYPE_PASSWD_POPUP:
 286         default:
 287                 /* Lets disable the scan updates so that the UI is not refreshed */
 288                 wlan_manager_disable_scan_result_update();
 289                 if (top_view_id == VIEW_MANAGER_VIEW_TYPE_PASSWD_POPUP)
 290                         passwd_popup_show(ug_app_state->passpopup);
 291                 break;
 292         }
 293
 294         __COMMON_FUNC_EXIT__;
 295 }
 296
 297 static void _lbutton_click_cb(void *data, Evas_Object *obj, void *event_info)
 298 {
 299         __COMMON_FUNC_ENTER__;
 300
 301         app_control_h app_control;
 302         int ret;
 303
 304         ret = app_control_create(&app_control);
 305         if (ret != APP_CONTROL_ERROR_NONE) {
 306                 INFO_LOG(UG_NAME_ERR, "app_control_create failed: %d", ret);
 307                 return;
 308         }
 309
 310         app_control_add_extra_data(app_control, "result", "lbutton_click");
 311         ug_send_result(ug_app_state->ug, app_control);
 312
 313         app_control_destroy(app_control);
 314         ug_destroy_me(ug_app_state->ug);
 315
 316         __COMMON_FUNC_EXIT__;
 317 }
 318
 319 static void _rbutton_click_cb(void *data, Evas_Object *obj, void *event_info)
 320 {
 321         __COMMON_FUNC_ENTER__;
 322
 323         app_control_h app_control;
 324         int ret;
 325
 326         ret = app_control_create(&app_control);
 327         if (ret != APP_CONTROL_ERROR_NONE) {
 328                 INFO_LOG(UG_NAME_ERR, "app_control_create failed: %d", ret);
 329                 return;
 330         }
 331
 332         app_control_add_extra_data(app_control, "result", "rbutton_click");
 333         ug_send_result(ug_app_state->ug, app_control);
 334
 335         app_control_destroy(app_control);
 336         ug_destroy_me(ug_app_state->ug);
 337
 338         __COMMON_FUNC_EXIT__;
 339 }
 340
 341 static void __back_cb(void *data, Evas_Object *obj, void *event_info)
 342 {
 343         __COMMON_FUNC_ENTER__;
 344
 345         if ((view_manager_view_type_t)evas_object_data_get(obj, SCREEN_TYPE_ID_KEY) !=
 346                         VIEW_MANAGER_VIEW_TYPE_MAIN) {
 347                 eext_naviframe_back_cb(data, obj, event_info);
 348                 __COMMON_FUNC_EXIT__;
 349                 return;
 350         }
 351
 352         if (viewer_manager_is_passwd_popup_exists() == TRUE ||
 353                         ug_app_state->bAlive == EINA_FALSE) {
 354                 __COMMON_FUNC_EXIT__;
 355                 return;
 356         }
 357
 358         wifi_exit();
 359
 360         __COMMON_FUNC_EXIT__;
 361 }
 362
 363 static Eina_Bool _back_sk_cb(void *data, Elm_Object_Item *it)
 364 {
 365         __COMMON_FUNC_ENTER__;
 366
 367         if (ug_app_state->bAlive == EINA_FALSE) {
 368                 __COMMON_FUNC_EXIT__;
 369                 return EINA_TRUE;
 370         }
 371
 372         wifi_exit();
 373
 374         __COMMON_FUNC_EXIT__;
 375         return EINA_FALSE;
 376 }
 377
 378 #ifdef MODEL_BUILD_FEATURE_WLAN_CONCURRENT_MODE
 379 static gboolean __activate_more_btn(gpointer pdata)
 380 {
 381         show_more = TRUE;
 382
 383         if (ug_app_state->timeout) {
 384                 g_source_remove(ug_app_state->timeout);
 385                 ug_app_state->timeout = 0;
 386         }
 387
 388         return FALSE;
 389 }
 390 #endif
 391
 392 static void _ctxpopup_item_select_cb(void *data, Evas_Object *obj,
 393                 void *event_info)
 394 {
 395         const char *label = elm_object_item_text_get((Elm_Object_Item *) event_info);
 396         if (label)
 397                 SECURE_INFO_LOG(UG_NAME_NORMAL, "text(%s) is clicked\n", label);
 398
 399         if (g_strcmp0(label, sc(PACKAGE, I18N_TYPE_Advanced)) == 0)
 400                 view_advanced();
 401         else if (g_strcmp0(label, sc(PACKAGE, I18N_TYPE_Find_Hidden_Network)) == 0)
 402                 _hidden_button_callback(data, obj, event_info);
 403
 404 #ifdef MODEL_BUILD_FEATURE_WLAN_CONCURRENT_MODE
 405         else if (g_strcmp0(label, sc(PACKAGE, I18N_TYPE_WiFi_direct)) == 0) {
 406                 show_more = FALSE;
 407                 ug_app_state->timeout = g_timeout_add(300, __activate_more_btn, NULL);
 408                 _launch_wifi_direct_app();
 409         }
 410 #endif
 411
 412         if (manager_object->ctxpopup) {
 413                 evas_object_del(manager_object->ctxpopup);
 414                 manager_object->ctxpopup = NULL;
 415         }
 416 }
 417
 418 static void _ctxpopup_del_cb(void *data,
 419                  Evas_Object *obj, void *event_info)
 420 {
 421         __COMMON_FUNC_ENTER__;
 422
 423         if (!manager_object)
 424                 return;
 425
 426         evas_object_del(manager_object->ctxpopup);
 427         manager_object->ctxpopup = NULL;
 428
 429         __COMMON_FUNC_EXIT__;
 430 }
 431
 432 static void _ctxpopup_move(Evas_Object *parent)
 433 {
 434         __COMMON_FUNC_ENTER__;
 435
 436         if (!manager_object)
 437                 return;
 438
 439         Evas_Coord y = 0, w = 0, h = 0;
 440         int rotate_angle;
 441
 442         elm_win_screen_size_get(parent, NULL, &y, &w, &h);
 443         rotate_angle = elm_win_rotation_get(parent);
 444
 445         if (0 == rotate_angle || 180 == rotate_angle)
 446                 evas_object_move(manager_object->ctxpopup, w/2, h);
 447         else
 448                 evas_object_move(manager_object->ctxpopup, h/2, w);
 449
 450         __COMMON_FUNC_EXIT__;
 451 }
 452
 453 static void _ctxpopup_move_to_button(Evas_Object *ctxpopup, Evas_Object *btn)
 454 {
 455         Evas_Coord x, y, w, h;
 456         evas_object_geometry_get(btn, &x, &y, &w, &h);
 457         evas_object_move(ctxpopup, x + (w / 2), y + h);
 458 }
 459
 460 static void _ctxpopup_dismissed_cb(void *data, Evas_Object *obj,
 461                 void *event_info)
 462 {
 463         __COMMON_FUNC_ENTER__;
 464
 465         if (!manager_object)
 466                 return;
 467
 468         Evas_Object *_win_main = data;
 469
 470         if (!rotate_flag) {
 471                 evas_object_del(manager_object->ctxpopup);
 472                 manager_object->ctxpopup = NULL;
 473         } else {
 474                 _ctxpopup_move(_win_main);
 475                 evas_object_show(manager_object->ctxpopup);
 476                 rotate_flag = EINA_FALSE;
 477         }
 478
 479         __COMMON_FUNC_EXIT__;
 480 }
 481
 482 static void _ctxpopup_rotate_cb(void *data, Evas_Object *obj, void *event_info)
 483 {
 484
 485         __COMMON_FUNC_ENTER__;
 486
 487         if (!manager_object)
 488                 return;
 489
 490         Evas_Object *_win_main = data;
 491
 492         _ctxpopup_move(_win_main);
 493         evas_object_show(manager_object->ctxpopup);
 494
 495         __COMMON_FUNC_EXIT__;
 496 }
 497
 498 static void _ctxpopup_resize_cb(void *data, Evas *e, Evas_Object *obj,
 499                 void *event_info)
 500 {
 501         __COMMON_FUNC_ENTER__;
 502
 503         if (manager_object->ctxpopup)
 504                 rotate_flag = EINA_TRUE;
 505         else
 506                 rotate_flag = EINA_FALSE;
 507
 508         __COMMON_FUNC_EXIT__;
 509 }
 510
 511 static void _ctxpopup_delete_cb(void *data, Evas *e, Evas_Object *obj,
 512                 void *event_info)
 513 {
 514         __COMMON_FUNC_ENTER__;
 515
 516         Evas_Object *navi = (Evas_Object *)data;
 517         Evas_Object *ctx = obj;
 518
 519         if (navi == NULL)
 520                 return;
 521
 522         if (ctx == NULL)
 523                 return;
 524
 525         evas_object_smart_callback_del(ctx, "dismissed",
 526                         _ctxpopup_dismissed_cb);
 527         evas_object_event_callback_del(navi, EVAS_CALLBACK_RESIZE,
 528                         _ctxpopup_resize_cb);
 529         evas_object_smart_callback_del(elm_object_top_widget_get(ctx),
 530                         "rotation,changed", _ctxpopup_rotate_cb);
 531         evas_object_event_callback_del_full(ctx, EVAS_CALLBACK_DEL,
 532                         _ctxpopup_delete_cb, navi);
 533
 534         __COMMON_FUNC_EXIT__;
 535
 536 }
 537
 538 static void _more_button_cb(void *data, Evas_Object *obj, void *event_info)
 539 {
 540         Evas_Object *_win_main = (Evas_Object*)data;
 541         HEADER_MODES current_state;
 542         struct ug_data *ugd = NULL;
 543         Evas_Object *parent = NULL;
 544         Elm_Object_Item *item = NULL;
 545         int ps_mode = 0;
 546
 547         ugd = (struct ug_data *)ug_app_state->gadget;
 548         retm_if(ugd == NULL || show_more == FALSE);
 549
 550         parent = ugd->win_main;
 551         if (!parent || !manager_object)
 552                 return;
 553
 554         current_state = viewer_manager_header_mode_get();
 555
 556         if (manager_object->ctxpopup)
 557                 evas_object_del(manager_object->ctxpopup);
 558
 559         ps_mode = common_util_get_system_registry(VCONFKEY_SETAPPL_PSMODE);
 560         INFO_LOG(UG_NAME_NORMAL, "PS mode - [%d]", ps_mode);
 561
 562         manager_object->ctxpopup = elm_ctxpopup_add(parent);
 563         elm_ctxpopup_auto_hide_disabled_set(manager_object->ctxpopup, EINA_TRUE);
 564         elm_object_style_set(manager_object->ctxpopup, "more/default");
 565         eext_object_event_callback_add(manager_object->ctxpopup, EEXT_CALLBACK_BACK,
 566                         _ctxpopup_del_cb, NULL);
 567         eext_object_event_callback_add(manager_object->ctxpopup, EEXT_CALLBACK_MORE,
 568                         _ctxpopup_del_cb, NULL);
 569         evas_object_smart_callback_add(manager_object->ctxpopup, "dismissed",
 570                         _ctxpopup_dismissed_cb, _win_main);
 571         evas_object_event_callback_add(manager_object->ctxpopup, EVAS_CALLBACK_DEL,
 572                         _ctxpopup_delete_cb, parent);
 573         evas_object_event_callback_add(parent, EVAS_CALLBACK_RESIZE,
 574                         _ctxpopup_resize_cb, _win_main);
 575         evas_object_smart_callback_add(elm_object_top_widget_get(manager_object->ctxpopup),
 576                         "rotation,changed", _ctxpopup_rotate_cb, _win_main);
 577
 578         if (current_state != HEADER_MODE_OFF &&
 579                         current_state != HEADER_MODE_DEACTIVATING) {
 580                 item = elm_ctxpopup_item_append(manager_object->ctxpopup,
 581                                 "IDS_WIFI_BUTTON_FIND_HIDDEN_NETWORK", NULL,
 582                                 _ctxpopup_item_select_cb, parent);
 583                 elm_object_item_domain_text_translatable_set(item, PACKAGE, EINA_TRUE);
 584         }
 585
 586         item = elm_ctxpopup_item_append(manager_object->ctxpopup,
 587                         "IDS_ST_BODY_ADVANCED", NULL,
 588                         _ctxpopup_item_select_cb, parent);
 589         elm_object_item_domain_text_translatable_set(item, PACKAGE, EINA_TRUE);
 590
 591 #ifdef MODEL_BUILD_FEATURE_WLAN_CONCURRENT_MODE
 592         if (ps_mode <= SETTING_PSMODE_POWERFUL &&
 593                         current_state != HEADER_MODE_OFF &&
 594                         current_state != HEADER_MODE_DEACTIVATING) {
 595                 item = elm_ctxpopup_item_append(manager_object->ctxpopup,
 596                                 "IDS_WIFI_BODY_WI_FI_DIRECT_ABB", NULL,
 597                                 _ctxpopup_item_select_cb, parent);
 598                 elm_object_item_domain_text_translatable_set(item, PACKAGE, EINA_TRUE);
 599         }
 600 #endif
 601
 602         elm_ctxpopup_direction_priority_set(manager_object->ctxpopup,
 603                         ELM_CTXPOPUP_DIRECTION_UP, ELM_CTXPOPUP_DIRECTION_UNKNOWN,
 604                         ELM_CTXPOPUP_DIRECTION_UNKNOWN, ELM_CTXPOPUP_DIRECTION_UNKNOWN);
 605
 606         if (wifi_get_ug_type() == UG_VIEW_IOT_COMMON)
 607                 _ctxpopup_move_to_button(manager_object->ctxpopup, obj);
 608         else
 609                 _ctxpopup_move(_win_main);
 610
 611         evas_object_show(manager_object->ctxpopup);
 612 }
 613
 614 static void __refresh_scan_callback(void *data,
 615                 Evas_Object *obj, void *event_info)
 616 {
 617         __COMMON_FUNC_ENTER__;
 618
 619         int scan_result;
 620         HEADER_MODES current_state;
 621         current_state = viewer_manager_header_mode_get();
 622
 623         switch (current_state) {
 624         case HEADER_MODE_ON:
 625         case HEADER_MODE_CONNECTED:
 626                 viewer_manager_show(VIEWER_WINSET_SEARCHING);
 627                 viewer_manager_header_mode_set(HEADER_MODE_SEARCHING);
 628
 629                 scan_result = wlan_manager_scan();
 630                 if (scan_result != WLAN_MANAGER_ERR_NONE) {
 631                         viewer_manager_hide(VIEWER_WINSET_SEARCHING);
 632                         viewer_manager_header_mode_set(current_state);
 633                 }
 634                 break;
 635
 636         default:
 637                 break;
 638         }
 639
 640         __COMMON_FUNC_EXIT__;
 641 }
 642
 643 static void __power_onoff_cb(void *data, Evas_Object *obj, void *event_info)
 644 {
 645         __COMMON_FUNC_ENTER__;
 646
 647         Elm_Object_Item *item = NULL;
 648         const char *object_type;
 649         HEADER_MODES current_mode;
 650
 651         item = (Elm_Object_Item *)event_info;
 652         object_type = evas_object_type_get(obj);
 653
 654         current_mode = viewer_manager_header_mode_get();
 655         ug_app_state->is_wifi_scan_indication_block = 0;
 656
 657         if (current_mode == HEADER_MODE_ACTIVATING ||
 658                         current_mode == HEADER_MODE_DEACTIVATING) {
 659                 if (g_strcmp0(object_type, "elm_genlist") == 0)
 660                         elm_genlist_item_selected_set(item, EINA_FALSE);
 661
 662                 __COMMON_FUNC_EXIT__;
 663                 return;
 664         }
 665
 666         if (g_strcmp0(object_type, "elm_check") == 0) {
 667                 Eina_Bool check_mode = elm_check_state_get(obj);
 668
 669                 if (check_mode == TRUE && current_mode == HEADER_MODE_OFF) {
 670                         elm_check_state_set(obj, EINA_FALSE);
 671                         power_control();
 672                 } else if (check_mode != TRUE && current_mode != HEADER_MODE_OFF) {
 673                         power_control();
 674                 }
 675         } else if (g_strcmp0(object_type, "elm_genlist") == 0) {
 676                 power_control();
 677         }
 678
 679         if (item != NULL) {
 680                 elm_genlist_item_update(item);
 681                 elm_genlist_item_selected_set(item, EINA_FALSE);
 682         }
 683
 684         __COMMON_FUNC_EXIT__;
 685 }
 686
 687 static char *_gl_wifi_onoff_text_get(void *data, Evas_Object *obj, const char *part)
 688 {
 689         char *det = NULL;
 690         int ug_type = GPOINTER_TO_INT(data);
 691
 692         retvm_if(NULL == manager_object, NULL);
 693
 694         if (!strcmp(g_genlist_info[WIFI_GENLIST_1LINE_STYLE].text_part, part)) {
 695                 if (ug_type == UG_VIEW_OOBE) {
 696                         det = g_strdup_printf("<font_size=%d>%s</font_size>",
 697                                         g_content_size_info.mid_font,
 698                                         manager_object->header_mode == HEADER_MODE_SEARCHING ?
 699                                                 sc(PACKAGE, I18N_TYPE_Scanning) :
 700                                                 manager_object->item_wifi_onoff_text);
 701                 } else {
 702                         det = g_strdup(manager_object->item_wifi_onoff_text);
 703                 }
 704         }
 705
 706         return det;
 707 }
 708
 709 static char *_gl_helper_text_get(void *data, Evas_Object *obj, const char *part)
 710 {
 711         char* det = NULL;
 712
 713         retvm_if(NULL == manager_object, NULL);
 714
 715         if (!strcmp(g_genlist_info[WIFI_GENLIST_MULTILINE_STYLE].sub_text_part, part)) {
 716                 det = g_strdup(manager_object->item_onoff_description_text);
 717                 assertm_if(NULL == det, "NULL!!");
 718         }
 719
 720         return det;
 721 }
 722
 723 static Evas_Object* _gl_helper_content_get(void *data, Evas_Object *obj, const char *part)
 724 {
 725         retvm_if(NULL == manager_object, NULL);
 726
 727         Evas_Object *box, *top_padding, *label;
 728         char* det = g_strdup_printf("<align=center><font_size=%d>%s</font_size></align>",
 729                         g_content_size_info.big_font,
 730                         manager_object->item_onoff_description_text);
 731
 732         assertm_if(NULL == det, "NULL!!");
 733
 734         box = elm_box_add(obj);
 735         elm_box_horizontal_set(box, EINA_FALSE);
 736
 737         top_padding = evas_object_rectangle_add(evas_object_evas_get(obj));
 738         evas_object_size_hint_min_set(top_padding, ELM_SCALE_SIZE(40), ELM_SCALE_SIZE(50));
 739         evas_object_size_hint_max_set(top_padding, ELM_SCALE_SIZE(40), ELM_SCALE_SIZE(50));
 740         evas_object_color_set(top_padding, 0, 0, 0, 0);
 741         evas_object_show(top_padding);
 742         elm_box_pack_end(box, top_padding);
 743
 744         label = elm_label_add(box);
 745         elm_object_text_set(label, det);
 746         evas_object_show(label);
 747         elm_box_pack_end(box, label);
 748
 749         return box;
 750 }
 751
 752 static Evas_Object *_gl_wifi_onoff_content_get(void *data,
 753                 Evas_Object *obj, const char *part)
 754 {
 755         if (manager_object == NULL)
 756                 return NULL;
 757
 758         Evas_Object *c = NULL;
 759         int ug_type = GPOINTER_TO_INT(data);
 760         const char *style;
 761         const char *content_part = (ug_type == UG_VIEW_IOT_COMMON)
 762                 ? g_genlist_info[WIFI_GENLIST_1LINE_STYLE].content_part
 763                 : g_genlist_info[WIFI_GENLIST_1LINE_STYLE].sub_content_part;
 764
 765         // On&Off toggle button
 766         if (!strcmp(content_part, part)) {
 767                 if (ug_type == UG_VIEW_OOBE)
 768                         style = "onoff";
 769                 else
 770                         style = "on&off";
 771
 772                 c = elm_check_add(obj);
 773                 elm_object_style_set(c, style);
 774                 evas_object_propagate_events_set(c, EINA_FALSE);
 775                 evas_object_smart_callback_add(c, "changed", __power_onoff_cb, NULL);
 776
 777                 if (manager_object->header_mode == HEADER_MODE_OFF
 778                                 || manager_object->header_mode == HEADER_MODE_DEACTIVATING)
 779                         elm_check_state_set(c, EINA_FALSE);
 780                 else
 781                         elm_check_state_set(c, EINA_TRUE);
 782
 783                 evas_object_size_hint_align_set(c, EVAS_HINT_FILL, EVAS_HINT_FILL);
 784                 evas_object_size_hint_weight_set(c, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
 785         }
 786
 787         // OOBE: Progress icon
 788         if (ug_type == UG_VIEW_OOBE
 789                         && !strcmp(g_genlist_info[WIFI_GENLIST_1LINE_STYLE].content_part, part)) {
 790                 if (manager_object->header_mode == HEADER_MODE_SEARCHING) {
 791                         c = elm_progressbar_add(obj);
 792                         elm_object_style_set(c, "process_small");
 793                         evas_object_size_hint_align_set(c, EVAS_HINT_FILL, 0.5);
 794                         evas_object_size_hint_weight_set(c,
 795                                         EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
 796                         elm_progressbar_pulse(c, TRUE);
 797                         evas_object_show(c);
 798                 }
 799         }
 800
 801         // OOBE: Scan button
 802         if (ug_type == UG_VIEW_OOBE && !strcmp("elm.swallow.icon.2", part)) {
 803                 c = elm_button_add(obj);
 804                 elm_object_style_set(c, "scan");
 805                 evas_object_size_hint_align_set(c, EVAS_HINT_FILL, EVAS_HINT_FILL);
 806                 evas_object_size_hint_weight_set(c, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
 807                 elm_object_domain_translatable_text_set(c, PACKAGE, "IDS_WIFI_BUTTON_SCAN");
 808                 evas_object_smart_callback_add(c, "clicked", __refresh_scan_callback, NULL);
 809
 810                 if (manager_object->header_mode == HEADER_MODE_SEARCHING)
 811                         elm_object_disabled_set(c, EINA_TRUE);
 812                 else
 813                         elm_object_disabled_set(c, EINA_FALSE);
 814         }
 815
 816         return c;
 817 }
 818
 819 static void __viewer_manager_wifi_onoff_item_create(Evas_Object* genlist, int ug_type)
 820 {
 821         __COMMON_FUNC_ENTER__;
 822
 823         manager_object->item_wifi_onoff_text = g_strdup(sc(PACKAGE, I18N_TYPE_Wi_Fi));
 824
 825         wifi_onoff_itc.item_style = g_genlist_info[WIFI_GENLIST_1LINE_STYLE].style_name;
 826         wifi_onoff_itc.func.text_get = _gl_wifi_onoff_text_get;
 827         wifi_onoff_itc.func.content_get = _gl_wifi_onoff_content_get;
 828         wifi_onoff_itc.func.state_get = NULL;
 829         wifi_onoff_itc.func.del = NULL;
 830
 831         manager_object->item_wifi_onoff = elm_genlist_item_append(genlist,
 832                         &wifi_onoff_itc, GINT_TO_POINTER(ug_type), NULL, ELM_GENLIST_ITEM_NONE,
 833                         NULL, NULL);
 834
 835         elm_genlist_item_select_mode_set(manager_object->item_wifi_onoff, ELM_OBJECT_SELECT_MODE_NONE);
 836         __COMMON_FUNC_EXIT__;
 837 }
 838
 839 static void __viewer_manager_onoff_description_item_create(void)
 840 {
 841         __COMMON_FUNC_ENTER__;
 842
 843         manager_object->item_onoff_description_text = g_strdup(sc(PACKAGE,
 844                                 I18N_TYPE_Turn_on_wifi_to_view_available_networks));
 845
 846         if (wifi_get_ug_type() != UG_VIEW_IOT_COMMON) {
 847                 onoff_description_itc.item_style = g_genlist_info[WIFI_GENLIST_MULTILINE_STYLE].style_name;
 848                 onoff_description_itc.func.text_get = _gl_helper_text_get;
 849                 onoff_description_itc.func.content_get = NULL;
 850         } else {
 851                 onoff_description_itc.item_style = g_genlist_info[WIFI_GENLIST_FULL_STYLE].style_name;
 852                 onoff_description_itc.func.text_get = NULL;
 853                 onoff_description_itc.func.content_get = _gl_helper_content_get;
 854         }
 855
 856         onoff_description_itc.func.state_get = NULL;
 857         onoff_description_itc.func.del = NULL;
 858
 859         __COMMON_FUNC_EXIT__;
 860 }
 861
 862 static void viewer_manager_onoff_description_item_set(bool state)
 863 {
 864         __COMMON_FUNC_ENTER__;
 865
 866         if (manager_object == NULL) {
 867                 __COMMON_FUNC_EXIT__;
 868                 return;
 869         }
 870
 871         if (state && manager_object->item_onoff_description == NULL) {
 872                 manager_object->item_onoff_description = elm_genlist_item_append(manager_object->list,
 873                         &onoff_description_itc, NULL, NULL, ELM_GENLIST_ITEM_NONE,
 874                         NULL, NULL);
 875         } else if (!state && manager_object->item_onoff_description != NULL) {
 876                 elm_object_item_del(manager_object->item_onoff_description);
 877                 manager_object->item_onoff_description = NULL;
 878         }
 879
 880         __COMMON_FUNC_EXIT__;
 881 }
 882
 883 static void _hidden_button_callback(void* data, Evas_Object* obj, void* event_info)
 884 {
 885         __COMMON_FUNC_ENTER__;
 886
 887         view_hidden_ap_popup_create(ug_app_state->layout_main, PACKAGE);
 888
 889         __COMMON_FUNC_EXIT__;
 890 }
 891
 892 static void __viewer_manager_hidden_button_create(Evas_Object *genlist)
 893 {
 894         __COMMON_FUNC_ENTER__;
 895
 896         if (manager_object->sw_hidden_btn != NULL ||
 897                         ug_app_state->ug_type != UG_VIEW_SETUP_WIZARD) {
 898                 __COMMON_FUNC_EXIT__;
 899                 return;
 900         }
 901
 902         Evas_Object *btn = NULL;
 903         Evas_Object *layout = NULL;
 904         Elm_Object_Item *navi_it = NULL;
 905
 906         navi_it = elm_naviframe_top_item_get(manager_object->nav);
 907         layout = elm_object_item_content_get(navi_it);
 908
 909         btn = elm_button_add(layout);
 910         elm_object_style_set(btn, "default");
 911         evas_object_propagate_events_set(btn, EINA_FALSE);
 912
 913         evas_object_smart_callback_add(btn, "clicked", _hidden_button_callback,
 914                         NULL);
 915         elm_object_domain_translatable_text_set(btn, PACKAGE,
 916                         "IDS_WIFI_BUTTON_FIND_HIDDEN_NETWORK");
 917         elm_object_part_content_set(layout, "button1", btn);
 918
 919         switch (viewer_manager_header_mode_get()) {
 920         case HEADER_MODE_ACTIVATING:
 921         case HEADER_MODE_DEACTIVATING:
 922         case HEADER_MODE_SEARCHING:
 923                 elm_object_disabled_set(btn, EINA_TRUE);
 924                 break;
 925         default:
 926                 elm_object_disabled_set(btn, EINA_FALSE);
 927                 break;
 928         }
 929
 930         evas_object_show(btn);
 931         manager_object->sw_hidden_btn = btn;
 932
 933         __COMMON_FUNC_EXIT__;
 934 }
 935
 936
 937 static void __viewer_manager_setup_wizard_scan_btn_create(Evas_Object *genlist)
 938 {
 939         __COMMON_FUNC_ENTER__;
 940
 941         if (manager_object->sw_scan_btn != NULL ||
 942                         ug_app_state->ug_type != UG_VIEW_SETUP_WIZARD) {
 943                 __COMMON_FUNC_EXIT__;
 944                 return;
 945         }
 946
 947         Evas_Object *btn = NULL;
 948         Evas_Object *layout = NULL;
 949         Elm_Object_Item *navi_it = NULL;
 950
 951         navi_it = elm_naviframe_top_item_get(manager_object->nav);
 952         layout = elm_object_item_content_get(navi_it);
 953
 954         btn = elm_button_add(layout);
 955         elm_object_style_set(btn, "default");
 956         evas_object_propagate_events_set(btn, EINA_FALSE);
 957
 958         evas_object_smart_callback_add(btn, "clicked", __refresh_scan_callback,
 959                         NULL);
 960         elm_object_domain_translatable_text_set(btn, PACKAGE,
 961                         "IDS_WIFI_BUTTON_SCAN");
 962         elm_object_part_content_set(layout, "button2", btn);
 963
 964         switch (viewer_manager_header_mode_get()) {
 965         case HEADER_MODE_ACTIVATING:
 966         case HEADER_MODE_DEACTIVATING:
 967         case HEADER_MODE_SEARCHING:
 968                 elm_object_disabled_set(btn, EINA_TRUE);
 969                 break;
 970         default:
 971                 elm_object_disabled_set(btn, EINA_FALSE);
 972                 break;
 973         }
 974
 975         evas_object_show(btn);
 976         manager_object->sw_scan_btn = btn;
 977
 978         __COMMON_FUNC_EXIT__;
 979 }
 980
 981 static void viewer_manager_setup_wizard_scan_btn_set(Eina_Bool show_state)
 982 {
 983         __COMMON_FUNC_ENTER__;
 984
 985         if (ug_app_state->ug_type != UG_VIEW_SETUP_WIZARD ||
 986                         manager_object == NULL ||
 987                         manager_object->sw_scan_btn == NULL) {
 988                 __COMMON_FUNC_EXIT__;
 989                 return;
 990         }
 991
 992         elm_object_disabled_set(manager_object->sw_scan_btn, !show_state);
 993
 994         __COMMON_FUNC_EXIT__;
 995 }
 996
 997 static Eina_Bool viewer_manager_scan_button_set(Eina_Bool show_state)
 998 {
 999         __COMMON_FUNC_ENTER__;
1000
1001         if (manager_object == NULL) {
1002                 __COMMON_FUNC_EXIT__;
1003                 return EINA_FALSE;
1004         }
1005
1006         if (manager_object->scan_button == NULL)
1007                 viewer_manager_create_scan_btn();
1008
1009         /* TODO: need to check VIEW_MANAGER_VIEW_TYPE_MAIN ?
1010          * Evas_Object* navi_frame = viewer_manager_get_naviframe();
1011          * view_manager_view_type_t top_view_id =
1012          *                      (view_manager_view_type_t)evas_object_data_get(
1013          *                              navi_frame, SCREEN_TYPE_ID_KEY);
1014          */
1015
1016         if (show_state == EINA_TRUE && manager_object->scan_button != NULL)
1017                 elm_object_disabled_set(manager_object->scan_button, EINA_FALSE);
1018         else if (show_state == EINA_FALSE && manager_object->scan_button != NULL)
1019                 elm_object_disabled_set(manager_object->scan_button, EINA_TRUE);
1020
1021         viewer_manager_setup_wizard_scan_btn_set(show_state);
1022
1023         __COMMON_FUNC_EXIT__;
1024         return EINA_TRUE;
1025 }
1026
1027 static void __ea_setup_wizard_back_cb(void *data, Evas_Object *obj,
1028                 void *event_info)
1029 {
1030         if ((view_manager_view_type_t)evas_object_data_get(obj, SCREEN_TYPE_ID_KEY) !=
1031                         VIEW_MANAGER_VIEW_TYPE_MAIN) {
1032                 eext_naviframe_back_cb(data, obj, event_info);
1033                 return;
1034         }
1035
1036         if (viewer_manager_is_passwd_popup_exists() == TRUE ||
1037                         ug_app_state->bAlive == EINA_FALSE) {
1038                 return;
1039         }
1040
1041         _lbutton_click_cb(data, obj, event_info);
1042 }
1043
1044 static void __viewer_manager_create_setup_wizard_content(Evas_Object *layout)
1045 {
1046         __COMMON_FUNC_ENTER__;
1047
1048         Elm_Object_Item *navi_it = NULL;
1049
1050         elm_layout_file_set(layout, SETUP_WIZARD_EDJ_PATH, "main_pwlock");
1051         elm_object_domain_translatable_part_text_set(layout, "text.title",
1052                 PACKAGE, sc(PACKAGE, I18N_TYPE_Wi_Fi));
1053
1054         eext_object_event_callback_add(manager_object->nav, EEXT_CALLBACK_BACK,
1055                         __ea_setup_wizard_back_cb, NULL);
1056
1057         __viewer_manager_wifi_onoff_item_create(manager_object->list, UG_VIEW_SETUP_WIZARD);
1058         __viewer_manager_onoff_description_item_create();
1059
1060         elm_object_part_content_set(layout, "elm.swallow.content",
1061                         manager_object->list);
1062
1063         navi_it = elm_naviframe_item_push(manager_object->nav, NULL, NULL, NULL, layout, NULL);
1064         elm_naviframe_item_title_enabled_set(navi_it, EINA_FALSE, EINA_FALSE);
1065
1066         evas_object_data_set(manager_object->nav, SCREEN_TYPE_ID_KEY,
1067                         (void *)VIEW_MANAGER_VIEW_TYPE_MAIN);
1068         evas_object_smart_callback_add(manager_object->nav,
1069                         "transition,finished", _transition_finished_main_cb, navi_it);
1070
1071         Evas_Object *prev_btn = elm_button_add(layout);
1072         elm_object_style_set(prev_btn, "bottom");
1073         elm_object_part_content_set(layout, "button.prev", prev_btn);
1074         elm_object_text_set(prev_btn, sc(PACKAGE, I18N_TYPE_Prev));
1075         evas_object_smart_callback_add(prev_btn, "clicked", _lbutton_click_cb, manager_object);
1076         manager_object->prev_button = prev_btn;
1077
1078         Evas_Object *next_btn = elm_button_add(layout);
1079         elm_object_style_set(next_btn, "bottom");
1080         elm_object_part_content_set(layout, "button.next", next_btn);
1081         elm_object_text_set(next_btn, sc(PACKAGE, I18N_TYPE_Next));
1082         evas_object_smart_callback_add(next_btn, "clicked", _rbutton_click_cb, manager_object);
1083         manager_object->next_button = next_btn;
1084
1085         __COMMON_FUNC_EXIT__;
1086 }
1087
1088 static void __viewer_manager_create_wifi_ug_content(Evas_Object *layout,
1089                 Evas_Object *_win_main)
1090 {
1091         __COMMON_FUNC_ENTER__;
1092
1093         Elm_Object_Item *navi_it = NULL;
1094         Evas_Object *back_btn = NULL;
1095         Evas_Object *more_btn = NULL;
1096         int ug_type = wifi_get_ug_type();
1097
1098         if (ug_type == UG_VIEW_IOT_COMMON) {
1099                 elm_layout_file_set(layout, MAIN_LAYOUT_EDJ_PATH, "main_layout");
1100         } else {
1101                 elm_layout_theme_set(layout, "layout", "application", "default");
1102                 edje_object_signal_emit(elm_layout_edje_get(layout), "elm,state,show,content", "elm");
1103                 edje_object_signal_emit(elm_layout_edje_get(layout), "elm,bg,show,group_list", "elm");
1104         }
1105
1106         __viewer_manager_wifi_onoff_item_create(manager_object->list, ug_type);
1107         __viewer_manager_onoff_description_item_create();
1108
1109         elm_object_part_content_set(layout, "elm.swallow.content", manager_object->list);
1110
1111         eext_object_event_callback_add(manager_object->nav, EEXT_CALLBACK_BACK, eext_naviframe_back_cb, NULL);
1112
1113         back_btn = elm_button_add(manager_object->nav);
1114         elm_object_style_set(back_btn, "naviframe/back_btn/default");
1115         evas_object_smart_callback_add(back_btn, "clicked", __back_cb, _win_main);
1116         elm_object_focus_allow_set(back_btn, EINA_FALSE);
1117
1118         manager_object->navi_it = navi_it = elm_naviframe_item_push(manager_object->nav,
1119                         sc(PACKAGE, I18N_TYPE_Wi_Fi), back_btn, NULL,
1120                         layout, NULL);
1121         evas_object_data_set(manager_object->nav, SCREEN_TYPE_ID_KEY,
1122                         (void *)VIEW_MANAGER_VIEW_TYPE_MAIN);
1123         evas_object_smart_callback_add(manager_object->nav,
1124                         "transition,finished", _transition_finished_main_cb, navi_it);
1125
1126         more_btn = elm_button_add(manager_object->nav);
1127         evas_object_smart_callback_add(more_btn, "clicked",
1128                         _more_button_cb, _win_main);
1129
1130         if (ug_app_state->ug_type == UG_VIEW_IOT_COMMON) {
1131                 elm_object_style_set(more_btn, "naviframe/more");
1132                 elm_object_item_part_content_set(navi_it, "title_content", more_btn);
1133         } else {
1134                 elm_object_style_set(more_btn, "naviframe/more/default");
1135                 elm_object_item_part_content_set(navi_it, "toolbar_more_btn", more_btn);
1136         }
1137
1138         elm_naviframe_item_pop_cb_set(navi_it, _back_sk_cb, NULL);
1139
1140         __COMMON_FUNC_EXIT__;
1141 }
1142
1143 static void __viewer_manager_create_oobe_content(Evas_Object *layout,
1144                 Evas_Object *_win_main)
1145 {
1146         __COMMON_FUNC_ENTER__;
1147
1148         Elm_Object_Item *navi_it = NULL;
1149
1150         elm_layout_theme_set(layout, "layout", "application", "default");
1151         edje_object_signal_emit(elm_layout_edje_get(layout), "elm,state,show,content", "elm");
1152         edje_object_signal_emit(elm_layout_edje_get(layout), "elm,bg,show,group_list", "elm");
1153
1154         __viewer_manager_wifi_onoff_item_create(manager_object->list, UG_VIEW_OOBE);
1155         __viewer_manager_onoff_description_item_create();
1156
1157         elm_object_part_content_set(layout, "elm.swallow.content", manager_object->list);
1158
1159         eext_object_event_callback_add(manager_object->nav, EEXT_CALLBACK_BACK,
1160                         eext_naviframe_back_cb, NULL);
1161
1162         manager_object->navi_it = navi_it = elm_naviframe_item_push(manager_object->nav,
1163                         NULL, NULL, NULL, layout, NULL);
1164
1165         elm_naviframe_item_title_enabled_set(manager_object->navi_it, EINA_FALSE, EINA_FALSE);
1166         evas_object_data_set(manager_object->nav, SCREEN_TYPE_ID_KEY,
1167                         (void *)VIEW_MANAGER_VIEW_TYPE_MAIN);
1168         evas_object_smart_callback_add(manager_object->nav,
1169                         "transition,finished", _transition_finished_main_cb, navi_it);
1170         elm_naviframe_item_pop_cb_set(navi_it, _back_sk_cb, NULL);
1171
1172         __COMMON_FUNC_EXIT__;
1173 }
1174
1175 #if 0 /* not used */
1176 Evas_Object *viewer_manager_create_bg(Evas_Object *parent, char *style)
1177 {
1178         Evas_Object *bg;
1179
1180         bg = elm_bg_add(parent);
1181         evas_object_size_hint_weight_set(bg, EVAS_HINT_EXPAND,
1182                 EVAS_HINT_EXPAND);
1183
1184         if (style)
1185                 elm_object_style_set(bg, style);
1186
1187         elm_win_resize_object_add(parent, bg);
1188         evas_object_show(bg);
1189
1190         return bg;
1191 }
1192 #endif
1193
1194 Evas_Object *viewer_manager_create(Evas_Object *_parent, Evas_Object *_win_main)
1195 {
1196         __COMMON_FUNC_ENTER__;
1197
1198         retvm_if(NULL == _parent, NULL);
1199         if (manager_object != NULL) {
1200                 free(manager_object);
1201                 manager_object = NULL;
1202         }
1203
1204         Evas_Object *layout = NULL;
1205         Evas_Object *view_content = NULL;
1206
1207         manager_object = g_new0(viewer_manager_object, 1);
1208         retvm_if(NULL == manager_object, NULL);
1209
1210         /* Add Full Layout */
1211         layout = elm_layout_add(_parent);
1212         retvm_if(NULL == layout, NULL);
1213
1214         elm_layout_theme_set(layout, "layout", "application", "default");
1215         evas_object_size_hint_weight_set(layout,
1216                         EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
1217         edje_object_signal_emit(elm_layout_edje_get(layout),
1218                         "elm,state,show,content", "elm");
1219         edje_object_signal_emit(elm_layout_edje_get(layout),
1220                         "elm,bg,show,group_list", "elm");
1221         edje_object_signal_emit(elm_layout_edje_get(layout),
1222                         "elm,state,show,indicator", "elm");
1223
1224         /* Add Naviframe */
1225         manager_object->nav = elm_naviframe_add(layout);
1226         assertm_if(NULL == manager_object->nav, "manager_object->nav is NULL");
1227         elm_object_part_content_set(layout,
1228                         "elm.swallow.content", manager_object->nav);
1229         elm_naviframe_prev_btn_auto_pushed_set(manager_object->nav, EINA_FALSE);
1230         eext_object_event_callback_add(manager_object->nav, EEXT_CALLBACK_MORE,
1231                         eext_naviframe_more_cb, NULL);
1232
1233         /* Add layout for custom styles */
1234         elm_theme_extension_add(NULL, CUSTOM_EDITFIELD_PATH);
1235
1236         if (ug_app_state->ug_type == UG_VIEW_OOBE)
1237                 elm_theme_extension_add(NULL, OOBE_BUTTONS_EDJ_PATH);
1238
1239         /* Add MainView Layout */
1240         view_content = elm_layout_add(manager_object->nav);
1241
1242         /* Add genlist */
1243         manager_object->list = viewer_list_create(view_content);
1244         assertm_if(NULL == manager_object->list, "manager_object->list is NULL");
1245
1246         /* Add app setup-wizard/wifi-ug specific contents */
1247         if (ug_app_state->ug_type == UG_VIEW_SETUP_WIZARD)
1248                 __viewer_manager_create_setup_wizard_content(view_content);
1249         else if (ug_app_state->ug_type == UG_VIEW_OOBE)
1250                 __viewer_manager_create_oobe_content(view_content, _win_main);
1251         else
1252                 __viewer_manager_create_wifi_ug_content(view_content, _win_main);
1253
1254         if(_is_emulator()) {
1255                 int state = wlan_manager_state_get();
1256                 if(state == WLAN_MANAGER_UNCONNECTED) {
1257                         viewer_manager_header_mode_set(HEADER_MODE_ON);
1258                         wifi_emulator_create_event_timer(WIFI_EMUL_EVENT_TIMER_ACTIVATE,
1259                                         1000, wlan_manager_emulator_power_on, NULL);
1260                 } else {
1261                         viewer_manager_header_mode_set(HEADER_MODE_OFF);
1262                         wifi_emulator_create_event_timer(WIFI_EMUL_EVENT_TIMER_DEACTIVATE,
1263                                         500, wlan_manager_emulator_power_off, NULL);
1264                 }
1265         }
1266
1267         evas_object_show(layout);
1268         elm_object_focus_set(layout, EINA_TRUE);
1269
1270         __COMMON_FUNC_EXIT__;
1271         return layout;
1272 }
1273
1274 void viewer_manager_destroy(void)
1275 {
1276         __COMMON_FUNC_ENTER__;
1277
1278         if (wifi_device_list != NULL) {
1279                 g_list_free(wifi_device_list);
1280                 wifi_device_list = NULL;
1281         }
1282
1283         if (manager_object != NULL) {
1284                 viewer_manager_cleanup_views();
1285
1286                 if (manager_object->item_wifi_onoff_text) {
1287                         g_free(manager_object->item_wifi_onoff_text);
1288                         manager_object->item_wifi_onoff_text = NULL;
1289                 }
1290
1291                 if (manager_object->item_onoff_description) {
1292                         g_free(manager_object->item_onoff_description_text);
1293                         manager_object->item_onoff_description = NULL;
1294                 }
1295
1296                 g_free(manager_object);
1297                 manager_object = NULL;
1298         }
1299
1300         __COMMON_FUNC_EXIT__;
1301 }
1302
1303 Eina_Bool viewer_manager_show(VIEWER_WINSETS winset)
1304 {
1305         __COMMON_FUNC_ENTER__;
1306
1307         assertm_if(NULL == manager_object, "Manager object is NULL");
1308
1309         switch (winset) {
1310         case VIEWER_WINSET_SEARCHING:
1311                 viewer_manager_scan_button_set(EINA_FALSE);
1312                 viewer_list_item_disable_all();
1313                 break;
1314
1315         case VIEWER_WINSET_SUB_CONTENTS:
1316                 assertm_if(NULL == manager_object->list, "List is NULL");
1317
1318                 viewer_list_title_item_set(manager_object->item_wifi_onoff);
1319                 if (ug_app_state->ug_type == UG_VIEW_SETUP_WIZARD) {
1320                         __viewer_manager_hidden_button_create(manager_object->list);
1321                         __viewer_manager_setup_wizard_scan_btn_create(
1322                                 manager_object->list);
1323                 }
1324                 break;
1325
1326         case VIEWER_WINSET_SEARCHING_GRP_TITLE:
1327                 viewer_manager_scan_button_set(EINA_FALSE);
1328                 break;
1329
1330         default:
1331                 break;
1332         }
1333
1334         __COMMON_FUNC_EXIT__;
1335         return EINA_TRUE;
1336 }
1337
1338 static void __viewer_manager_hidden_btn_del(void)
1339 {
1340         __COMMON_FUNC_ENTER__;
1341
1342         if (manager_object->sw_hidden_btn) {
1343                 evas_object_del(manager_object->sw_hidden_btn);
1344                 manager_object->sw_hidden_btn = NULL;
1345         }
1346
1347         __COMMON_FUNC_EXIT__;
1348 }
1349
1350 static void __viewer_manager_setup_wizard_scan_btn_del(void)
1351 {
1352         if (ug_app_state->ug_type != UG_VIEW_SETUP_WIZARD)
1353                 return;
1354
1355         __COMMON_FUNC_ENTER__;
1356
1357         if (manager_object->sw_scan_btn) {
1358                 evas_object_del(manager_object->sw_scan_btn);
1359                 manager_object->sw_scan_btn = NULL;
1360         }
1361
1362         __COMMON_FUNC_EXIT__;
1363 }
1364
1365 Eina_Bool viewer_manager_hide(VIEWER_WINSETS winset)
1366 {
1367         __COMMON_FUNC_ENTER__;
1368
1369         switch (winset) {
1370         case VIEWER_WINSET_SEARCHING:
1371                 /* searching view */
1372                 viewer_manager_scan_button_set(EINA_TRUE);
1373                 viewer_list_item_enable_all();
1374                 break;
1375
1376         case VIEWER_WINSET_SUB_CONTENTS:
1377                 /* hidden AP and WPS PBC */
1378                 if (ug_app_state->passpopup) {
1379                         passwd_popup_free(ug_app_state->passpopup);
1380                         ug_app_state->passpopup = NULL;
1381                 }
1382
1383                 if (ug_app_state->eap_view) {
1384                         eap_connect_data_free(ug_app_state->eap_view);
1385                         ug_app_state->eap_view = NULL;
1386                 }
1387
1388                 if (ug_app_state->ug_type == UG_VIEW_SETUP_WIZARD) {
1389                         __viewer_manager_hidden_btn_del();
1390                         __viewer_manager_setup_wizard_scan_btn_del();
1391                 }
1392                 viewer_list_title_item_del();
1393                 break;
1394
1395         default:
1396                 break;
1397         }
1398
1399         __COMMON_FUNC_EXIT__;
1400         return EINA_TRUE;
1401 }
1402
1403 #if 0
1404 /* Unused function */
1405 Eina_Bool viewer_manager_genlist_item_update(Elm_Object_Item* item)
1406 {
1407         __COMMON_FUNC_ENTER__;
1408         if (item == NULL) {
1409                 __COMMON_FUNC_EXIT__;
1410                 return EINA_FALSE;
1411         }
1412
1413         if (item != NULL)
1414                 elm_genlist_item_update(item);
1415
1416         __COMMON_FUNC_EXIT__;
1417         return EINA_FALSE;
1418 }
1419 #endif
1420
1421 void viewer_manager_update_hidden_btn(void)
1422 {
1423         if (ug_app_state->ug_type != UG_VIEW_SETUP_WIZARD)
1424                 return;
1425
1426         __COMMON_FUNC_ENTER__;
1427         retm_if(NULL == manager_object->sw_hidden_btn);
1428
1429         switch (viewer_manager_header_mode_get()) {
1430         case HEADER_MODE_ACTIVATING:
1431         case HEADER_MODE_DEACTIVATING:
1432         case HEADER_MODE_SEARCHING:
1433                 elm_object_disabled_set(manager_object->sw_hidden_btn,
1434                                 EINA_TRUE);
1435                 break;
1436         default:
1437                 elm_object_disabled_set(manager_object->sw_hidden_btn,
1438                                 EINA_FALSE);
1439                 break;
1440         }
1441
1442         __COMMON_FUNC_EXIT__;
1443 }
1444
1445 void viewer_manager_update_setup_wizard_scan_btn(void)
1446 {
1447         if (ug_app_state->ug_type != UG_VIEW_SETUP_WIZARD)
1448                 return;
1449
1450         __COMMON_FUNC_ENTER__;
1451         retm_if(NULL == manager_object->sw_scan_btn);
1452
1453         switch (viewer_manager_header_mode_get()) {
1454         case HEADER_MODE_ACTIVATING:
1455         case HEADER_MODE_DEACTIVATING:
1456         case HEADER_MODE_SEARCHING:
1457                 elm_object_disabled_set(manager_object->sw_scan_btn,
1458                                 EINA_TRUE);
1459                 break;
1460         default:
1461                 elm_object_disabled_set(manager_object->sw_scan_btn,
1462                                 EINA_FALSE);
1463                 break;
1464         }
1465
1466         __COMMON_FUNC_EXIT__;
1467 }
1468
1469 void viewer_manager_setup_wizard_button_controller()
1470 {
1471         __COMMON_FUNC_ENTER__;
1472
1473         int ret;
1474         wifi_manager_connection_state_e connection_state;
1475
1476         ret = wlan_manager_get_connection_state(&connection_state);
1477         if (ret != WIFI_MANAGER_ERROR_NONE)
1478                 INFO_LOG(UG_NAME_NORMAL, "Failed to retrieve connection state ret [%d]", ret);
1479
1480         if (manager_object->prev_button != NULL &&
1481                 ug_app_state->lbutton_setup_wizard_prev != NULL) {
1482                 elm_object_text_set(manager_object->prev_button,
1483                         sc(PACKAGE, I18N_TYPE_Prev));
1484         }
1485
1486         if (connection_state == WIFI_MANAGER_CONNECTION_STATE_CONNECTED) {
1487                 if (manager_object->next_button != NULL &&
1488                         ug_app_state->rbutton_setup_wizard_next != NULL) {
1489                         elm_object_text_set(manager_object->next_button,
1490                                 sc(PACKAGE, I18N_TYPE_Next));
1491                 }
1492         } else {
1493                 if (manager_object->next_button != NULL &&
1494                         ug_app_state->rbutton_setup_wizard_skip != NULL) {
1495                         elm_object_text_set(manager_object->next_button,
1496                                 sc(PACKAGE, I18N_TYPE_Skip));
1497                 }
1498         }
1499
1500         if (manager_object->sw_hidden_btn != NULL) {
1501                 elm_object_domain_translatable_text_set(
1502                                 manager_object->sw_hidden_btn, PACKAGE,
1503                                 "IDS_WIFI_BUTTON_FIND_HIDDEN_NETWORK");
1504         }
1505
1506         if (manager_object->sw_scan_btn != NULL) {
1507                 elm_object_domain_translatable_text_set(
1508                                 manager_object->sw_scan_btn, PACKAGE,
1509                                 "IDS_WIFI_BUTTON_SCAN");
1510         }
1511 }
1512
1513 static void viewer_manager_pop_naviframe_item(void)
1514 {
1515         __COMMON_FUNC_ENTER__;
1516
1517         view_manager_view_type_t top_viewID;
1518
1519         top_viewID = viewer_manager_view_type_get();
1520         if (top_viewID == VIEW_MANAGER_VIEW_TYPE_DETAIL)
1521                 elm_naviframe_item_pop(viewer_manager_get_naviframe());
1522
1523         __COMMON_FUNC_EXIT__;
1524 }
1525
1526 Evas_Object *viewer_manager_naviframe_power_item_get(void)
1527 {
1528         __COMMON_FUNC_ENTER__;
1529
1530         Elm_Object_Item *navi_it = NULL;
1531         Evas_Object *layout = NULL;
1532
1533         if (manager_object == NULL)
1534                 return NULL;
1535
1536         navi_it = elm_naviframe_top_item_get(manager_object->nav);
1537
1538         if (navi_it == NULL) {
1539                 ERROR_LOG(UG_NAME_ERR, "navi_it is NULL");
1540                 return NULL;
1541         }
1542
1543         if (ug_app_state->ug_type == UG_VIEW_SETUP_WIZARD) {
1544                 layout = elm_object_item_content_get(navi_it);
1545                 if (layout) {
1546                         __COMMON_FUNC_EXIT__;
1547                         return elm_object_part_content_get(layout, "title_right_btn");
1548                 }
1549         }
1550
1551         __COMMON_FUNC_EXIT__;
1552         return elm_object_item_part_content_get(navi_it, "title_right_btn");
1553 }
1554
1555 // For IoT Common profile.
1556 Evas_Object *viewer_maanger_create_scan_list_btn(Evas_Object *parent)
1557 {
1558         Evas_Object *btn = elm_button_add(parent);
1559         if (!btn)
1560                 return NULL;
1561
1562         elm_object_style_set(btn, "border");
1563         elm_object_domain_translatable_text_set(btn, PACKAGE,
1564                         "IDS_WIFI_BUTTON_SCAN");
1565         evas_object_smart_callback_add(btn, "clicked", __refresh_scan_callback, NULL);
1566
1567         return btn;
1568 }
1569
1570 int viewer_manager_create_scan_btn(void)
1571 {
1572         __COMMON_FUNC_ENTER__;
1573         if (ug_app_state->ug_type == UG_VIEW_SETUP_WIZARD
1574                         || ug_app_state->ug_type == UG_VIEW_OOBE
1575                         || ug_app_state->ug_type == UG_VIEW_IOT_COMMON
1576                         || manager_object->scan_button) {
1577                 __COMMON_FUNC_EXIT__;
1578                 return 0;
1579         }
1580         Evas_Object *btn = elm_button_add(manager_object->nav);
1581                 /* Use "bottom" style button */
1582         if (!btn) {
1583                 ERROR_LOG(UG_NAME_NORMAL, "Error creating toolbar");
1584                 return -1;
1585         }
1586         elm_object_style_set(btn, "bottom");
1587         elm_object_domain_translatable_text_set(btn, PACKAGE,
1588                         "IDS_WIFI_BUTTON_SCAN");
1589         evas_object_smart_callback_add(btn, "clicked", __refresh_scan_callback, NULL);
1590
1591         /* Set button into "toolbar" swallow part */
1592         elm_object_item_part_content_set(manager_object->navi_it, "toolbar", btn);
1593         manager_object->scan_button = btn;
1594         evas_object_show(manager_object->scan_button);
1595         __COMMON_FUNC_EXIT__;
1596         return 0;
1597 }
1598
1599 void viewer_manager_header_mode_set(HEADER_MODES new_mode)
1600 {
1601         __COMMON_FUNC_ENTER__;
1602
1603         HEADER_MODES old_mode;
1604         if (manager_object == NULL)
1605                 return;
1606
1607         if (HEADER_MODE_OFF > new_mode || HEADER_MODE_MAX <= new_mode) {
1608                 ERROR_LOG(UG_NAME_ERR, "Invalid mode %d", new_mode);
1609                 return;
1610         }
1611
1612         old_mode = manager_object->header_mode;
1613         if (old_mode == new_mode) {
1614                 if (new_mode == HEADER_MODE_OFF && manager_object->scan_button) {
1615                         evas_object_del(manager_object->scan_button);
1616                         manager_object->scan_button = NULL;
1617                 }
1618                 return;
1619         }
1620
1621         DEBUG_LOG(UG_NAME_NORMAL, "Header mode %d --> %d", old_mode, new_mode);
1622
1623         manager_object->header_mode = new_mode;
1624
1625         switch (new_mode) {
1626         case HEADER_MODE_OFF:
1627                 viewer_manager_onoff_description_item_set(TRUE);
1628                 if (manager_object->scan_button) {
1629                         evas_object_del(manager_object->scan_button);
1630                         manager_object->scan_button = NULL;
1631                 }
1632                 if (ug_app_state->ug_type == UG_VIEW_SETUP_WIZARD) {
1633                         __viewer_manager_hidden_btn_del();
1634                         __viewer_manager_setup_wizard_scan_btn_del();
1635                 }
1636                 ug_app_state->is_wifi_scan_indication_block = 0;
1637                 break;
1638         case HEADER_MODE_ON:
1639         case HEADER_MODE_CONNECTED:
1640                 viewer_manager_onoff_description_item_set(FALSE);
1641                 viewer_manager_scan_button_set(EINA_TRUE);
1642                 break;
1643         default:
1644                 break;
1645         }
1646
1647         if (manager_object->item_wifi_onoff != NULL)
1648                 elm_genlist_item_update(manager_object->item_wifi_onoff);
1649         viewer_list_title_item_update();
1650         if (ug_app_state->ug_type == UG_VIEW_SETUP_WIZARD) {
1651                 viewer_manager_update_hidden_btn();
1652                 viewer_manager_update_setup_wizard_scan_btn();
1653                 viewer_manager_setup_wizard_button_controller();
1654         }
1655
1656         __COMMON_FUNC_EXIT__;
1657 }
1658
1659 HEADER_MODES viewer_manager_header_mode_get(void)
1660 {
1661         return manager_object->header_mode;
1662 }
1663
1664 Evas_Object* viewer_manager_get_naviframe()
1665 {
1666         return manager_object->nav;
1667 }
1668
1669 void viewer_manager_refresh_ap_info(Elm_Object_Item *item)
1670 {
1671         if (!item)
1672                 return;
1673
1674         ug_genlist_data_t *gdata = elm_object_item_data_get(item);
1675         if (!gdata)
1676                 return;
1677
1678         wifi_device_info_t *wifi_device = gdata->device_info;
1679         if (!wifi_device)
1680                 return;
1681
1682         wifi_manager_ap_refresh(wifi_device->ap);
1683
1684         return;
1685 }
1686
1687 static gboolean __viewer_manager_list_scroll_to_top(void *data)
1688 {
1689         if (data)
1690                 elm_genlist_item_bring_in((Elm_Object_Item *)data, ELM_GENLIST_ITEM_SCROLLTO_TOP);
1691
1692         return FALSE;
1693 }
1694
1695 void viewer_manager_move_to_top(void)
1696 {
1697         __COMMON_FUNC_ENTER__;
1698
1699         Elm_Object_Item * first_item = NULL;
1700
1701         if (manager_object == NULL || manager_object->list == NULL)
1702                 return;
1703
1704         first_item = elm_genlist_first_item_get(manager_object->list);
1705         if (first_item == NULL)
1706                 return;
1707
1708         common_util_managed_idle_add(__viewer_manager_list_scroll_to_top, first_item);
1709
1710         __COMMON_FUNC_EXIT__;
1711 }
1712
1713 Elm_Object_Item *viewer_manager_move_item_to_top(Elm_Object_Item *old_item)
1714 {
1715         __COMMON_FUNC_ENTER__;
1716
1717         Elm_Object_Item *first_item = viewer_list_get_first_item();
1718         ug_genlist_data_t *gdata = NULL, *first_it_gdata = NULL;
1719
1720         if (!old_item || !first_item) {
1721                 __COMMON_FUNC_EXIT__;
1722                 return NULL;
1723         }
1724
1725         gdata = elm_object_item_data_get(old_item);
1726         if (!gdata || !gdata->device_info) {
1727                 __COMMON_FUNC_EXIT__;
1728                 return NULL;
1729         }
1730
1731         if (old_item != first_item) {
1732                 first_it_gdata = elm_object_item_data_get(first_item);
1733                 elm_object_item_data_set(first_item, gdata);
1734                 elm_object_item_data_set(old_item, first_it_gdata);
1735
1736                 if (first_item != NULL)
1737                         elm_genlist_item_update(first_item);
1738                 if (old_item != NULL)
1739                         elm_genlist_item_update(old_item);
1740         }
1741
1742         __COMMON_FUNC_EXIT__;
1743         return first_item;
1744 }
1745
1746 void viewer_manager_update_rssi(void)
1747 {
1748         int ret;
1749         wifi_manager_ap_h ap;
1750
1751         ret = wlan_manager_get_connected_ap(&ap);
1752         if (WIFI_MANAGER_ERROR_NONE != ret)
1753                 return;
1754
1755         Elm_Object_Item *item = item_get_for_ap(ap);
1756         if (!item) {
1757                 wifi_manager_ap_destroy(ap);
1758                 return;
1759         }
1760
1761         ug_genlist_data_t* gdata = elm_object_item_data_get(item);
1762         if (gdata && gdata->device_info) {
1763                 int rssi = 0;
1764
1765                 if (WIFI_MANAGER_ERROR_NONE != wifi_manager_ap_get_rssi(ap, &rssi)) {
1766                         wifi_manager_ap_destroy(ap);
1767                         return;
1768                 } else if (gdata->device_info->rssi != rssi) {
1769                         wifi_manager_ap_refresh(gdata->device_info->ap);
1770                         gdata->device_info->rssi = rssi;
1771
1772                         g_free(gdata->device_info->ap_image_path);
1773
1774                         common_utils_get_device_icon(gdata->device_info,
1775                                         &gdata->device_info->ap_image_path);
1776
1777                         if (item != NULL)
1778                                 elm_genlist_item_update(item);
1779                 }
1780         }
1781
1782         wifi_manager_ap_destroy(ap);
1783 }
1784
1785 static gint compare(gconstpointer a, gconstpointer b)
1786 {
1787         bool favorite1 = false, favorite2 = false;
1788         wifi_manager_connection_state_e state1 = 0, state2 = 0;
1789
1790         wifi_device_info_t *wifi_device1 = (wifi_device_info_t*)a;
1791         wifi_device_info_t *wifi_device2 = (wifi_device_info_t*)b;
1792
1793         wifi_manager_ap_get_connection_state(wifi_device1->ap, &state1);
1794         wifi_manager_ap_get_connection_state(wifi_device2->ap, &state2);
1795
1796         if (state1 != state2) {
1797                 if (state1 == WIFI_MANAGER_CONNECTION_STATE_CONNECTED)
1798                         return -1;
1799                 if (state2 == WIFI_MANAGER_CONNECTION_STATE_CONNECTED)
1800                         return 1;
1801
1802                 if (state1 == WIFI_MANAGER_CONNECTION_STATE_CONFIGURATION)
1803                         return -1;
1804                 if (state2 == WIFI_MANAGER_CONNECTION_STATE_CONFIGURATION)
1805                         return 1;
1806
1807                 if (state1 == WIFI_MANAGER_CONNECTION_STATE_ASSOCIATION)
1808                         return -1;
1809                 if (state2 == WIFI_MANAGER_CONNECTION_STATE_ASSOCIATION)
1810                         return 1;
1811         }
1812
1813         wifi_manager_ap_is_favorite(wifi_device1->ap, &favorite1);
1814         wifi_manager_ap_is_favorite(wifi_device2->ap, &favorite2);
1815
1816         if (favorite1 != favorite2) {
1817                 if (favorite1 == true)
1818                         return -1;
1819                 if (favorite2 == true)
1820                         return 1;
1821         }
1822
1823         if (manager_object->sort_type == I18N_TYPE_Alphabetical) {
1824                 return strcasecmp((const char *)wifi_device1->ssid,
1825                                 (const char *)wifi_device2->ssid);
1826         } else {
1827                 return ((wifi_device1->rssi >= wifi_device2->rssi) ? -1 : 1);
1828         }
1829 }
1830
1831 static bool wifi_update_list_for_each_ap(wifi_manager_ap_h ap, void *user_data)
1832 {
1833         int *profile_size = (int *)user_data;
1834         wifi_device_info_t *wifi_device = NULL;
1835
1836         wifi_device = view_list_item_device_info_create(ap);
1837         if (wifi_device == NULL)
1838                 return true;
1839
1840         wifi_device_list = g_list_insert_sorted(wifi_device_list, wifi_device, compare);
1841         (*profile_size)++;
1842
1843         return true;
1844 }
1845
1846 static wifi_device_info_t *view_list_item_emulator_device_info_create(int index)
1847 {
1848         wifi_device_info_t* wifi_device = NULL;
1849
1850         wifi_device = g_try_new0(wifi_device_info_t, 1);
1851         retvm_if(NULL == wifi_device, NULL);
1852
1853         wifi_device->ap = NULL;
1854         wifi_device->ssid = g_strdup(wifi_samples[index].ssid);
1855         wifi_device->rssi = 100;
1856         wifi_device->security_mode = wifi_samples[index].security;
1857         wifi_device->wps_mode = wifi_samples[index].wps;
1858         common_utils_get_device_icon(wifi_device, &wifi_device->ap_image_path);
1859
1860         return wifi_device;
1861 }
1862
1863 static void wifi_update_list_for_emulator_ap(void)
1864 {
1865         int index;
1866         wifi_device_info_t *wifi_device = NULL;
1867
1868         for (index = 0; index < wifi_sample_count; ++index) {
1869                 wifi_device = view_list_item_emulator_device_info_create(index);
1870                 if (wifi_device == NULL)
1871                         return;
1872
1873                 wifi_device_list = g_list_insert_sorted(wifi_device_list, wifi_device, compare);
1874                 INFO_LOG(UG_NAME_NORMAL, "wifi_device_list added device(%s)", wifi_device->ssid);
1875         }
1876 }
1877
1878 static int viewer_manager_update_list_all(char *ssid)
1879 {
1880         int i, profiles_list_size = 0;
1881         Elm_Object_Item *item = NULL;
1882         GList* list_of_device ;
1883         wifi_device_info_t *wifi_device = NULL;
1884         int ssid_count = 0;
1885
1886         __COMMON_FUNC_ENTER__;
1887
1888         view_manager_list_update_info_t update_info;
1889         memset(&update_info, 0, sizeof(update_info));
1890
1891         manager_object->sort_type = _convert_vconf_to_sort_by_value(
1892                         common_util_get_system_registry(VCONF_SORT_BY));
1893
1894         if (_is_emulator()) {
1895                 profiles_list_size = wifi_sample_count;
1896                 wifi_update_list_for_emulator_ap();
1897         } else
1898                 wlan_manager_foreach_found_ap(wifi_update_list_for_each_ap, &profiles_list_size);
1899
1900         list_of_device = wifi_device_list;
1901         for (i = 0; i < profiles_list_size && list_of_device != NULL; i++) {
1902                 wifi_device = (wifi_device_info_t*)list_of_device->data;
1903                 if (ssid == NULL || g_strcmp0(ssid, wifi_device->ssid) == 0) {
1904                         item = viewer_list_item_insert_after(wifi_device, update_info.last_appended_item);
1905                         if (item) {
1906                                 update_info.last_appended_item = item;
1907                                 update_info.total_items_added++;
1908                                 ssid_count++;
1909                         }
1910                 }
1911
1912                 list_of_device = list_of_device->next;
1913         }
1914
1915         if (wifi_device_list != NULL) {
1916                 g_list_free(wifi_device_list);
1917                 wifi_device_list = NULL;
1918         }
1919
1920         // OOBE: hidden AP, IOT: scan button
1921         viewer_list_last_item_set(update_info.last_appended_item);
1922         INFO_LOG(UG_NAME_NORMAL, "total items added = %d", update_info.total_items_added);
1923
1924         if (0 == update_info.total_items_added) {
1925                 /* Check if whether it's the first time we get no profiles,
1926                  * if so, send one more scan request. This avoids the issue of
1927                  * showing 'No Wi-Fi AP found' during launch time.
1928                  */
1929                 if (manager_object->is_first_time_no_profiles == false) {
1930                         HEADER_MODES current_state;
1931                         int scan_result = WLAN_MANAGER_ERR_NONE;
1932                         current_state = viewer_manager_header_mode_get();
1933
1934                         viewer_manager_show(VIEWER_WINSET_SEARCHING);
1935                         viewer_manager_header_mode_set(HEADER_MODE_SEARCHING);
1936
1937                         scan_result = wlan_manager_scan();
1938                         if (scan_result != WLAN_MANAGER_ERR_NONE) {
1939                                 viewer_manager_hide(VIEWER_WINSET_SEARCHING);
1940                                 viewer_manager_header_mode_set(current_state);
1941                         }
1942
1943                         manager_object->is_first_time_no_profiles = true;
1944                 } else {
1945                         /* if there is no scan_data, generate No-AP item */
1946                         item = viewer_list_item_insert_after(NULL, NULL);
1947                         if (item)
1948                                 elm_genlist_item_select_mode_set(item,
1949                                                 ELM_OBJECT_SELECT_MODE_DISPLAY_ONLY);
1950
1951                 }
1952         }
1953
1954         if (_is_emulator())
1955                 wifi_emulator_remove_event_timer(WIFI_EMUL_EVENT_TIMER_SCAN);
1956
1957         __COMMON_FUNC_EXIT__;
1958         return ssid_count;
1959 }
1960
1961 Eina_Bool viewer_manager_refresh(void)
1962 {
1963         int state;
1964         int header_state;
1965
1966         INFO_LOG(UG_NAME_SCAN, "viewer manager refresh");
1967
1968         if (manager_object == NULL)
1969                 return EINA_FALSE;
1970
1971         header_state = viewer_manager_header_mode_get();
1972         if (header_state == HEADER_MODE_CONNECTING ||
1973                         header_state == HEADER_MODE_ACTIVATING ||
1974                         header_state == HEADER_MODE_DEACTIVATING) {
1975                 return EINA_FALSE;
1976         }
1977
1978         viewer_list_item_disable_all();
1979         viewer_list_item_clear();
1980
1981         state = wlan_manager_state_get();
1982         if (WLAN_MANAGER_ERROR == state || WLAN_MANAGER_OFF == state) {
1983                 /* Some body requested to refresh the list
1984                  * while the WLAN manager is OFF or Unable to get the profile state
1985                  */
1986                 INFO_LOG(UG_NAME_ERR, "WLAN Manager state: %d", state);
1987
1988                 viewer_manager_header_mode_set(HEADER_MODE_OFF);
1989
1990                 return EINA_FALSE;
1991         }
1992
1993         wifi_manager_ap_h ap = wlan_manager_get_ap_with_state(state);
1994         viewer_manager_update_list_all(NULL);
1995         if (ug_app_state->ug_type == UG_VIEW_SETUP_WIZARD) {
1996                 __viewer_manager_hidden_button_create(manager_object->list);
1997                 __viewer_manager_setup_wizard_scan_btn_create(
1998                         manager_object->list);
1999         }
2000
2001         if (WLAN_MANAGER_CONNECTING == state) {
2002                 INFO_LOG(UG_NAME_NORMAL, "Wi-Fi is connecting");
2003
2004                 Elm_Object_Item* target_item = item_get_for_ap(ap);
2005
2006                 viewer_manager_header_mode_set(HEADER_MODE_CONNECTING);
2007                 viewer_list_item_radio_mode_set(target_item,
2008                                 VIEWER_ITEM_RADIO_MODE_CONNECTING);
2009         } else if (WLAN_MANAGER_CONNECTED == state) {
2010                 INFO_LOG(UG_NAME_NORMAL, "Wi-Fi is connected");
2011
2012                 Elm_Object_Item* target_item = item_get_for_ap(ap);
2013
2014                 target_item = viewer_manager_move_item_to_top(target_item);
2015                 viewer_manager_header_mode_set(HEADER_MODE_CONNECTED);
2016                 viewer_list_item_radio_mode_set(target_item,
2017                                 VIEWER_ITEM_RADIO_MODE_CONNECTED);
2018         } else {
2019                 INFO_LOG(UG_NAME_NORMAL, "Wi-Fi state: %d", state);
2020
2021                 viewer_manager_header_mode_set(HEADER_MODE_ON);
2022         }
2023         wifi_manager_ap_destroy(ap);
2024
2025         INFO_LOG(UG_NAME_SCAN, "viewer manager refresh finished");
2026
2027         return EINA_TRUE;
2028 }
2029
2030 static void hidden_ap_connect_ok_cb(void *data,
2031                 Evas_Object *obj, void *event_info)
2032 {
2033         __COMMON_FUNC_ENTER__;
2034
2035         hidden_ap_data_t *hidden_ap_data = (hidden_ap_data_t *)data;
2036         if (hidden_ap_data == NULL) {
2037                 __COMMON_FUNC_EXIT__;
2038                 return;
2039         }
2040
2041         char* szPassword = NULL;
2042         wifi_manager_ap_h ap;
2043
2044         int ret = wlan_manager_ap_create(hidden_ap_data->ssid, &ap);
2045         if (WIFI_MANAGER_ERROR_NONE != ret) {
2046                 ERROR_LOG(UG_NAME_ERR, "Failed to create an AP handle. Err = %d", ret);
2047
2048                 goto exit;
2049         }
2050
2051         SECURE_INFO_LOG(UG_NAME_NORMAL, "Hidden AP[%s]. Sec mode = %d. Connect ok cb",
2052                         hidden_ap_data->ssid, hidden_ap_data->sec_mode);
2053
2054         switch (hidden_ap_data->sec_mode) {
2055         case WIFI_MANAGER_SECURITY_TYPE_NONE:
2056                 INFO_LOG(UG_NAME_NORMAL, "OPEN: event %p; passpopup %p",
2057                                 event_info, ug_app_state->passpopup);
2058
2059                 wifi_manager_ap_set_security_type(ap, WIFI_MANAGER_SECURITY_TYPE_NONE);
2060                 break;
2061
2062         case WIFI_MANAGER_SECURITY_TYPE_WEP:
2063         case WIFI_MANAGER_SECURITY_TYPE_WPA_PSK:
2064         case WIFI_MANAGER_SECURITY_TYPE_WPA2_PSK:
2065                 szPassword = passwd_popup_get_txt(ug_app_state->passpopup);
2066                 wifi_manager_ap_set_security_type(ap, hidden_ap_data->sec_mode);
2067
2068                 int ret = wifi_manager_ap_set_passphrase(ap, szPassword);
2069                 if (ret != WIFI_MANAGER_ERROR_NONE)
2070                         INFO_LOG(UG_NAME_ERR, "Failed to set passpharse [%d]" , ret);
2071
2072                 g_free(szPassword);
2073
2074                 passwd_popup_free(ug_app_state->passpopup);
2075                 ug_app_state->passpopup = NULL;
2076                 break;
2077
2078         default:
2079                 INFO_LOG(UG_NAME_NORMAL, "Fatal: Unknown Sec mode: %d",
2080                                 hidden_ap_data->sec_mode);
2081
2082                 goto hidden_ap_connect_end;
2083         }
2084
2085         wlan_manager_connect(ap);
2086
2087 hidden_ap_connect_end:
2088         wifi_manager_ap_destroy(ap);
2089
2090 exit:
2091         viewer_manager_hidden_confirm_cleanup();
2092
2093         __COMMON_FUNC_EXIT__;
2094 }
2095
2096 static void hidden_ap_connect_cancel_cb(void *data, Evas_Object *obj,
2097                 void *event_info)
2098 {
2099         __COMMON_FUNC_ENTER__;
2100
2101         hidden_ap_data_t *hidden_ap_data = (hidden_ap_data_t *)data;
2102         if (hidden_ap_data == NULL) {
2103                 __COMMON_FUNC_EXIT__;
2104                 return;
2105         }
2106
2107         switch (hidden_ap_data->sec_mode) {
2108         case WIFI_MANAGER_SECURITY_TYPE_NONE:
2109                 INFO_LOG(UG_NAME_NORMAL, "This hidden AP is Open");
2110                 break;
2111
2112         case WIFI_MANAGER_SECURITY_TYPE_WEP:
2113         case WIFI_MANAGER_SECURITY_TYPE_WPA_PSK:
2114         case WIFI_MANAGER_SECURITY_TYPE_WPA2_PSK:
2115                 INFO_LOG(UG_NAME_NORMAL, "Hidden AP Secured");
2116
2117                 passwd_popup_free(ug_app_state->passpopup);
2118                 ug_app_state->passpopup = NULL;
2119                 break;
2120
2121         default:
2122                 INFO_LOG(UG_NAME_NORMAL, "Fatal: Unknown Sec mode: %d",
2123                                 hidden_ap_data->sec_mode);
2124                 break;
2125         }
2126
2127         viewer_manager_request_scan();
2128         viewer_manager_hidden_confirm_cleanup();
2129
2130         __COMMON_FUNC_EXIT__;
2131 }
2132
2133 static void __hidden_ap_cancel_mouseup_cb(void *data, Evas *e, Evas_Object *obj, void *event_info)
2134 {
2135         __COMMON_FUNC_ENTER__;
2136
2137         Evas_Event_Mouse_Up *event = event_info;
2138
2139         if (event->button == 3)
2140                 hidden_ap_connect_cancel_cb(data, obj, event_info);
2141
2142         __COMMON_FUNC_EXIT__;
2143 }
2144
2145 static void __hidden_ap_cancel_keydown_cb(void *data, Evas *e, Evas_Object *obj, void *event_info)
2146 {
2147         __COMMON_FUNC_ENTER__;
2148
2149         Evas_Event_Key_Down *event = event_info;
2150
2151         if (g_strcmp0(event->keyname, "XF86Back") == 0)
2152                 hidden_ap_connect_cancel_cb(data, obj, event_info);
2153
2154         __COMMON_FUNC_EXIT__;
2155 }
2156
2157 void viewer_manager_eap_view_deref(void)
2158 {
2159         __COMMON_FUNC_ENTER__;
2160
2161         ug_app_state->eap_view = NULL;
2162
2163         __COMMON_FUNC_EXIT__;
2164 }
2165
2166 void viewer_manager_specific_scan_response_hlr(
2167                 GSList *bss_info_list, void *user_data)
2168 {
2169         hidden_ap_data_t *hidden_ap_data = NULL;
2170         const char *ssid = (const char *)user_data;
2171         wifi_manager_security_type_e sec_mode = 0;
2172         bool favorite = false;
2173         ug_genlist_data_t* gdata = NULL;
2174         Evas_Object *popup = NULL;
2175         int hidden_ap_count = (int)g_slist_length(bss_info_list);
2176         Elm_Object_Item *item = NULL;
2177
2178         viewer_manager_hide(VIEWER_WINSET_SEARCHING);
2179         viewer_manager_header_mode_set(HEADER_MODE_ON);
2180
2181         if (view_hidden_ap_popup_data_get() == NULL) {
2182                 ERROR_LOG(UG_NAME_RESP, "Popup is already destroyed");
2183
2184                 g_free(user_data);
2185                 return;
2186         }
2187         /**
2188          * We will delete the popup anyway
2189          */
2190         view_hidden_ap_popup_destroy();
2191
2192         if (ssid == NULL) {
2193                 ERROR_LOG(UG_NAME_RESP, "SSID is empty");
2194                 return;
2195         }
2196
2197         INFO_LOG(UG_NAME_RESP, "Recieved %s(%d) hidden Wi-Fi networks",
2198                         ssid, hidden_ap_count);
2199         viewer_list_item_clear();
2200         hidden_ap_count = viewer_manager_update_list_all((char *)ssid);
2201         INFO_LOG(UG_NAME_NORMAL, "Found %s(%d) Wi-Fi networks", ssid,
2202                         hidden_ap_count);
2203
2204         if (hidden_ap_count > 1)
2205                 goto exit;
2206
2207         viewer_manager_refresh();
2208         if (hidden_ap_count == 0) {
2209                 INFO_LOG(UG_NAME_ERR, "no ap found");
2210                 common_utils_send_message_to_net_popup("Network connection popup",
2211                                 "no ap found", "toast_popup", NULL);
2212                 /*Recreate the popup*/
2213                 view_hidden_ap_popup_create(ug_app_state->layout_main, PACKAGE);
2214                 goto exit;
2215         }
2216
2217         item = item_get_for_ssid(ssid);
2218         if (item != NULL) {
2219                 gdata = elm_object_item_data_get(item);
2220                 if (gdata == NULL || gdata->device_info == NULL ||
2221                                 gdata->radio_mode == VIEWER_ITEM_RADIO_MODE_CONNECTED)
2222                         goto exit;
2223                 sec_mode = gdata->device_info->security_mode;
2224                 gdata->device_info->is_hidden = true;
2225                 wifi_manager_ap_is_favorite(gdata->device_info->ap, &favorite);
2226                 if (favorite == true) {
2227                         wlan_manager_connect(gdata->device_info->ap);
2228                         goto exit;
2229                 }
2230
2231                 /* Only if there is one AP found then we need Users further action */
2232                 switch (sec_mode) {
2233                 case WIFI_MANAGER_SECURITY_TYPE_NONE:
2234                         SECURE_INFO_LOG(UG_NAME_NORMAL, "%s open network found", ssid);
2235
2236                         hidden_ap_data = g_new0(hidden_ap_data_t, 1);
2237                         hidden_ap_data->sec_mode = sec_mode;
2238                         hidden_ap_data->ssid = g_strdup(ssid);
2239
2240                         popup_btn_info_t popup_btn_data;
2241                         memset(&popup_btn_data, 0, sizeof(popup_btn_data));
2242                         popup_btn_data.title_txt = g_strdup(ssid);
2243                         popup_btn_data.sub_title_txt = NULL;
2244                         popup_btn_data.info_txt = "IDS_WIFI_BODY_A_WI_FI_NETWORK_HAS_BEEN_DETECTED_YOU_WILL_BE_CONNECTED";
2245                         popup_btn_data.btn1_txt = "IDS_WIFI_SK_CANCEL";
2246                         popup_btn_data.btn1_cb = hidden_ap_connect_cancel_cb;
2247                         popup_btn_data.btn1_data = popup_btn_data.btn2_data = hidden_ap_data;
2248                         popup_btn_data.btn2_txt = "IDS_WIFI_BODY_CONNECT";
2249                         popup_btn_data.btn2_cb = hidden_ap_connect_ok_cb;
2250
2251                         popup = common_utils_show_info_popup(ug_app_state->layout_main,
2252                                                         &popup_btn_data);
2253                         g_free(popup_btn_data.title_txt);
2254
2255                         hidden_ap_data->confirm_popup  = popup;
2256
2257                         evas_object_event_callback_add(popup,
2258                                         EVAS_CALLBACK_MOUSE_UP,
2259                                         __hidden_ap_cancel_mouseup_cb,
2260                                         hidden_ap_data);
2261                         evas_object_event_callback_add(popup,
2262                                         EVAS_CALLBACK_KEY_DOWN,
2263                                         __hidden_ap_cancel_keydown_cb,
2264                                         hidden_ap_data);
2265
2266                         manager_object->hidden_popup_data = hidden_ap_data;
2267                         break;
2268
2269                 case WIFI_MANAGER_SECURITY_TYPE_EAP:
2270                         SECURE_INFO_LOG(UG_NAME_NORMAL, "%s IEEE8021X found", ssid);
2271
2272                         wifi_device_info_t device_info;
2273                         wifi_manager_ap_h ap;
2274
2275                         wlan_manager_ap_create(ssid, &ap);
2276                         wifi_manager_ap_set_security_type(ap, WIFI_MANAGER_SECURITY_TYPE_EAP);
2277
2278                         struct ug_data *ugd = (struct ug_data *)ug_app_state->gadget;
2279
2280                         memset(&device_info, 0, sizeof(device_info));
2281                         device_info.security_mode = WIFI_MANAGER_SECURITY_TYPE_EAP;
2282                         device_info.ssid = (char *)ssid;
2283                         device_info.ap = ap;
2284
2285                         UG_TYPE ug_type = wifi_get_ug_type();
2286                         ug_app_state->eap_view =
2287                                         create_eap_view(ug_type == UG_VIEW_OOBE ?
2288                                                         ug_app_state->parent_layout : ug_app_state->layout_main,
2289                                                         ugd->win_main,
2290                                                         ug_app_state->conformant,
2291                                                         PACKAGE, &device_info,
2292                                                         viewer_manager_eap_view_deref);
2293
2294                         wifi_manager_ap_destroy(ap);
2295
2296                         break;
2297
2298                 case WIFI_MANAGER_SECURITY_TYPE_WEP:
2299                 case WIFI_MANAGER_SECURITY_TYPE_WPA_PSK:
2300                 case WIFI_MANAGER_SECURITY_TYPE_WPA2_PSK:
2301                         SECURE_INFO_LOG(UG_NAME_NORMAL,
2302                                         "Secured(%d) %s found", sec_mode, ssid);
2303
2304                         pswd_popup_create_req_data_t popup_info;
2305
2306                         hidden_ap_data = g_try_new0(hidden_ap_data_t, 1);
2307                         if (hidden_ap_data == NULL) {
2308                                 ERROR_LOG(UG_NAME_RESP, "Memory allocation error.");
2309                                 goto exit;
2310                         }
2311                         hidden_ap_data->sec_mode = sec_mode;
2312                         hidden_ap_data->ssid = g_strdup(ssid);
2313                         if (gdata && gdata->device_info) {
2314                                 hidden_ap_data->device_info = view_list_item_device_info_create(
2315                                                 gdata->device_info->ap);
2316                         }
2317                         memset(&popup_info, 0, sizeof(pswd_popup_create_req_data_t));
2318                         /* Wi-Fi hidden network cannot be connected by WPS method.
2319                          * In addition, Wi-Fi network info is also impossible to be set.
2320                          * It's ConnMan agent limitation.
2321                          * Do not use WPS method in here.
2322                          */
2323                         popup_info.title = (char *)ssid;
2324                         popup_info.sub_title = common_utils_get_ap_security_type_info_txt(PACKAGE,
2325                                         gdata->device_info, false);
2326                         popup_info.ok_cb = hidden_ap_connect_ok_cb;
2327                         popup_info.cancel_cb = hidden_ap_connect_cancel_cb;
2328                         popup_info.cb_data = hidden_ap_data;
2329                         popup_info.sec_type = sec_mode;
2330
2331                         ug_app_state->passpopup =
2332                                         create_passwd_popup(
2333                                                         ug_app_state->conformant,
2334                                                         ug_app_state->layout_main,
2335                                                         PACKAGE, &popup_info);
2336                         if (ug_app_state->passpopup == NULL)
2337                                 INFO_LOG(UG_NAME_ERR, "Fail to create password popup");
2338
2339                         manager_object->hidden_popup_data = hidden_ap_data;
2340                         g_free(popup_info.sub_title);
2341                         break;
2342
2343                 default:
2344                         INFO_LOG(UG_NAME_NORMAL, "Unknown security mode: %d", sec_mode);
2345                         break;
2346                 }
2347         }
2348
2349 exit:
2350         g_free(user_data);
2351 }
2352
2353 wifi_device_info_t *view_list_item_device_info_create(wifi_manager_ap_h ap)
2354 {
2355         int ret = false;
2356         wifi_device_info_t* wifi_device = NULL;
2357
2358         if (ap != NULL) {
2359                 wifi_device = g_try_new0(wifi_device_info_t, 1);
2360                 retvm_if(NULL == wifi_device, NULL);
2361
2362                 if (WIFI_MANAGER_ERROR_NONE != wifi_manager_ap_clone(&(wifi_device->ap), ap))
2363                         goto FREE_DEVICE_INFO;
2364                 else if (WIFI_MANAGER_ERROR_NONE != wifi_manager_ap_get_essid(ap, &(wifi_device->ssid)))
2365                         goto FREE_DEVICE_INFO;
2366                 else if (WIFI_MANAGER_ERROR_NONE != wifi_manager_ap_get_rssi(ap, &(wifi_device->rssi)))
2367                         goto FREE_DEVICE_INFO;
2368                 else if (WIFI_MANAGER_ERROR_NONE != wifi_manager_ap_get_security_type(ap, &(wifi_device->security_mode)))
2369                         goto FREE_DEVICE_INFO;
2370                 else if (WIFI_MANAGER_ERROR_NONE != wifi_manager_ap_is_wps_supported(ap, &(wifi_device->wps_mode)))
2371                         goto FREE_DEVICE_INFO;
2372
2373                 common_utils_get_device_icon(wifi_device, &wifi_device->ap_image_path);
2374         }
2375         ret = true;
2376
2377 FREE_DEVICE_INFO:
2378         if (ret == false && wifi_device) {
2379                 wifi_manager_ap_destroy(wifi_device->ap);
2380                 g_free(wifi_device->ap_image_path);
2381                 g_free(wifi_device->ap_status_txt);
2382                 g_free(wifi_device->ssid);
2383                 g_free(wifi_device);
2384                 wifi_device = NULL;
2385
2386                 return NULL;
2387         }
2388
2389         return wifi_device;
2390 }
2391
2392 view_manager_view_type_t viewer_manager_view_type_get(void)
2393 {
2394         __COMMON_FUNC_ENTER__;
2395
2396         Evas_Object* navi_frame = NULL;
2397         view_manager_view_type_t top_view_id;
2398
2399         navi_frame = viewer_manager_get_naviframe();
2400         top_view_id = (view_manager_view_type_t)evas_object_data_get(
2401                                                         navi_frame,
2402                                                         SCREEN_TYPE_ID_KEY);
2403
2404         __COMMON_FUNC_EXIT__;
2405         return top_view_id;
2406 }
2407
2408 void viewer_manager_request_scan(void)
2409 {
2410         __COMMON_FUNC_ENTER__;
2411
2412         HEADER_MODES current_state;
2413
2414         current_state = viewer_manager_header_mode_get();
2415
2416         if (current_state == HEADER_MODE_ON ||
2417                         current_state == HEADER_MODE_CONNECTED) {
2418                 int scan_result;
2419
2420                 INFO_LOG(UG_NAME_NORMAL, "Time to make a scan..");
2421
2422                 viewer_manager_show(VIEWER_WINSET_SEARCHING_GRP_TITLE);
2423                 viewer_manager_header_mode_set(HEADER_MODE_SEARCHING);
2424
2425                 scan_result = wlan_manager_scan();
2426                 if (scan_result != WLAN_MANAGER_ERR_NONE)
2427                         viewer_manager_header_mode_set(current_state);
2428         }
2429
2430         __COMMON_FUNC_EXIT__;
2431 }
2432
2433 void viewer_manager_ctxpopup_cleanup(void)
2434 {
2435         if (manager_object->ctxpopup) {
2436                 evas_object_del(manager_object->ctxpopup);
2437                 manager_object->ctxpopup = NULL;
2438         }
2439 }
2440
2441 void viewer_manager_hidden_confirm_cleanup(void)
2442 {
2443         if (manager_object == NULL)
2444                 return;
2445
2446         hidden_ap_data_t *hidden_data = manager_object->hidden_popup_data;
2447
2448         if (hidden_data != NULL) {
2449                 if (hidden_data->confirm_popup != NULL) {
2450                         evas_object_del(hidden_data->confirm_popup);
2451                         hidden_data->confirm_popup = NULL;
2452                 }
2453
2454                 if (hidden_data->device_info)
2455                         g_free(hidden_data->device_info);
2456                 g_free(hidden_data->ssid);
2457                 g_free(hidden_data);
2458
2459                 manager_object->hidden_popup_data = NULL;
2460         }
2461 }
2462
2463 void viewer_manager_cleanup_views(void)
2464 {
2465         viewer_manager_ctxpopup_cleanup();
2466
2467         viewer_manager_pop_naviframe_item();
2468         view_hidden_ap_popup_delete();
2469         viewer_manager_hidden_confirm_cleanup();
2470 }
2471
2472 void viewer_manager_rotate_top_setupwizard_layout(void)
2473 {
2474         Evas_Object *layout = NULL;
2475         struct ug_data *ugd;
2476         int change_ang = 0;
2477         Elm_Object_Item *navi_it = NULL;
2478
2479         navi_it = elm_naviframe_top_item_get(manager_object->nav);
2480         layout = elm_object_item_content_get(navi_it);
2481
2482         ugd = (struct ug_data *)ug_app_state->gadget;
2483         change_ang = elm_win_rotation_get(ugd->win_main);
2484         if (change_ang == 0 || change_ang == 180) {
2485                 common_utils_contents_rotation_adjust(UG_EVENT_ROTATE_PORTRAIT);
2486                 edje_object_signal_emit((Evas_Object *)elm_layout_edje_get(layout),
2487                                         "location,vertical", "elm");
2488         } else {
2489                 common_utils_contents_rotation_adjust(UG_EVENT_ROTATE_LANDSCAPE);
2490                 edje_object_signal_emit((Evas_Object *)elm_layout_edje_get(layout),
2491                                 "location,horizontal", "elm");
2492         }
2493 }