sources/wifi-syspopup/wifi-syspopup.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 <wifi-manager.h>
  21 #include <vconf.h>
  22 #include <vconf-keys.h>
  23 #include <appcore-efl.h>
  24 #include <ui-gadget-module.h>
  25 #include <efl_util.h>
  26 #include <efl_extension.h>
  27
  28 #include "common.h"
  29 #include "view-main.h"
  30 #include "i18nmanager.h"
  31 #include "view-alerts.h"
  32 #include "common_utils.h"
  33 #include "wlan_manager.h"
  34 #include "wifi-syspopup.h"
  35 #include "appcoreWrapper.h"
  36 #include "wifi-syspopup-engine-callback.h"
  37
  38 typedef enum {
  39         SIZE_INDEX_SMALL = 0,
  40         SIZE_INDEX_NORMAL,
  41         SIZE_INDEX_LARGE,
  42         SIZE_INDEX_HUGE,
  43         SIZE_INDEX_GIANT
  44 } font_size_index;
  45
  46 #define FONT_SIZE_SMALL_GENLIST_H 96
  47 #define FONT_SIZE_NORMAL_GENLIST_H 96
  48 #define FONT_SIZE_LARGE_GENLIST_H 163
  49 #define FONT_SIZE_HUGE_GENLIST_H 182
  50 #define FONT_SIZE_GIANT_GENLIST_H 216
  51 #define FONT_SIZE_SMALL_GRP_TITLE_GENLIST_H 51
  52 #define FONT_SIZE_NORMAL_GRP_TITLE_GENLIST_H 51
  53 #define FONT_SIZE_LARGE_GRP_TITLE_GENLIST_H 95
  54 #define FONT_SIZE_HUGE_GRP_TITLE_GENLIST_H 108
  55 #define FONT_SIZE_GIANT_GRP_TITLE_GENLIST_H 132
  56
  57 wifi_object* devpkr_app_state = NULL;
  58
  59 Ecore_Event_Handler* event_handler = NULL;
  60
  61 static void __idle_lock_state_change_cb(keynode_t *node, void *user_data);
  62
  63 static gboolean __del_found_ap_noti(void *data)
  64 {
  65         common_utils_send_message_to_net_popup(NULL, NULL, "del_found_ap_noti",
  66                         NULL);
  67
  68         return FALSE;
  69 }
  70
  71 gboolean wifi_devpkr_get_scan_status(void)
  72 {
  73         Evas_Object *btn_scan = NULL;
  74         Eina_Bool status = EINA_FALSE;
  75         gboolean ret = FALSE;
  76
  77         btn_scan = elm_object_part_content_get(devpkr_app_state->popup,
  78                         "button2");
  79         status = elm_object_disabled_get(btn_scan);
  80
  81         if (status == EINA_TRUE)
  82                 ret = TRUE;
  83
  84         return ret;
  85 }
  86
  87 void wifi_devpkr_enable_scan_btn(void)
  88 {
  89         Evas_Object *btn_scan = NULL;
  90
  91         btn_scan = elm_object_part_content_get(devpkr_app_state->popup,
  92                         "button2");
  93         elm_object_disabled_set(btn_scan, EINA_FALSE);
  94 }
  95
  96 void wifi_devpkr_disable_scan_btn(void)
  97 {
  98         Evas_Object *btn_scan = NULL;
  99
 100         btn_scan = elm_object_part_content_get(devpkr_app_state->popup,
 101                         "button2");
 102         elm_object_disabled_set(btn_scan, EINA_TRUE);
 103 }
 104
 105 static void _scan_cb(void *data, Evas_Object *obj, void *event_info)
 106 {
 107         __COMMON_FUNC_ENTER__;
 108
 109         int scan_result;
 110
 111         wifi_devpkr_disable_scan_btn();
 112         view_main_update_group_title(FALSE);
 113
 114         scan_result = wlan_manager_scan();
 115         if (scan_result != WLAN_MANAGER_ERR_NONE) {
 116                 wifi_devpkr_enable_scan_btn();
 117                 ERROR_LOG(SP_NAME_ERR, "Scan failed");
 118         }
 119
 120         __COMMON_FUNC_EXIT__;
 121 }
 122
 123 static int __wifi_devpkr_calculate_height(int rotate_angle,
 124                 int profile_count)
 125 {
 126         int height = 0;
 127         int item_h = 0;
 128         int grp_title_h = 0;
 129         int x = 0;
 130         font_size_index font_index;
 131         double scale = elm_config_scale_get();
 132
 133         if (profile_count == 0)
 134                 height = (int)(DEVICE_PICKER_EMPTY_POPUP_H * scale);
 135
 136         vconf_get_int(VCONFKEY_SETAPPL_ACCESSIBILITY_FONT_SIZE, &x);
 137         font_index = x;
 138
 139         switch (font_index) {
 140         case SIZE_INDEX_SMALL:
 141                 item_h = (int)(FONT_SIZE_SMALL_GENLIST_H * scale);
 142                 grp_title_h = (int)(FONT_SIZE_SMALL_GRP_TITLE_GENLIST_H * scale);
 143                 break;
 144         case SIZE_INDEX_NORMAL:
 145                 item_h = (int)(FONT_SIZE_NORMAL_GENLIST_H * scale);
 146                 grp_title_h = (int)(FONT_SIZE_NORMAL_GRP_TITLE_GENLIST_H * scale);
 147                 break;
 148         case SIZE_INDEX_LARGE:
 149                 item_h = (int)(FONT_SIZE_LARGE_GENLIST_H * scale);
 150                 grp_title_h = (int)(FONT_SIZE_LARGE_GRP_TITLE_GENLIST_H * scale);
 151                 break;
 152         case SIZE_INDEX_HUGE:
 153                 item_h = (int)(FONT_SIZE_HUGE_GENLIST_H * scale);
 154                 grp_title_h = (int)(FONT_SIZE_HUGE_GRP_TITLE_GENLIST_H * scale);
 155                 break;
 156         case SIZE_INDEX_GIANT:
 157                 item_h = (int)(FONT_SIZE_GIANT_GENLIST_H * scale);
 158                 grp_title_h = (int)(FONT_SIZE_GIANT_GRP_TITLE_GENLIST_H * scale);
 159                 break;
 160         default:
 161                 item_h = (int)(FONT_SIZE_NORMAL_GENLIST_H * scale);
 162                 grp_title_h = (int)(FONT_SIZE_NORMAL_GRP_TITLE_GENLIST_H * scale);
 163         }
 164
 165         if (profile_count) {
 166                 height = profile_count * item_h;
 167                 height += grp_title_h;
 168         } else if (wifi_devpkr_get_scan_status() == TRUE) {
 169                 height += grp_title_h;
 170         }
 171
 172         if (0 == rotate_angle || 180 == rotate_angle) {
 173                 if (height > DEVICE_PICKER_POPUP_H)
 174                         height = DEVICE_PICKER_POPUP_H * scale;
 175         } else {
 176                 if (height > DEVICE_PICKER_POPUP_LN_H)
 177                         height = DEVICE_PICKER_POPUP_LN_H * scale;
 178         }
 179
 180         return height;
 181 }
 182
 183 static void wifi_devpkr_rotate_cb(void *data, Evas_Object *obj, void *event)
 184 {
 185         int rotate_angle;
 186         Evas_Object *box = NULL;
 187         int profile_count = 0;
 188         int height = 0;
 189
 190         if (obj == NULL)
 191                 return;
 192
 193         rotate_angle = elm_win_rotation_get(obj);
 194         box = elm_object_content_get(devpkr_app_state->popup);
 195
 196         profile_count = view_main_get_profile_count();
 197         INFO_LOG(SP_NAME_NORMAL, "Profiles count: %d", profile_count);
 198
 199         height = __wifi_devpkr_calculate_height(rotate_angle, profile_count);
 200
 201         evas_object_size_hint_min_set(box, -1, height);
 202
 203         if (0 == rotate_angle || 180 == rotate_angle)
 204                 common_utils_contents_rotation_adjust(UG_EVENT_ROTATE_PORTRAIT);
 205         else
 206                 common_utils_contents_rotation_adjust(UG_EVENT_ROTATE_LANDSCAPE);
 207
 208         INFO_LOG(SP_NAME_NORMAL, "rotate_angle: %d", rotate_angle);
 209 }
 210
 211 /* Tizen 2.4's setting supports auto rotate mode */
 212 #if 0
 213 static void wifi_devpkr_set_rotation(Evas_Object *win)
 214 {
 215         if (!elm_win_wm_rotation_supported_get(win))
 216                 return;
 217
 218         elm_win_wm_rotation_preferred_rotation_set(win, 0);
 219 }
 220 #endif
 221
 222 static void _exit_cb(void *data, Evas_Object *obj, void *event_info)
 223 {
 224         __COMMON_FUNC_ENTER__;
 225
 226         wifi_devpkr_destroy();
 227
 228         __COMMON_FUNC_EXIT__;
 229 }
 230
 231 static void __idle_lock_state_change_cb(keynode_t *node, void *user_data)
 232 {
 233         __COMMON_FUNC_ENTER__;
 234
 235         int lock_state = 0;
 236
 237         if (vconf_get_int(VCONFKEY_IDLE_LOCK_STATE, &lock_state) != 0)
 238                 ERROR_LOG(UG_NAME_NORMAL, "Failed to get vconf");
 239
 240         if (VCONFKEY_IDLE_LOCK == lock_state)
 241                 wifi_devpkr_destroy();
 242
 243         __COMMON_FUNC_EXIT__;
 244 }
 245
 246 void wifi_devpkr_redraw(void)
 247 {
 248         __COMMON_FUNC_ENTER__;
 249
 250         wifi_devpkr_rotate_cb(NULL, devpkr_app_state->win_main, NULL);
 251
 252         __COMMON_FUNC_EXIT__;
 253 }
 254
 255 int wifi_devpkr_destroy(void)
 256 {
 257         if (VCONFKEY_WIFI_QS_WIFI_CONNECTED == devpkr_app_state->connection_result) {
 258                 INFO_LOG(SP_NAME_NORMAL, "Wi-Fi connected");
 259         } else if (VCONFKEY_WIFI_QS_3G == devpkr_app_state->connection_result) {
 260                 INFO_LOG(SP_NAME_NORMAL, "Cellular connected");
 261         } else {
 262                 WARN_LOG(SP_NAME_NORMAL, "Result: [%d]",
 263                                 devpkr_app_state->connection_result);
 264
 265                 devpkr_app_state->connection_result = VCONFKEY_WIFI_QS_3G;
 266         }
 267
 268         view_main_clear_disconnect_popup(NULL);
 269
 270         if (event_handler != NULL)
 271                 ecore_event_handler_del(event_handler);
 272
 273         common_util_set_system_registry("memory/wifi/wifi_qs_exit",
 274                         devpkr_app_state->connection_result);
 275
 276         vconf_ignore_key_changed(VCONFKEY_IDLE_LOCK_STATE, __idle_lock_state_change_cb);
 277
 278         connman_request_scan_mode_set(WIFI_BGSCAN_MODE_EXPONENTIAL);
 279
 280         elm_exit();
 281
 282         return 1;
 283 }
 284
 285 static void __keydown_cb(void *data, Evas_Object *obj, void *event_info)
 286 {
 287         __COMMON_FUNC_ENTER__;
 288
 289         wifi_devpkr_destroy();
 290
 291         __COMMON_FUNC_EXIT__;
 292 }
 293
 294 static Eina_Bool __key_press_cb(void *data, int type, void *event)
 295 {
 296         __COMMON_FUNC_ENTER__;
 297         Evas_Event_Key_Down *ev = event;
 298         if (!ev)
 299                 return ECORE_CALLBACK_RENEW;
 300
 301         if (strcmp(ev->keyname, "XF86Home") == 0)
 302                 wifi_devpkr_destroy();
 303
 304         __COMMON_FUNC_EXIT__;
 305         return ECORE_CALLBACK_RENEW;
 306
 307 }
 308
 309 static int wifi_devpkr_create(void)
 310 {
 311         __COMMON_FUNC_ENTER__;
 312
 313         Evas_Object *btn_scan = NULL;
 314         Evas_Object *btn_cancel = NULL;
 315
 316         if (NULL == devpkr_app_state->popup) {
 317                 devpkr_app_state->popup = elm_popup_add(devpkr_app_state->layout_main);
 318                 elm_object_content_set(devpkr_app_state->layout_main, devpkr_app_state->popup);
 319                 assertm_if(NULL == devpkr_app_state->popup, "syspopup is NULL!!");
 320         }
 321
 322         eext_object_event_callback_add(devpkr_app_state->popup, EEXT_CALLBACK_BACK,
 323                         __keydown_cb, NULL);
 324
 325         event_handler = ecore_event_handler_add(ECORE_EVENT_KEY_DOWN, __key_press_cb, NULL);
 326
 327         elm_object_style_set(devpkr_app_state->popup, "default");
 328         elm_object_part_text_set(devpkr_app_state->popup, "title,text", sc(PACKAGE, I18N_TYPE_Wi_Fi));
 329         evas_object_size_hint_weight_set(devpkr_app_state->popup, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
 330
 331         btn_cancel = elm_button_add(devpkr_app_state->popup);
 332         elm_object_style_set(btn_cancel, "popup");
 333         elm_object_text_set(btn_cancel, sc(PACKAGE, I18N_TYPE_Cancel));
 334         elm_object_part_content_set(devpkr_app_state->popup, "button1", btn_cancel);
 335         evas_object_smart_callback_add(btn_cancel, "clicked", _exit_cb, NULL);
 336
 337         btn_scan = elm_button_add(devpkr_app_state->popup);
 338         elm_object_style_set(btn_scan, "popup");
 339         elm_object_text_set(btn_scan, sc(PACKAGE, I18N_TYPE_Scan));
 340         elm_object_part_content_set(devpkr_app_state->popup, "button2", btn_scan);
 341         evas_object_smart_callback_add(btn_scan, "clicked", _scan_cb, NULL);
 342
 343         view_main_create_main_list();
 344
 345 /* Tizen 2.4's setting supports auto rotate mode */
 346 #if 0
 347         wifi_devpkr_set_rotation(devpkr_app_state->win_main);
 348 #endif
 349         wifi_devpkr_redraw();
 350
 351         elm_win_indicator_mode_set(devpkr_app_state->win_main, ELM_WIN_INDICATOR_SHOW);
 352         elm_win_indicator_opacity_set(devpkr_app_state->win_main, ELM_WIN_INDICATOR_TRANSPARENT);
 353
 354         vconf_notify_key_changed(VCONFKEY_IDLE_LOCK_STATE, __idle_lock_state_change_cb, NULL);
 355
 356         __COMMON_FUNC_EXIT__;
 357         return 1;
 358 }
 359
 360 static void _bg_scan_status_callback(GDBusConnection *conn,
 361                 const gchar *name, const gchar *path, const gchar *interface,
 362                 const gchar *sig, GVariant *param, gpointer user_data)
 363 {
 364         __COMMON_FUNC_ENTER__;
 365
 366         GVariantIter *iter = NULL;
 367         GVariant *var = NULL;
 368         gchar *key = NULL;
 369         gboolean value = FALSE;
 370
 371         if (NULL == devpkr_app_state) {
 372                 INFO_LOG(SP_NAME_ERR, "devpkr_app_state is NULL!! Is it test mode?");
 373
 374                 __COMMON_FUNC_EXIT__;
 375                 return;
 376         }
 377
 378         g_variant_get(param, "(a{sv})", &iter);
 379         while (g_variant_iter_loop(iter, "{sv}", &key, &var)) {
 380                 if (g_strcmp0(key, "Scanning") == 0) {
 381                         value = g_variant_get_boolean(var);
 382                         if (value) {
 383                                 wifi_devpkr_disable_scan_btn();
 384                                 view_main_update_group_title(TRUE);
 385                         } else
 386                                 wifi_devpkr_enable_scan_btn();
 387
 388                         g_variant_unref(var);
 389                         g_free(key);
 390                         break;
 391                 }
 392         }
 393
 394         g_variant_iter_free(iter);
 395
 396         __COMMON_FUNC_EXIT__;
 397 }
 398
 399 static int wifi_devpkr_init()
 400 {
 401         __COMMON_FUNC_ENTER__;
 402
 403         int wlan_ret;
 404         bool activated = FALSE;
 405
 406         wlan_manager_create();
 407         wlan_manager_set_message_callback(wlan_engine_callback);
 408         wlan_manager_set_refresh_callback(wlan_engine_refresh_callback);
 409
 410         wlan_ret = wlan_manager_start();
 411         switch (wlan_ret) {
 412         case WLAN_MANAGER_ERR_ALREADY_REGISTERED:
 413                 ERROR_LOG(SP_NAME_ERR, "Already registered.");
 414                 /* fall through */
 415         case WLAN_MANAGER_ERR_NONE:
 416                 wlan_ret = wlan_manager_is_activated(&activated);
 417                 if (WIFI_MANAGER_ERROR_NONE == wlan_ret) {
 418                         INFO_LOG(SP_NAME_NORMAL, "Wi-Fi activated: %d", activated);
 419                         if (activated)
 420                                 wlan_manager_scan();
 421                 }
 422                 INFO_LOG(SP_NAME_NORMAL, "wlan_manager start complete");
 423                 break;
 424
 425         default:
 426                 ERROR_LOG(SP_NAME_ERR, "Failed to start wlan_manager (%d)", wlan_ret);
 427                 break;
 428         }
 429
 430         connman_request_scan_mode_set(WIFI_BGSCAN_MODE_PERIODIC);
 431
 432         __COMMON_FUNC_EXIT__;
 433         return wlan_ret;
 434 }
 435
 436 #if 0
 437 /* TODO: Check if bundle paramter check is required later:
 438  * "[Wi-Fi_syspopup wifi_syspopup_supports:support]"
 439  */
 440 static int devpkr_support_set(const char* support)
 441 {
 442         __COMMON_FUNC_ENTER__;
 443
 444         if (NULL == support) {
 445                 __COMMON_FUNC_EXIT__;
 446                 return 0;
 447         }
 448
 449         if (g_strcmp0("WIFI_SYSPOPUP_SUPPORT_QUICKPANEL", support) == 0) {
 450                 devpkr_app_state->wifi_devpkr_support =
 451                         WIFI_DEVPKR_SUPPORT_QUICKPANEL;
 452         } else {
 453                 __COMMON_FUNC_EXIT__;
 454                 return 0;
 455         }
 456
 457         __COMMON_FUNC_EXIT__;
 458         return 1;
 459 }
 460 #endif
 461
 462 static gboolean _power_on_check(void)
 463 {
 464         int connection_state;
 465
 466         connection_state = wlan_manager_state_get();
 467         switch (connection_state) {
 468         case WLAN_MANAGER_OFF:
 469                 INFO_LOG(SP_NAME_NORMAL, "current state is wifi-off");
 470
 471                 int wlan_ret = wlan_manager_power_on();
 472                 if (wlan_ret == WLAN_MANAGER_ERR_NONE) {
 473                         view_alerts_powering_on_show();
 474
 475                         __COMMON_FUNC_EXIT__;
 476                         return TRUE;
 477 #if defined TIZEN_TETHERING_ENABLE
 478                 } else if (wlan_ret == WLAN_MANAGER_ERR_WIFI_TETHERING_OCCUPIED) {
 479                         __COMMON_FUNC_EXIT__;
 480                         return TRUE;
 481                 } else if (wlan_ret == WLAN_MANAGER_ERR_WIFI_AP_TETHERING_OCCUPIED) {
 482                         __COMMON_FUNC_EXIT__;
 483                         return TRUE;
 484 #endif
 485                 } else {
 486                         __COMMON_FUNC_EXIT__;
 487                         return FALSE;
 488                 }
 489                 break;
 490
 491         case WLAN_MANAGER_UNCONNECTED:
 492         case WLAN_MANAGER_CONNECTING:
 493                 __COMMON_FUNC_EXIT__;
 494                 return TRUE;
 495
 496         case WLAN_MANAGER_CONNECTED:
 497                 ERROR_LOG(SP_NAME_NORMAL, "current state is wifi-connected");
 498
 499                 __COMMON_FUNC_EXIT__;
 500                 return FALSE;
 501
 502         case WLAN_MANAGER_ERROR:
 503                 ERROR_LOG(SP_NAME_NORMAL, "current state is wifi error");
 504
 505                 __COMMON_FUNC_EXIT__;
 506                 return FALSE;
 507
 508         default:
 509                 ERROR_LOG(SP_NAME_NORMAL, "current state is wifi etc");
 510
 511                 __COMMON_FUNC_EXIT__;
 512                 return FALSE;
 513         }
 514
 515         __COMMON_FUNC_EXIT__;
 516         return TRUE;
 517 }
 518
 519 static gboolean load_initial_ap_list(void)
 520 {
 521         __COMMON_FUNC_ENTER__;
 522
 523         wlan_manager_scanned_profile_refresh();
 524
 525         __COMMON_FUNC_EXIT__;
 526         return FALSE;
 527 }
 528
 529 static void app_control(app_control_h request, void *data)
 530 {
 531         __COMMON_FUNC_ENTER__;
 532
 533         Evas_Object *win_main = NULL;
 534         Evas *evas = NULL;
 535         char *caller = NULL;
 536
 537         assertm_if(NULL == data, "data param is NULL!!");
 538
 539         devpkr_app_state = data;
 540
 541         INFO_LOG(SP_NAME_NORMAL, "Creating device-picker popup");
 542
 543         if (NULL != devpkr_app_state->win_main) {
 544                 INFO_LOG(SP_NAME_ERR, "Don't create device picker again");
 545                 goto second_launch;
 546         }
 547
 548         win_main = appcore_create_win(PACKAGE, ELM_WIN_NOTIFICATION);
 549
 550         assertm_if(NULL == win_main, "win_main is NULL!!");
 551         evas = evas_object_evas_get(win_main);
 552         assertm_if(NULL == evas, "evas is NULL!!");
 553
 554         devpkr_app_state->win_main = win_main;
 555         devpkr_app_state->evas = evas;
 556
 557         elm_win_alpha_set(devpkr_app_state->win_main, EINA_TRUE); /* invisible window */
 558
 559         efl_util_set_notification_window_level(win_main, EFL_UTIL_NOTIFICATION_LEVEL_DEFAULT);
 560
 561         elm_win_borderless_set(devpkr_app_state->win_main, EINA_TRUE); /* No borders */
 562         elm_win_conformant_set(devpkr_app_state->win_main, TRUE); /* Popup autoscroll */
 563
 564         Evas_Object *conformant = elm_conformant_add(devpkr_app_state->win_main);
 565         elm_win_conformant_set(devpkr_app_state->win_main, EINA_TRUE);
 566         elm_win_resize_object_add(devpkr_app_state->win_main, conformant);
 567         evas_object_size_hint_weight_set(conformant, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
 568         evas_object_size_hint_align_set(conformant, EVAS_HINT_FILL, EVAS_HINT_FILL);
 569         devpkr_app_state->conformant = conformant;
 570
 571         Evas_Object *layout = elm_layout_add(conformant);
 572         elm_object_content_set(conformant, layout);
 573         devpkr_app_state->layout_main = layout;
 574
 575         /* TODO: Check if the parameter check '-t' is required later */
 576
 577         devpkr_app_state->devpkr_type = WIFI_DEVPKR_WITH_AP_LIST;
 578
 579         int wlan_ret = wifi_devpkr_init();
 580         if (WLAN_MANAGER_ERR_NONE != wlan_ret || _power_on_check() == FALSE) {
 581                 INFO_LOG(SP_NAME_ERR, "failed to wifi_devpkr_init()");
 582                 goto exit;
 583         }
 584
 585         devpkr_app_state->popup = elm_popup_add(devpkr_app_state->win_main);
 586
 587         evas_object_show(devpkr_app_state->win_main);
 588         evas_object_show(devpkr_app_state->conformant);
 589
 590         /* TODO: Check if below bundle parameter check is required later:
 591          * "[Wi-Fi_syspopup wifi_syspopup_supports:support]" */
 592
 593         wifi_devpkr_create();
 594
 595         load_initial_ap_list();
 596
 597 second_launch:
 598         if (request != NULL) {
 599                 app_control_get_extra_data(request, "caller", &caller);
 600                 INFO_LOG(SP_NAME_NORMAL, "caller - [%s]", caller);
 601
 602                 if (caller != NULL) {
 603                         /* Remove the "WiFi networks found" from
 604                          * the notification tray.*/
 605                         if (strcmp(caller, "notification") == 0) {
 606                                 common_util_managed_idle_add(
 607                                                 __del_found_ap_noti, NULL);
 608                         }
 609                         free(caller);
 610                 }
 611         }
 612
 613         __COMMON_FUNC_EXIT__;
 614         return;
 615
 616 exit:
 617         wifi_devpkr_destroy();
 618         __COMMON_FUNC_EXIT__;
 619
 620         return;
 621 }
 622
 623 static bool app_create(void *data)
 624 {
 625         __COMMON_FUNC_ENTER__;
 626
 627         bindtextdomain(PACKAGE, LOCALEDIR);
 628
 629         __COMMON_FUNC_EXIT__;
 630         return true;
 631 }
 632
 633 static void app_terminate(void *data)
 634 {
 635         __COMMON_FUNC_ENTER__;
 636
 637         if (devpkr_app_state->passpopup) {
 638                 passwd_popup_free(devpkr_app_state->passpopup);
 639                 devpkr_app_state->passpopup = NULL;
 640         }
 641
 642         if (devpkr_app_state->win_main) {
 643                 evas_object_del(devpkr_app_state->win_main);
 644                 devpkr_app_state->win_main = NULL;
 645         }
 646
 647         if (devpkr_app_state->popup) {
 648                 evas_object_del(devpkr_app_state->popup);
 649                 devpkr_app_state->popup = NULL;
 650         }
 651
 652         if (devpkr_app_state->alertpopup) {
 653                 evas_object_del(devpkr_app_state->alertpopup);
 654                 devpkr_app_state->alertpopup = NULL;
 655         }
 656
 657         if (devpkr_app_state->eap_popup) {
 658                 eap_connect_data_free(devpkr_app_state->eap_popup);
 659                 devpkr_app_state->eap_popup = NULL;
 660         }
 661
 662         common_util_managed_idle_cleanup();
 663         common_util_managed_ecore_scan_update_timer_del();
 664         wlan_manager_destroy();
 665
 666         __COMMON_FUNC_EXIT__;
 667         return;
 668 }
 669
 670 static void app_pause(void *data)
 671 {
 672         __COMMON_FUNC_ENTER__;
 673
 674         connman_request_scan_mode_set(WIFI_BGSCAN_MODE_EXPONENTIAL);
 675
 676         __COMMON_FUNC_EXIT__;
 677         return;
 678 }
 679
 680 static void app_resume(void *data)
 681 {
 682         __COMMON_FUNC_ENTER__;
 683
 684         connman_request_scan_mode_set(WIFI_BGSCAN_MODE_PERIODIC);
 685
 686         __COMMON_FUNC_EXIT__;
 687         return;
 688 }
 689
 690 EXPORT_API int main(int argc, char *argv[])
 691 {
 692         __COMMON_FUNC_ENTER__;
 693
 694         INFO_LOG(SP_NAME_NORMAL, "argc [%d]", argc);
 695
 696         wifi_object ad;
 697         memset(&ad, 0x0, sizeof(wifi_object));
 698
 699         ad.connection_result = VCONFKEY_WIFI_QS_3G;
 700         ad.win_main = NULL;
 701         ad.evas = NULL;
 702         ad.popup = NULL;
 703         ad.passpopup = NULL;
 704         ad.alertpopup = NULL;
 705
 706         ui_app_lifecycle_callback_s app_callback = {
 707                 .create = app_create,
 708                 .terminate = app_terminate,
 709                 .pause = app_pause,
 710                 .resume = app_resume,
 711                 .app_control = app_control,
 712         };
 713
 714         return ui_app_main(argc, argv, &app_callback, &ad);
 715 }