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