src/mh_main_ug.c

   1 /*
   2 * ug-mobile-ap
   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 <setting-cfg.h>
  25
  26 #include "mobile_hotspot.h"
  27 #include "mh_view_main.h"
  28 #include "mh_func_onoff.h"
  29 #include "mh_common_utility.h"
  30 #include "mh_popup.h"
  31 #include "mh_string.h"
  32 #include "mh_view_wifi_setup.h"
  33
  34 //UG_MODULE_API int setting_plugin_search_init(app_control_h app_control, void * priv, char ** domainname);
  35
  36 static Evas_Object *create_content(mh_appdata_t *ad)
  37 {
  38         __MOBILE_AP_FUNC_ENTER__;
  39
  40         ad->naviframe = _create_naviframe(ad->layout);
  41         _main_draw_contents(ad);
  42
  43         __MOBILE_AP_FUNC_EXIT__;
  44
  45         return ad->naviframe;
  46 }
  47
  48 static void __set_callbacks(tethering_h handle, void *user_data)
  49 {
  50         DBG("+\n");
  51
  52         int ret;
  53
  54         ret = tethering_set_enabled_cb(handle, TETHERING_TYPE_ALL,
  55                         _enabled_cb, user_data);
  56         if (ret != TETHERING_ERROR_NONE)
  57                 ERR("tethering_set_enabled_cb [0x%X]\n", ret);
  58
  59         ret = tethering_set_enabled_cb(handle, TETHERING_TYPE_RESERVED,
  60                         _enabled_cb, user_data);
  61         if (ret != TETHERING_ERROR_NONE)
  62                 ERR("tethering_set_enabled_cb [0x%X]\n", ret);
  63
  64         ret = tethering_wifi_set_passphrase_changed_cb(handle,
  65                         _passphrase_changed_cb, user_data);
  66         if (ret != TETHERING_ERROR_NONE)
  67                 ERR("tethering_wifi_set_passphrase_changed_cb [0x%X]\n", ret);
  68
  69         ret = tethering_wifi_set_ssid_visibility_changed_cb(handle,
  70                         _visibility_changed_cb, user_data);
  71         if (ret != TETHERING_ERROR_NONE)
  72                 ERR("tethering_wifi_set_ssid_visibility_changed_cb [0x%X]\n", ret);
  73
  74         ret = tethering_wifi_set_security_type_changed_cb(handle,
  75                         _security_type_changed_cb, user_data);
  76         if (ret != TETHERING_ERROR_NONE)
  77                 ERR("tethering_wifi_set_security_type_changed_cb [0x%X]\n", ret);
  78
  79         ret = tethering_set_disabled_cb(handle, TETHERING_TYPE_ALL,
  80                         _disabled_cb, user_data);
  81         if (ret != TETHERING_ERROR_NONE)
  82                 ERR("tethering_set_disabled_cb [0x%X]\n", ret);
  83
  84         ret = tethering_set_disabled_cb(handle, TETHERING_TYPE_RESERVED,
  85                         _disabled_cb, user_data);
  86         if (ret != TETHERING_ERROR_NONE)
  87                 ERR("tethering_set_disabled_cb [0x%X]\n", ret);
  88
  89         ret = tethering_set_connection_state_changed_cb(handle,
  90                         TETHERING_TYPE_ALL,
  91                         _connection_changed_cb, user_data);
  92         if (ret != TETHERING_ERROR_NONE)
  93                 ERR("tethering_set_connection_state_changed_cb [0x%X]\n", ret);
  94
  95         ret = wifi_set_device_state_changed_cb(_wifi_state_changed_cb, user_data);
  96         if (ret != WIFI_ERROR_NONE)
  97                 ERR("wifi_set_device_state_changed_cb [0x%X]\n", ret);
  98         vconf_notify_key_changed(VCONFKEY_SETAPPL_DEVICE_NAME_STR,
  99                                 _device_name_changed_cb, user_data);
 100
 101         vconf_notify_key_changed(VCONFKEY_NETWORK_CELLULAR_STATE,
 102                         _handle_network_cellular_state_changed_cb, user_data);
 103
 104         vconf_notify_key_changed(VCONFKEY_SYSMAN_USB_STATUS,
 105                         _handle_usb_status_change, (void *)user_data);
 106
 107         vconf_notify_key_changed(VCONF_KEY_MOBILEAP_SYSPOPUP_RESPONSE,
 108                         _handle_mobileap_syspopup_popup_response, (void *)user_data);
 109
 110         DBG("-\n");
 111 }
 112
 113 static void __unset_callbacks(tethering_h handle)
 114 {
 115         DBG("+\n");
 116
 117         int ret;
 118
 119         ret = wifi_unset_device_state_changed_cb();
 120         if (ret != WIFI_ERROR_NONE)
 121                 ERR("wifi_unset_device_state_changed_cb [0x%X]\n", ret);
 122
 123         ret = tethering_unset_connection_state_changed_cb(handle,
 124                         TETHERING_TYPE_ALL);
 125         if (ret != TETHERING_ERROR_NONE)
 126                 ERR("tethering_unset_connection_state_changed_cb[0x%X]\n", ret);
 127
 128         ret = tethering_unset_disabled_cb(handle, TETHERING_TYPE_RESERVED);
 129         if (ret != TETHERING_ERROR_NONE)
 130                 ERR("tethering_unset_disabled_cb [0x%X]\n", ret);
 131
 132         ret = tethering_unset_disabled_cb(handle, TETHERING_TYPE_ALL);
 133         if (ret != TETHERING_ERROR_NONE)
 134                 ERR("tethering_unset_disabled_cb [0x%X]\n", ret);
 135
 136         ret = tethering_wifi_unset_security_type_changed_cb(handle);
 137         if (ret != TETHERING_ERROR_NONE)
 138                 ERR("tethering_wifi_unset_security_type_changed_cb [0x%X]\n", ret);
 139
 140         ret = tethering_wifi_unset_ssid_visibility_changed_cb(handle);
 141         if (ret != TETHERING_ERROR_NONE)
 142                 ERR("tethering_wifi_unset_ssid_visibility_changed_cb [0x%X]\n", ret);
 143
 144         ret = tethering_wifi_unset_passphrase_changed_cb(handle);
 145         if (ret != TETHERING_ERROR_NONE)
 146                 ERR("tethering_wifi_unset_passphrase_changed_cb [0x%X]\n", ret);
 147
 148         ret = tethering_unset_enabled_cb(handle, TETHERING_TYPE_RESERVED);
 149         if (ret != TETHERING_ERROR_NONE)
 150                 ERR("tethering_unset_enabled [0x%X]\n", ret);
 151
 152         ret = tethering_unset_enabled_cb(handle, TETHERING_TYPE_ALL);
 153         if (ret != TETHERING_ERROR_NONE)
 154                 ERR("tethering_unset_enabled [0x%X]\n", ret);
 155
 156         vconf_ignore_key_changed(VCONFKEY_SETAPPL_DEVICE_NAME_STR,
 157                         _device_name_changed_cb);
 158
 159         vconf_ignore_key_changed(VCONFKEY_NETWORK_CELLULAR_STATE,
 160                         _handle_network_cellular_state_changed_cb);
 161
 162         vconf_ignore_key_changed(VCONFKEY_SYSMAN_USB_STATUS, _handle_usb_status_change);
 163
 164         vconf_ignore_key_changed(VCONF_KEY_MOBILEAP_SYSPOPUP_RESPONSE,
 165                         _handle_mobileap_syspopup_popup_response);
 166
 167         DBG("-\n");
 168 }
 169
 170 static void *on_create(ui_gadget_h ug, enum ug_mode mode,
 171                 app_control_h app_control, void *priv)
 172 {
 173         DBG("+\n");
 174
 175         if (!ug || !priv) {
 176                 ERR("The param is NULL\n");
 177                 return NULL;
 178         }
 179
 180         if (mode != UG_MODE_FULLVIEW) {
 181                 ERR("Only Fullview is supported\n");
 182                 return NULL;
 183         }
 184
 185         Evas_Object *layout;
 186         Evas_Object *content;
 187         mh_ugdata_t *ugd;
 188         mh_appdata_t *ad;
 189         int ret;
 190
 191         bindtextdomain(MH_TEXT_DOMAIN, MH_LOCALEDIR);
 192         dgettext(PACKAGE, LOCALEDIR);
 193
 194         ad = (mh_appdata_t *)malloc(sizeof(mh_appdata_t));
 195         if (ad == NULL) {
 196                 ERR("Error!!! failed to allocate memory()\n");
 197                 return NULL;
 198         }
 199         memset(ad, 0x0, sizeof(mh_appdata_t));
 200
 201         ugd = (mh_ugdata_t *)priv;
 202         ugd->ad = ad;
 203         ugd->ug = ug;
 204         ad->gadget = ugd;
 205
 206         _send_signal_qp(QP_SIGNAL_PROGRESS_RESET);
 207
 208         ecore_imf_init();
 209
 210         ret = tethering_create(&ad->handle);
 211         if (ret != TETHERING_ERROR_NONE) {
 212                 ERR("tethering_create is failed : %d\n", ret);
 213                 free(ad);
 214                 ugd->ad = NULL;
 215                 return NULL;
 216         }
 217
 218         ad->win = ug_get_parent_layout(ug);
 219         if (!ad->win) {
 220                 ERR("ad->win is NULL\n");
 221                 free(ad);
 222                 ugd->ad = NULL;
 223                 return NULL;
 224         }
 225
 226         /* set rotation */
 227         if (elm_win_wm_rotation_supported_get(ad->win)) {
 228                 int rots[4] = {0, 90, 180, 270};
 229                 elm_win_wm_rotation_available_rotations_set(ad->win, (const int *)(&rots), 4);
 230         }
 231
 232         layout = _create_win_layout(ad);
 233         if (layout == NULL) {
 234                 ERR("_create_win_layout is failed\n");
 235                 free(ad);
 236                 ugd->ad = NULL;
 237                 return NULL;
 238         }
 239
 240         content = create_content(ad);
 241         if (content == NULL) {
 242                 ERR("create_content is failed\n");
 243                 free(ad);
 244                 ugd->ad = NULL;
 245                 return NULL;
 246         }
 247
 248         elm_object_part_content_set(layout, "elm.swallow.content", content);
 249         evas_object_show(layout);
 250         ret = connection_create(&ad->conn_handle);
 251         if (ret != CONNECTION_ERROR_NONE) {
 252                 ERR("connection_create() is failed : %d\n", ret);
 253         }
 254
 255         ret = wifi_initialize();
 256         if (ret != WIFI_ERROR_NONE) {
 257                 ERR("wifi_initialize() is failed : %d\n", ret);
 258         }
 259
 260         __set_callbacks(ad->handle, (void *)ad);
 261
 262         DBG("-\n");
 263         return layout;
 264 }
 265
 266 static void on_start(ui_gadget_h ug, app_control_h app_control, void *priv)
 267 {
 268         DBG("+\n");
 269
 270         char * viewtype = NULL;
 271
 272         mh_ugdata_t *ugd = (mh_ugdata_t *)priv;
 273         mh_appdata_t *ad = ugd->ad;
 274
 275         ad->is_foreground = true;
 276
 277         if (_get_list_clients_count(ad) > 0) {
 278 #ifdef TETHERING_DATA_USAGE_SUPPORT
 279                 _start_update_data_packet_usage(ad);
 280 #endif
 281                 if (ad->connected_device.navi_it) {
 282                         _start_update_device_conn_time(ad);
 283                 }
 284         }
 285
 286         if (tethering_is_enabled(NULL, TETHERING_TYPE_RESERVED) == true) {
 287                 DBG("MobileAP is turned on\n");
 288                 _prepare_popup(MH_POPUP_WIFI_AP_OFF, STR_WIFI_AP_CONTROLLED_ANOTHER_APP);
 289                 _create_popup(ad);
 290         }
 291
 292         app_control_get_extra_data(app_control, "viewtype", &viewtype);
 293
 294         if (viewtype != NULL) {
 295                 if(strcmp(viewtype, "wifisettings") == 0)
 296                         mh_draw_wifi_setup_view(ad);
 297                 g_free(viewtype);
 298         }
 299
 300         DBG("-\n");
 301         return;
 302 }
 303
 304 static void on_pause(ui_gadget_h ug, app_control_h app_control, void *priv)
 305 {
 306         DBG("+\n");
 307
 308         mh_ugdata_t *ugd = (mh_ugdata_t *)priv;
 309         mh_appdata_t *ad = ugd->ad;
 310
 311 #ifdef TETHERING_DATA_USAGE_SUPPORT
 312         _stop_update_data_packet_usage(ad);
 313 #endif
 314         _stop_update_device_conn_time(ad);
 315         ad->is_foreground = false;
 316
 317         DBG("-\n");
 318 }
 319
 320 static void on_resume(ui_gadget_h ug, app_control_h app_control, void *priv)
 321 {
 322         DBG("+\n");
 323
 324         mh_ugdata_t *ugd = (mh_ugdata_t *)priv;
 325         mh_appdata_t *ad = ugd->ad;
 326         Elm_Object_Item *item = ad->main.device_item;
 327         GSList *l = NULL;
 328
 329         ad->is_foreground = true;
 330
 331         if (item && elm_genlist_item_expanded_get(item)) {
 332                 for (l = ad->client_list; l != NULL; l = g_slist_next(l) ) {
 333                         item = elm_genlist_item_next_get(item);
 334                         elm_genlist_item_fields_update(item, "elm.text", ELM_GENLIST_ITEM_FIELD_TEXT);
 335                 }
 336         }
 337
 338         if (_get_list_clients_count(ad) > 0) {
 339 #ifdef TETHERING_DATA_USAGE_SUPPORT
 340                 _start_update_data_packet_usage(ad);
 341 #endif
 342                 if (ad->connected_device.navi_it) {
 343                         _start_update_device_conn_time(ad);
 344                 }
 345         }
 346         DBG("-\n");
 347 }
 348
 349 static void on_destroy(ui_gadget_h ug, app_control_h app_control, void *priv)
 350 {
 351         DBG("+\n");
 352
 353         if (priv == NULL) {
 354                 ERR("The param is NULL\n");
 355                 return;
 356         }
 357
 358         mh_ugdata_t *ugd = priv;
 359         mh_appdata_t *ad = ugd->ad;
 360         int ret = 0;
 361
 362         if (ad == NULL) {
 363                 ERR("The param is NULL\n");
 364                 return;
 365         }
 366
 367         __unset_callbacks(ad->handle);
 368
 369 #ifdef TETHERING_DATA_USAGE_SUPPORT
 370         _stop_update_data_packet_usage(ad);
 371 #endif
 372         _stop_update_device_conn_time(ad);
 373
 374         if (vconf_set_int(VCONF_MOBILE_AP_CONNECT_USB_POPUP_STATUS, 0) < 0) {
 375                 ERR("vconf_set_int is failed\n");
 376         }
 377
 378         ret = wifi_deinitialize();
 379         if (ret != WIFI_ERROR_NONE) {
 380                 ERR("wifi_deinitialize() is failed : %d\n", ret);
 381         }
 382
 383         ret = connection_destroy(ad->conn_handle);
 384         if (ret != CONNECTION_ERROR_NONE) {
 385                 ERR("connection_destroy() is failed : %d\n", ret);
 386         }
 387
 388         ret = tethering_destroy(ad->handle);
 389         if (ret != TETHERING_ERROR_NONE) {
 390                 ERR("tethering_destroy() is failed : %d\n", ret);
 391         }
 392
 393         if (ad->layout == NULL) {
 394                 ERR("ad->layout is NULL\n");
 395                 free(ugd->ad);
 396                 ugd->ad = NULL;
 397                 return;
 398         }
 399
 400         if (ad->popup) {
 401                 evas_object_del(ad->popup);
 402                 ad->popup = NULL;
 403         }
 404
 405         if(ad->ps_recheck_timer_id > 0) {
 406                 g_source_remove(ad->ps_recheck_timer_id);
 407                 ad->ps_recheck_timer_id = 0;
 408         }
 409
 410         evas_object_del(ad->bg);
 411         ad->bg = NULL;
 412
 413         evas_object_del(ad->layout);
 414         ad->layout = NULL;
 415
 416         _main_free_genlist_itc(ad);
 417
 418         ecore_imf_shutdown();
 419
 420         free(ugd->ad);
 421         ugd->ad = NULL;
 422
 423         DBG("-\n");
 424         return;
 425 }
 426
 427 static void on_message(ui_gadget_h ug, app_control_h msg,
 428                 app_control_h app_control, void *priv)
 429 {
 430 }
 431
 432 static void on_event(ui_gadget_h ug, enum ug_event event,
 433                 app_control_h app_control, void *priv)
 434 {
 435         __MOBILE_AP_FUNC_ENTER__;
 436
 437         if (!ug || !priv) {
 438                 ERR("The param is NULL\n");
 439                 return;
 440         }
 441
 442         switch (event) {
 443         case UG_EVENT_LOW_MEMORY:
 444                 break;
 445         case UG_EVENT_LOW_BATTERY:
 446                 break;
 447         case UG_EVENT_LANG_CHANGE:
 448                 break;
 449         case UG_EVENT_ROTATE_PORTRAIT:
 450         case UG_EVENT_ROTATE_PORTRAIT_UPSIDEDOWN:
 451                 DBG("UG_EVENT_ROTATE_PORTRAIT[_UPSIDEDOWN]\n");
 452 #if 0 /* device rename not supported */
 453                 _rotate_adjust_rename_popup();
 454 #endif
 455                 break;
 456         case UG_EVENT_ROTATE_LANDSCAPE:
 457         case UG_EVENT_ROTATE_LANDSCAPE_UPSIDEDOWN:
 458                 DBG("UG_EVENT_ROTATE_LANDSCAPE[_UPSIDEDOWN]\n");
 459 #if 0 /* device rename not supported */
 460                 _rotate_adjust_rename_popup();
 461 #endif
 462                 break;
 463         default:
 464                 break;
 465         }
 466
 467         __MOBILE_AP_FUNC_EXIT__;
 468 }
 469
 470 static void on_key_event(ui_gadget_h ug, enum ug_key_event event,
 471                 app_control_h app_control, void *priv)
 472 {
 473         __MOBILE_AP_FUNC_ENTER__;
 474
 475         if (priv == NULL || ug == NULL) {
 476                 ERR("The param is NULL\n");
 477                 return;
 478         }
 479
 480         mh_ugdata_t *ugd = (mh_ugdata_t *)priv;
 481         mh_appdata_t *ad = ugd->ad;
 482
 483         if (ad == NULL) {
 484                 ERR("ad is NULL\n");
 485                 return;
 486         }
 487
 488         switch (event) {
 489         case UG_KEY_EVENT_END:
 490                 DBG("UG_KEY_EVENT_END is received : %p\n", ad->popup);
 491                 if (NULL == ad->popup)
 492                         ug_destroy_me(ug);
 493                 else
 494                         _destroy_popup(ad);
 495                 break;
 496
 497         default:
 498                 break;
 499         }
 500
 501         __MOBILE_AP_FUNC_EXIT__;
 502 }
 503
 504 UG_MODULE_API int UG_MODULE_INIT(struct ug_module_ops *ops)
 505 {
 506         DBG("+\n");
 507
 508         if (!ops) {
 509                 ERR("The param is NULL\n");
 510                 return -1;
 511         }
 512
 513         mh_ugdata_t *ugd;
 514         ugd = calloc(1, sizeof(mh_ugdata_t));
 515         if (!ugd) {
 516                 ERR("Quit : calloc failed(ugd)\n");
 517                 return -1;
 518         }
 519
 520         ops->create = on_create;
 521         ops->start = on_start;
 522         ops->pause = on_pause;
 523         ops->resume = on_resume;
 524         ops->destroy = on_destroy;
 525         ops->message = on_message;
 526         ops->event = on_event;
 527         ops->key_event = on_key_event;
 528         ops->priv = ugd;
 529         ops->opt = UG_OPT_INDICATOR_ENABLE;
 530
 531         return 0;
 532 }
 533
 534 UG_MODULE_API void UG_MODULE_EXIT(struct ug_module_ops *ops)
 535 {
 536         DBG("+\n");
 537
 538         if (!ops) {
 539                 ERR("The param is NULL\n");
 540                 return;
 541         }
 542
 543         mh_ugdata_t *ugd = (mh_ugdata_t *)ops->priv;
 544
 545         if (ugd)
 546                 free(ugd);
 547 }
 548
 549 static void __mh_reset_vconf(tethering_h handle)
 550 {
 551         int ret = 0;
 552
 553         ret = vconf_set_int(VCONF_MOBILE_AP_WIFI_POPUP_CHECKBOX_STATUS, 0);
 554         if (ret != 0)
 555                 ERR("vconf_set_int failed\n");
 556
 557         ret = vconf_set_int(VCONF_MOBILE_AP_BT_POPUP_CHECKBOX_STATUS, 0);
 558         if (ret != 0)
 559                 ERR("vconf_set_int failed\n");
 560
 561         ret = vconf_set_int(VCONF_MOBILE_AP_USB_POPUP_CHECKBOX_STATUS, 0);
 562         if (ret != 0)
 563                 ERR("vconf_set_int failed\n");
 564
 565         ret = vconf_set_int(VCONF_MOBILE_AP_PREV_WIFI_STATUS, 0);
 566         if (ret != 0)
 567                 ERR("vconf_set_int failed\n");
 568
 569         ret = vconf_set_int(VCONF_MOBILE_AP_CONNECT_USB_POPUP_STATUS, 0);
 570         if (ret != 0)
 571                 ERR("vconf_set_int is failed\n");
 572
 573         ret = tethering_wifi_set_ssid_visibility(handle, true);
 574         if (ret != TETHERING_ERROR_NONE)
 575                 ERR("tethering_wifi_set_ssid_visibility failed\n");
 576
 577         ret = tethering_wifi_set_security_type(handle, TETHERING_WIFI_SECURITY_TYPE_WPA2_PSK);
 578         if (ret != TETHERING_ERROR_NONE)
 579                 ERR("tethering_wifi_set_security_type failed\n");
 580
 581         return;
 582 }
 583
 584 UG_MODULE_API int setting_plugin_reset(app_control_h app_control, void *priv)
 585 {
 586         DBG("+\n");
 587
 588         int ret = -1;
 589         tethering_h handle = NULL;
 590
 591         if (tethering_create(&handle) != TETHERING_ERROR_NONE) {
 592                 ERR("tethering_create failed\n");
 593                 return -1;
 594         }
 595
 596         if (tethering_is_enabled(handle, TETHERING_TYPE_USB) ||
 597                         tethering_is_enabled(handle, TETHERING_TYPE_WIFI) ||
 598                         tethering_is_enabled(handle, TETHERING_TYPE_BT)) {
 599                 ret = tethering_disable(handle, TETHERING_TYPE_ALL);
 600                 if (ret != TETHERING_ERROR_NONE) {
 601                         ERR("tethering_disable failed : %d\n", ret);
 602                         tethering_destroy(handle);
 603                         return -1;
 604                 }
 605
 606         }
 607
 608         __mh_reset_vconf(handle);
 609
 610         tethering_destroy(handle);
 611
 612         return 0;
 613 }
 614
 615 /* Below code is commented as search in setting is no more supported in kiran */
 616
 617 #if 0
 618 UG_MODULE_API int setting_plugin_search_init(app_control_h app_control, void * priv, char ** domainname)
 619 {
 620         *domainname = strdup(PACKAGE":/usr/apps/ug-setting-mobileap-efl/res/locale");
 621
 622         Eina_List ** pplist = (Eina_List**)priv;
 623         void * node = NULL;
 624
 625         node = setting_plugin_search_item_add("IDS_MOBILEAP_MBODY_USB_TETHERING", "viewtype:frontpage", NULL, 5, NULL);
 626         *pplist = eina_list_append(*pplist, node);
 627
 628         node = setting_plugin_search_item_add("IDS_MOBILEAP_MBODY_WI_FI_TETHERING", "viewtype:frontpage", NULL, 5, NULL);
 629         *pplist = eina_list_append(*pplist, node);
 630
 631         node = setting_plugin_search_item_add("IDS_MOBILEAP_BODY_BLUETOOTH_TETHERING", "viewtype:frontpage", NULL, 5, NULL);
 632         *pplist = eina_list_append(*pplist, node);
 633
 634         node = setting_plugin_search_item_add("IDS_MOBILEAP_MBODY_WI_FI_TETHERING_SETTINGS", "viewtype:wifisettings", NULL, 5, NULL);
 635         *pplist = eina_list_append(*pplist, node);
 636
 637         node = setting_plugin_search_item_add("IDS_MOBILEAP_BODY_HIDE_MY_DEVICE", "viewtype:wifisettings", NULL, 5, NULL);
 638         *pplist = eina_list_append(*pplist, node);
 639
 640         node = setting_plugin_search_item_add("IDS_MOBILEAP_BODY_SECURITY", "viewtype:wifisettings", NULL, 5, NULL);
 641         *pplist = eina_list_append(*pplist, node);
 642
 643         return 0;
 644 }
 645 #endif