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