sources/ui-gadget/wifi-efl-UG.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 #ifndef UG_MODULE_API
  21 #define UG_MODULE_API __attribute__ ((visibility("default")))
  22 #endif
  23
  24 #include <vconf-keys.h>
  25 //#include <setting-cfg.h>
  26 #include "ug_wifi.h"
  27 #include "view_detail.h"
  28 #include "i18nmanager.h"
  29 #include "wlan_manager.h"
  30 #include "winset_popup.h"
  31 #include "common_utils.h"
  32 #include "viewer_manager.h"
  33 #include "view_ime_hidden.h"
  34 #include "view_advanced.h"
  35 #include "wifi-engine-callback.h"
  36
  37 #define STR_ATOM_PANEL_SCROLLABLE_STATE "_E_MOVE_PANEL_SCROLLABLE_STATE"
  38
  39 static int wifi_exit_end = FALSE;
  40 static bool is_scan_reqd = false;
  41 wifi_appdata *ug_app_state = NULL;
  42
  43 UG_MODULE_API int UG_MODULE_INIT(struct ug_module_ops *ops);
  44 UG_MODULE_API void UG_MODULE_EXIT(struct ug_module_ops *ops);
  45 UG_MODULE_API int setting_plugin_reset(bundle *data, void *priv);
  46 UG_MODULE_API int setting_plugin_search_init(app_control_h app_control, void *priv, char **domainname);
  47
  48 static gboolean __wifi_efl_ug_del_found_ap_noti(void *data)
  49 {
  50         common_utils_send_message_to_net_popup(NULL, NULL,
  51                         "del_found_ap_noti", NULL);
  52
  53         return FALSE;
  54 }
  55
  56 static void _bg_scan_status_callback(GDBusConnection *conn,
  57                 const gchar *name, const gchar *path, const gchar *interface,
  58                 const gchar *sig, GVariant *param, gpointer user_data)
  59 {
  60         __COMMON_FUNC_ENTER__;
  61
  62         GVariantIter *iter = NULL;
  63         GVariant *var = NULL;
  64         gchar *key = NULL;
  65         gboolean value = FALSE;
  66
  67         int header_mode = viewer_manager_header_mode_get();
  68         viewer_manager_create_scan_btn();
  69         if (header_mode == HEADER_MODE_DEACTIVATING ||
  70                         header_mode == HEADER_MODE_OFF) {
  71                 __COMMON_FUNC_EXIT__;
  72                 return;
  73         }
  74
  75         g_variant_get(param, "(a{sv})", &iter);
  76         while (g_variant_iter_loop(iter, "{sv}", &key, &var)) {
  77                 if (g_strcmp0(key, "Scanning") == 0) {
  78                         value = g_variant_get_boolean(var);
  79                         if (value) {
  80                                 if (header_mode != HEADER_MODE_CONNECTING) {
  81                                         viewer_manager_show(VIEWER_WINSET_SEARCHING_GRP_TITLE);
  82                                         viewer_manager_header_mode_set(HEADER_MODE_SEARCHING);
  83                                 }
  84                         }
  85
  86                         g_variant_unref(var);
  87                         g_free(key);
  88                         break;
  89                 }
  90         }
  91
  92         g_variant_iter_free(iter);
  93
  94         __COMMON_FUNC_EXIT__;
  95 }
  96
  97 static void _set_rotation(Evas_Object *win)
  98 {
  99         int rots[4] = { 0, 90, 180, 270 };
 100
 101         if (!elm_win_wm_rotation_supported_get(win)) {
 102                 return;
 103         }
 104
 105         elm_win_wm_rotation_available_rotations_set(win, (const int *)(&rots), 4);
 106 }
 107
 108 static void *on_create(ui_gadget_h ug, enum ug_mode mode,
 109                 app_control_h app_control, void *priv)
 110 {
 111         __COMMON_FUNC_ENTER__;
 112
 113         const char *uri = NULL;
 114         int state;
 115
 116         if (!ug || !priv) {
 117                 INFO_LOG(UG_NAME_ERR, "UG and PRIV should not be NULL");
 118
 119                 __COMMON_FUNC_EXIT__;
 120                 return NULL;
 121         }
 122
 123         ug_app_state = g_new0(wifi_appdata, 1);
 124         retvm_if(NULL == ug_app_state, NULL);
 125
 126         struct ug_data *ugd;
 127         ugd = (struct ug_data*)priv;
 128         ugd->ug = ug;
 129
 130         if (NULL != app_control) {
 131                 INFO_LOG(UG_NAME_NORMAL, "message load from caller");
 132
 133                 char *caller = NULL;
 134                 app_control_get_extra_data(app_control, UG_CALLER, &caller);
 135
 136                 if (app_control_get_uri(app_control, (char **)&uri) < 0)
 137                         ERROR_LOG(UG_NAME_NORMAL, "Failed to get app_control URI");
 138
 139                 if (uri)
 140                         free((void *)uri);
 141
 142                 if (caller != NULL) {
 143                         SECURE_INFO_LOG(UG_NAME_NORMAL, "caller: %s", caller);
 144
 145                         if (g_strcmp0(caller, "pwlock") == 0) {
 146                                 ugd->elm_conform = ug_get_conformant();
 147                                 ug_app_state->ug_type = UG_VIEW_SETUP_WIZARD;
 148
 149                                 ug_app_state->rbutton_setup_wizard_next = g_strdup(sc(PACKAGE,
 150                                         I18N_TYPE_Next));
 151                                 ug_app_state->rbutton_setup_wizard_skip = g_strdup(sc(PACKAGE,
 152                                         I18N_TYPE_Skip));
 153                                 ug_app_state->lbutton_setup_wizard_prev = g_strdup(sc(PACKAGE,
 154                                         I18N_TYPE_Prev));
 155                         } else if (g_strcmp0(caller, "notification") == 0){
 156                                 /* Remove the "WiFi networks found" from the notification tray.*/
 157                                 common_util_managed_idle_add(__wifi_efl_ug_del_found_ap_noti, NULL);
 158                                 ug_app_state->ug_type = UG_VIEW_DEFAULT;
 159                         } else if (g_strcmp0(caller, "lbhome") == 0){
 160                                 ug_app_state->ug_type = UG_VIEW_DEFAULT;
 161                                 ug_app_state->app_control = app_control;
 162                                 ug_app_state->is_lbhome = EINA_TRUE;
 163                         } else {
 164                                 ug_app_state->ug_type = UG_VIEW_DEFAULT;
 165                         }
 166
 167                         free(caller);
 168                 } else {
 169                         INFO_LOG(UG_NAME_NORMAL, "caller is not defined");
 170                         ug_app_state->ug_type = UG_VIEW_DEFAULT;
 171                 }
 172
 173
 174         } else {
 175                 INFO_LOG(UG_NAME_NORMAL, "caller is not defined");
 176                 ug_app_state->ug_type = UG_VIEW_DEFAULT;
 177         }
 178
 179         Evas_Object *parent_layout = ug_get_parent_layout(ug);
 180         if (parent_layout == NULL) {
 181                 ERROR_LOG(UG_NAME_NORMAL, "Failed to get parent layout");
 182
 183                 __COMMON_FUNC_EXIT__;
 184                 return NULL;
 185         }
 186
 187         ugd->win_main = ug_get_window();
 188         ug_app_state->gadget= ugd;
 189         ug_app_state->ug = ug;
 190         ug_app_state->conformant = ug_get_conformant();
 191
 192         _set_rotation(ugd->win_main);
 193
 194         common_util_set_system_registry(VCONFKEY_WIFI_UG_RUN_STATE,
 195                         VCONFKEY_WIFI_UG_RUN_STATE_ON_FOREGROUND);
 196
 197         Evas_Object *layout_main = viewer_manager_create(parent_layout, ugd->win_main);
 198         if (layout_main == NULL) {
 199                 INFO_LOG(UG_NAME_ERR, "Failed to create viewer_manager");
 200
 201                 __COMMON_FUNC_EXIT__;
 202                 return NULL;
 203         }
 204
 205         if (app_control != NULL) {
 206                 char *zorder = NULL;
 207                 app_control_get_extra_data(app_control, "z_order", &zorder);
 208                 INFO_LOG(UG_NAME_NORMAL, "zorder [%s]", zorder);
 209                 if (zorder != NULL && 0 == g_strcmp0(zorder, "highest")) {
 210                         efl_util_set_notification_window_level(ugd->win_main, EFL_UTIL_NOTIFICATION_LEVEL_DEFAULT);
 211                         g_free(zorder);
 212                         zorder = NULL;
 213                 }
 214         }
 215
 216 #if defined TIZEN_TETHERING_ENABLE
 217         ug_app_state->popup_manager = winset_popup_manager_create(layout_main, PACKAGE);
 218 #endif
 219
 220         ugd->base = layout_main;
 221         ug_app_state->layout_main = layout_main;
 222         ug_app_state->bAlive = EINA_TRUE;
 223
 224         wlan_manager_create();
 225         wlan_manager_set_message_callback(wlan_engine_callback);
 226         wlan_manager_set_refresh_callback(wlan_engine_refresh_callback);
 227         common_util_subscribe_scanning_signal(_bg_scan_status_callback);
 228
 229         switch (wlan_manager_start()) {
 230         case WLAN_MANAGER_ERR_NONE:
 231                 break;
 232
 233         case WLAN_MANAGER_ERR_ALREADY_REGISTERED:
 234                 break;
 235
 236         default:
 237                 ERROR_LOG(UG_NAME_NORMAL, "Cannot start wlan_manager");
 238
 239                 __COMMON_FUNC_EXIT__;
 240                 return ugd->base;
 241         }
 242
 243         state = wlan_manager_state_get();
 244         switch (state) {
 245         case WLAN_MANAGER_OFF:
 246                 if (ug_app_state->ug_type == UG_VIEW_SETUP_WIZARD) {
 247                         viewer_manager_header_mode_set(HEADER_MODE_ACTIVATING);
 248                         power_control();
 249                 } else {
 250                         viewer_manager_hide(VIEWER_WINSET_SUB_CONTENTS);
 251                         viewer_manager_header_mode_set(HEADER_MODE_OFF);
 252                 }
 253                 break;
 254
 255         case WLAN_MANAGER_CONNECTING:
 256         case WLAN_MANAGER_UNCONNECTED:
 257         case WLAN_MANAGER_CONNECTED:
 258                 viewer_manager_hide(VIEWER_WINSET_SEARCHING);
 259                 viewer_manager_show(VIEWER_WINSET_SUB_CONTENTS);
 260                 viewer_manager_header_mode_set(HEADER_MODE_SEARCHING);
 261                 break;
 262
 263         case WLAN_MANAGER_ERROR:
 264         default:
 265                 return ugd->base;
 266         }
 267
 268         evas_object_show(layout_main);
 269
 270         __COMMON_FUNC_EXIT__;
 271         return ugd->base;
 272 }
 273
 274 static gboolean load_initial_ap_list(gpointer data)
 275 {
 276         __COMMON_FUNC_ENTER__;
 277
 278         /* Because of transition effect performance,
 279          * Wi-Fi lists might be better to be updated at maximum delayed
 280          */
 281         wlan_manager_scanned_profile_refresh();
 282
 283         __COMMON_FUNC_EXIT__;
 284         return FALSE;
 285 }
 286
 287 static void on_start(ui_gadget_h ug, app_control_h app_control, void *priv)
 288 {
 289         __COMMON_FUNC_ENTER__;
 290
 291         common_util_managed_idle_add(load_initial_ap_list, NULL);
 292
 293         connman_request_scan_mode_set(WIFI_BGSCAN_MODE_PERIODIC);
 294
 295         __COMMON_FUNC_EXIT__;
 296 }
 297
 298 static void on_pause(ui_gadget_h ug, app_control_h app_control, void *priv)
 299 {
 300         __COMMON_FUNC_ENTER__;
 301
 302         INFO_LOG(UG_NAME_NORMAL, "Wi-Fi UG paused");
 303
 304         connman_request_scan_mode_set(WIFI_BGSCAN_MODE_EXPONENTIAL);
 305
 306         common_util_set_system_registry(VCONFKEY_WIFI_UG_RUN_STATE,
 307                         VCONFKEY_WIFI_UG_RUN_STATE_ON_BACKGROUND);
 308
 309         __COMMON_FUNC_EXIT__;
 310 }
 311
 312 static void on_resume(ui_gadget_h ug, app_control_h app_control, void *priv)
 313 {
 314         __COMMON_FUNC_ENTER__;
 315
 316         INFO_LOG(UG_NAME_NORMAL, "Wi-Fi UG resumed");
 317
 318         connman_request_scan_mode_set(WIFI_BGSCAN_MODE_PERIODIC);
 319
 320         common_util_set_system_registry(VCONFKEY_WIFI_UG_RUN_STATE,
 321                         VCONFKEY_WIFI_UG_RUN_STATE_ON_FOREGROUND);
 322
 323         view_manager_view_type_t top_viewID = viewer_manager_view_type_get();
 324         if (top_viewID == VIEW_MANAGER_VIEW_TYPE_MAIN) {
 325                 viewer_manager_request_scan();
 326                 is_scan_reqd = false;
 327         } else {
 328                 is_scan_reqd = true;
 329         }
 330
 331         __COMMON_FUNC_EXIT__;
 332 }
 333
 334 static void on_destroy(ui_gadget_h ug, app_control_h app_control, void *priv)
 335 {
 336         __COMMON_FUNC_ENTER__;
 337
 338         int ret;
 339         struct ug_data* ugd = priv;
 340
 341         common_util_set_system_registry(VCONFKEY_WIFI_UG_RUN_STATE,
 342                         VCONFKEY_WIFI_UG_RUN_STATE_OFF);
 343
 344         if (!ug || !priv){
 345                 __COMMON_FUNC_EXIT__;
 346                 return;
 347         }
 348
 349         /*Added to handle incase of force closure*/
 350         passwd_popup_free(ug_app_state->passpopup);
 351         ug_app_state->passpopup = NULL;
 352
 353         if (ug_app_state->timeout) {
 354                 g_source_remove(ug_app_state->timeout);
 355                 ug_app_state->timeout = 0;
 356         }
 357
 358 #if defined TIZEN_TETHERING_ENABLE
 359         winset_popup_manager_destroy(ug_app_state->popup_manager);
 360         ug_app_state->popup_manager = NULL;
 361         DEBUG_LOG(UG_NAME_NORMAL, "* popup manager destroy complete");
 362 #endif
 363
 364         if (wifi_exit_end == FALSE) {
 365                 connman_request_scan_mode_set(WIFI_BGSCAN_MODE_EXPONENTIAL);
 366
 367                 common_util_managed_idle_cleanup();
 368                 common_util_managed_ecore_scan_update_timer_del();
 369
 370                 ret = wlan_manager_destroy();
 371                 if (ret != WLAN_MANAGER_ERR_NONE) {
 372                         ERROR_LOG(UG_NAME_NORMAL, "Failed to destroy wlan manager: %d",ret);
 373                 } else {
 374                         INFO_LOG(UG_NAME_NORMAL, "* wlan manager destroy complete");
 375                 }
 376         }
 377
 378         viewer_manager_destroy();
 379         INFO_LOG(UG_NAME_NORMAL, "* viewer manager destroy complete");
 380
 381         if (ug_app_state->rbutton_setup_wizard_next != NULL) {
 382                 g_free(ug_app_state->rbutton_setup_wizard_next);
 383                 ug_app_state->rbutton_setup_wizard_next = NULL;
 384         }
 385
 386         if (ug_app_state->rbutton_setup_wizard_skip != NULL) {
 387                 g_free(ug_app_state->rbutton_setup_wizard_skip);
 388                 ug_app_state->rbutton_setup_wizard_skip = NULL;
 389         }
 390
 391         if (ug_app_state->lbutton_setup_wizard_prev != NULL) {
 392                 g_free(ug_app_state->lbutton_setup_wizard_prev);
 393                 ug_app_state->lbutton_setup_wizard_prev = NULL;
 394         }
 395
 396         if (ug_app_state != NULL) {
 397                 g_free(ug_app_state);
 398                 ug_app_state = NULL;
 399         }
 400
 401         if (ugd->base != NULL) {
 402                 evas_object_del(ugd->base);
 403                 ugd->base = NULL;
 404         }
 405
 406         __COMMON_FUNC_EXIT__;
 407 }
 408
 409 static void on_message(ui_gadget_h ug, app_control_h msg, app_control_h app_control, void *priv)
 410 {
 411 }
 412
 413 static void _language_changed(void)
 414 {
 415
 416         __COMMON_FUNC_ENTER__;
 417
 418         if (NULL != ug_app_state->rbutton_setup_wizard_next) {
 419                 g_free(ug_app_state->rbutton_setup_wizard_next);
 420                 ug_app_state->rbutton_setup_wizard_next = NULL;
 421         }
 422
 423         if (NULL != ug_app_state->rbutton_setup_wizard_skip) {
 424                 g_free(ug_app_state->rbutton_setup_wizard_skip);
 425                 ug_app_state->rbutton_setup_wizard_skip = NULL;
 426         }
 427
 428         if (NULL != ug_app_state->lbutton_setup_wizard_prev) {
 429                 g_free(ug_app_state->lbutton_setup_wizard_prev);
 430                 ug_app_state->lbutton_setup_wizard_prev = NULL;
 431         }
 432
 433         ug_app_state->rbutton_setup_wizard_next = g_strdup(sc(PACKAGE, I18N_TYPE_Next));
 434         ug_app_state->rbutton_setup_wizard_skip = g_strdup(sc(PACKAGE, I18N_TYPE_Skip));
 435         ug_app_state->lbutton_setup_wizard_prev = g_strdup(sc(PACKAGE, I18N_TYPE_Prev));
 436
 437         viewer_manager_setup_wizard_button_controller();
 438
 439         language_changed_refresh();
 440
 441         __COMMON_FUNC_EXIT__;
 442 }
 443
 444 static void on_event(ui_gadget_h ug, enum ug_event event, app_control_h app_control, void *priv)
 445 {
 446         __COMMON_FUNC_ENTER__;
 447
 448         switch (event) {
 449         case UG_EVENT_LOW_MEMORY:
 450                 break;
 451         case UG_EVENT_LOW_BATTERY:
 452                 break;
 453         case UG_EVENT_LANG_CHANGE:
 454                 INFO_LOG(UG_NAME_NORMAL, "LANGUAGE");
 455                 if (UG_VIEW_SETUP_WIZARD == ug_app_state->ug_type)
 456                         _language_changed();
 457                 break;
 458         case UG_EVENT_ROTATE_PORTRAIT:
 459         case UG_EVENT_ROTATE_PORTRAIT_UPSIDEDOWN:
 460                 INFO_LOG(UG_NAME_NORMAL, "PORTRAIT");
 461                 viewer_manager_rotate_top_setupwizard_layout();
 462                 break;
 463         case UG_EVENT_ROTATE_LANDSCAPE:
 464         case UG_EVENT_ROTATE_LANDSCAPE_UPSIDEDOWN:
 465                 INFO_LOG(UG_NAME_NORMAL, "LANSCAPE");
 466                 viewer_manager_rotate_top_setupwizard_layout();
 467                 break;
 468         default:
 469                 break;
 470         }
 471
 472         __COMMON_FUNC_EXIT__;
 473 }
 474
 475 static void on_key_event(ui_gadget_h ug, enum ug_key_event event, app_control_h app_control, void *priv)
 476 {
 477         __COMMON_FUNC_ENTER__;
 478
 479         if (!ug) {
 480                 __COMMON_FUNC_EXIT__;
 481                 return;
 482         }
 483
 484         switch (event) {
 485         case UG_KEY_EVENT_END:
 486                 INFO_LOG(UG_NAME_NORMAL, "UG_KEY_EVENT_END");
 487
 488 #if defined TIZEN_TETHERING_ENABLE
 489                 /* popup key event determine */
 490                 winset_popup_hide_popup(ug_app_state->popup_manager);
 491 #endif
 492                 view_manager_view_type_t top_view_id = viewer_manager_view_type_get();
 493                 if (top_view_id == VIEW_MANAGER_VIEW_TYPE_MAIN) {
 494                         INFO_LOG(UG_NAME_NORMAL, "same");
 495                 } else {
 496                         INFO_LOG(UG_NAME_NORMAL, "differ");
 497                         elm_naviframe_item_pop(viewer_manager_get_naviframe());
 498
 499                         __COMMON_FUNC_EXIT__;
 500                         return;
 501                 }
 502
 503                 wifi_exit();
 504                 break;
 505         default:
 506                 INFO_LOG(UG_NAME_NORMAL, "UG_KEY_EVENT [%d]", event);
 507                 break;
 508         }
 509
 510         __COMMON_FUNC_EXIT__;
 511 }
 512
 513 UG_MODULE_API int UG_MODULE_INIT(struct ug_module_ops *ops)
 514 {
 515         __COMMON_FUNC_ENTER__;
 516
 517         wifi_exit_end = FALSE;
 518
 519         retvm_if(NULL == ops, 0);
 520
 521         struct ug_data *ugd;
 522         ugd = calloc(1, sizeof(struct ug_data));
 523
 524         assertm_if(NULL == ugd, "Err!! calloc fail");
 525
 526         ops->create = on_create;
 527         ops->start = on_start;
 528         ops->pause = on_pause;
 529         ops->resume = on_resume;
 530         ops->destroy = on_destroy;
 531         ops->message = on_message;
 532         ops->event = on_event;
 533         ops->key_event = on_key_event;
 534         ops->priv = ugd;
 535         ops->opt = UG_OPT_INDICATOR_ENABLE;
 536
 537         __COMMON_FUNC_EXIT__;
 538         return 0;
 539 }
 540
 541 UG_MODULE_API void UG_MODULE_EXIT(struct ug_module_ops *ops)
 542 {
 543         __COMMON_FUNC_ENTER__;
 544
 545         retm_if(NULL == ops);
 546
 547         struct ug_data *ugd;
 548
 549         ugd = ops->priv;
 550
 551         if (ugd) {
 552                 free(ugd);
 553         }
 554
 555         __COMMON_FUNC_EXIT__;
 556 }
 557
 558 static bool setting_plugin_wifi_found_ap_cb(wifi_ap_h ap, void* user_data)
 559 {
 560         bool favorite = false;
 561
 562         wifi_ap_is_favorite(ap, &favorite);
 563
 564         if (true == favorite) {
 565                 wlan_manager_forget(ap);
 566         }
 567
 568         return true;
 569 }
 570
 571 UG_MODULE_API int setting_plugin_reset(bundle *data, void *priv)
 572 {
 573         __COMMON_FUNC_ENTER__;
 574
 575         int return_value = 0;
 576
 577         return_value = wlan_manager_start();
 578         if (return_value != WLAN_MANAGER_ERR_NONE) {
 579                 ERROR_LOG(UG_NAME_NORMAL, "Failed to register : %d",return_value);
 580                 return_value = -1;
 581                 goto error;
 582         }
 583
 584         wifi_foreach_found_aps(setting_plugin_wifi_found_ap_cb, NULL);
 585         return_value = wlan_manager_power_off();
 586         if (return_value != WLAN_MANAGER_ERR_NONE) {
 587                 ERROR_LOG(UG_NAME_NORMAL, "Failed to power_off: %d",return_value);
 588                 return_value = -1;
 589                 goto error;
 590         }
 591
 592         common_util_set_system_registry(VCONFKEY_WIFI_ENABLE_QS,
 593                                                                         VCONFKEY_WIFI_QS_ENABLE);
 594
 595 error:
 596         wlan_manager_destroy();
 597
 598         __COMMON_FUNC_EXIT__;
 599         return return_value;
 600 }
 601
 602 int wifi_exit(void)
 603 {
 604         __COMMON_FUNC_ENTER__;
 605
 606         if (wifi_exit_end == TRUE) {
 607                 __COMMON_FUNC_EXIT__;
 608                 return FALSE;
 609         }
 610         wifi_exit_end = TRUE;
 611
 612         int ret = WLAN_MANAGER_ERR_NONE;
 613         struct ug_data *ugd;
 614         ugd = ug_app_state->gadget;
 615         ug_app_state->bAlive = EINA_FALSE;
 616
 617         connman_request_scan_mode_set(WIFI_BGSCAN_MODE_EXPONENTIAL);
 618
 619         common_util_managed_idle_cleanup();
 620         common_util_managed_ecore_scan_update_timer_del();
 621
 622         ret = wlan_manager_destroy();
 623         if (ret != WLAN_MANAGER_ERR_NONE) {
 624                 ERROR_LOG(UG_NAME_NORMAL, "Failed to destroy wlan manager: %d",ret);
 625         } else {
 626                 DEBUG_LOG(UG_NAME_NORMAL, "* wlan manager destroy complete");
 627         }
 628
 629         DEBUG_LOG(UG_NAME_NORMAL, "* ug_destroying...");
 630         ug_destroy_me(ugd->ug);
 631
 632         __COMMON_FUNC_EXIT__;
 633         return TRUE;
 634 }
 635
 636 bool wifi_is_scan_required(void)
 637 {
 638         return is_scan_reqd;
 639 }
 640 #if 0
 641 UG_MODULE_API int setting_plugin_search_init(app_control_h app_control, void *priv, char **domainname)
 642 {
 643         void *node = NULL;
 644         *domainname = strdup(PACKAGE);
 645         Eina_List **pplist = (Eina_List **)priv;
 646
 647         node = setting_plugin_search_item_add("IDS_ST_BODY_NETWORK_NOTIFICATION",
 648                 "viewtype:advancedsetting", NULL, 5, NULL);
 649         *pplist = eina_list_append(*pplist, node);
 650         node = setting_plugin_search_item_add("IDS_WIFI_TMBODY_SMART_NETWORK_SWITCH",
 651                 "viewtype:mainview", NULL, 5, NULL);
 652         *pplist = eina_list_append(*pplist, node);
 653         node = setting_plugin_search_item_add("IDS_WIFI_HEADER_PASSPOINT",
 654                 "viewtype:advancedsetting", NULL, 5, NULL);
 655         *pplist = eina_list_append(*pplist, node);
 656         node = setting_plugin_search_item_add("IDS_ST_BODY_KEEP_WI_FI_ON_DURING_SLEEP",
 657                 "viewtype:advancedsetting", NULL, 5, NULL);
 658         *pplist = eina_list_append(*pplist, node);
 659         node = setting_plugin_search_item_add("IDS_ST_MBODY_ALWAYS_ALLOW_SCANNING",
 660                 "viewtype:advancedsetting", NULL, 5, NULL);
 661         *pplist = eina_list_append(*pplist, node);
 662         node = setting_plugin_search_item_add("IDS_WIFI_BODY_ADVANCED_SETTINGS",
 663                 "viewtype:advancedsetting", NULL, 5, NULL);
 664         *pplist = eina_list_append(*pplist, node);
 665
 666         return 0;
 667 }
 668 #endif