sources/ui-gadget/viewers-layout/view_advanced.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 <vconf-keys.h>
  22 #include <efl_assist.h>
  23 #include <app_control_internal.h>
  24 #include <efl_extension.h>
  25
  26 #include "ug_wifi.h"
  27 #include "view_advanced.h"
  28 #include "i18nmanager.h"
  29 #include "viewer_manager.h"
  30 #include "winset_popup.h"
  31 #include "common_utils.h"
  32
  33 #define VCONF_SLEEP_POLICY "file/private/wifi/sleep_policy"
  34 #define VCONF_SMART_SWITCHING "file/private/wifi/smart_switching"
  35 #define VCONF_SMART_SWITCH_CB "file/private/wifi/smart_switch_checkbox"
  36
  37 typedef enum {
  38         VCONF_SMART_SWITCH_OFF = 0x00,
  39         VCONF_SMART_SWITCH_ON,
  40 } VCONF_SMART_SWITCH_OPTIONS;
  41
  42 struct _private_data {
  43         Evas_Object *list;
  44         Elm_Object_Item *item_smart_switch;
  45         Evas_Object *smart_popup;
  46         Elm_Object_Item *item_network_noti;
  47         Elm_Object_Item *item_keep_wifi_switch;
  48         Evas_Object *keep_wifi_radio_group;
  49         Evas_Object *keep_wifi_popup;
  50
  51         Elm_Object_Item *item_sort_by;
  52         Evas_Object *sort_by_radio_group;
  53         Evas_Object *sort_by_popup;
  54
  55         Elm_Object_Item *item_install_cert;
  56 };
  57
  58 struct _private_data g_pd;
  59
  60 /* Prototype */
  61 static char *_gl_text_get(void *data, Evas_Object *obj, const char *part);
  62 static char *_gl_network_notification_text_get(void *data, Evas_Object *obj,    const char *part);
  63 static char *_gl_sort_by_text_get(void *data, Evas_Object *obj, const char *part);
  64 static char *_gl_sort_by_sub_text_get(void *data, Evas_Object *obj, const char *part);
  65 static char *_gl_never_text_get(void *data, Evas_Object *obj,const char *part);
  66 static char *_gl_keep_wifi_on_during_sleep_text_get(void *data, Evas_Object *obj,const char *part);
  67 static Evas_Object *_gl_content_get_network_noti(void *data, Evas_Object *obj, const char *part);
  68 static Evas_Object *_gl_content_get_keep_wifi_sub(void *data, Evas_Object *obj, const char *part);
  69 static Evas_Object *_gl_content_get_sort_by_sub(void *data,     Evas_Object *obj, const char *part);
  70 static char *_gl_install_certificate_text_get(void *data, Evas_Object *obj, const char *part);
  71
  72 /* Global variables for elm_genlist itc */
  73 static Elm_Genlist_Item_Class itc_network_noti = {
  74                 .item_style = "multiline_sub.main.1icon",
  75                 .func.text_get = _gl_network_notification_text_get,
  76                 .func.content_get = _gl_content_get_network_noti
  77 };
  78
  79 static Elm_Genlist_Item_Class itc_keep_wifi = {
  80                 .item_style = "2line.top",
  81                 .func.text_get = _gl_keep_wifi_on_during_sleep_text_get,
  82 };
  83
  84 static Elm_Genlist_Item_Class itc_keep_wifi_sub = {
  85                 .item_style = "1line",
  86                 .func.text_get = _gl_text_get,
  87                 .func.content_get = _gl_content_get_keep_wifi_sub,
  88 };
  89
  90 static Elm_Genlist_Item_Class itc_keep_wifi_sub_never = {
  91                 .item_style = "2line.top",
  92                 .func.text_get = _gl_never_text_get,
  93                 .func.content_get = _gl_content_get_keep_wifi_sub,
  94 };
  95
  96 static Elm_Genlist_Item_Class itc_sort_by = {
  97                 .item_style = "2line.top",
  98                 .func.text_get = _gl_sort_by_text_get,
  99 };
 100
 101 static Elm_Genlist_Item_Class itc_sort_by_sub = {
 102                 .item_style = "1line",
 103                 .func.text_get = _gl_sort_by_sub_text_get,
 104                 .func.content_get = _gl_content_get_sort_by_sub,
 105 };
 106
 107 static Elm_Genlist_Item_Class itc_install_cert = {
 108                 .item_style = "1line",
 109                 .func.text_get = _gl_install_certificate_text_get,
 110 };
 111
 112 static char *_gl_install_certificate_text_get(void *data, Evas_Object *obj,
 113                 const char *part)
 114 {
 115         char buf[1024];
 116
 117         if (!g_strcmp0(part, "elm.text.main.left")) {
 118                 snprintf(buf, 1023, "%s", sc(PACKAGE, I18N_TYPE_Install_certificate));
 119                 return strdup(buf);
 120         }
 121         return NULL;
 122 }
 123
 124 static void _launch_cert_select_app(void)
 125 {
 126         int ret = APP_CONTROL_ERROR_NONE;
 127         app_control_h app_control;
 128
 129         app_control_create(&app_control);
 130         app_control_set_operation(app_control, APP_CONTROL_OPERATION_DEFAULT);
 131         app_control_set_window(app_control, elm_win_xwindow_get(ug_get_window()));
 132         app_control_set_app_id(app_control, "setting-manage-certificates-efl");
 133
 134         ret = app_control_send_launch_request(app_control, NULL, NULL);
 135         if(ret == APP_CONTROL_ERROR_NONE) {
 136                 INFO_LOG(UG_NAME_NORMAL, "Launch Cert Success");
 137         } else {
 138                 ERROR_LOG(UG_NAME_NORMAL, "Fail to launch Cert");
 139         }
 140
 141         app_control_destroy(app_control);
 142 }
 143
 144 static void _gl_cert_sel_cb(void *data, Evas_Object *obj, void *event_info)
 145 {
 146         _launch_cert_select_app();
 147
 148         elm_genlist_item_selected_set(g_pd.item_install_cert, EINA_FALSE);
 149 }
 150
 151 static int _convert_wifi_keep_value_to_vconf(int i18n_key)
 152 {
 153         switch (i18n_key) {
 154         case I18N_TYPE_Always:
 155                 return 0;
 156
 157         case I18N_TYPE_Plugged:
 158                 return 1;
 159
 160         case I18N_TYPE_Donot_Use:
 161                 return 2;
 162         }
 163
 164         return -1;
 165 }
 166
 167 static int _convert_vconf_to_wifi_keep_value(int vconf_value)
 168 {
 169         switch (vconf_value) {
 170         case 0:
 171                 return I18N_TYPE_Always;
 172
 173         case 1:
 174                 return I18N_TYPE_Plugged;
 175
 176         case 2:
 177                 return I18N_TYPE_Donot_Use;
 178         }
 179
 180         return -1;
 181 }
 182
 183 int _convert_sort_by_value_to_vconf(int i18n_key)
 184 {
 185         switch (i18n_key) {
 186         case I18N_TYPE_Alphabetical:
 187                 return 0;
 188
 189         case I18N_TYPE_Signal_Strength:
 190                 return 1;
 191         }
 192
 193         return -1;
 194 }
 195
 196 int _convert_vconf_to_sort_by_value(int vconf_value)
 197 {
 198         switch (vconf_value) {
 199         case 0:
 200                 return I18N_TYPE_Alphabetical;
 201
 202         case 1:
 203                 return I18N_TYPE_Signal_Strength;
 204         }
 205
 206         return -1;
 207 }
 208
 209 static char *_gl_sort_by_text_get(void *data, Evas_Object *obj,
 210                 const char *part)
 211 {
 212         char buf[1024];
 213         if (!g_strcmp0(part, "elm.text.main.left.top")||!g_strcmp0(part, "elm.text.main.left")) {
 214                 if ((int) data != 0) {
 215                         snprintf(buf, 1023, "%s", sc(PACKAGE, (int) data));
 216                         return strdup(buf);
 217                 }
 218         } else if (!g_strcmp0(part, "elm.text.sub.left.bottom")) {
 219                 int value;
 220
 221                 value = _convert_vconf_to_sort_by_value(
 222                                 common_util_get_system_registry(VCONF_SORT_BY));
 223                 if (value >= 0) {
 224                         snprintf(buf, 1023, "%s", sc(PACKAGE, value));
 225                         return strdup(buf);
 226                 }
 227         }
 228
 229         return NULL;
 230 }
 231
 232 static char *_gl_sort_by_sub_text_get(void *data, Evas_Object *obj, const char *part)
 233 {
 234         char buf[1024];
 235         if (!g_strcmp0(part, "elm.text.main.left")) {
 236                 if ((int) data != 0) {
 237                         snprintf(buf, 1023, "%s", sc(PACKAGE, (int) data));
 238                         return strdup(buf);
 239                 }
 240         }
 241         return NULL;
 242 }
 243
 244 static char *_gl_network_notification_text_get(void *data, Evas_Object *obj, const char *part)
 245 {
 246         char buf[1024];
 247
 248         if (!g_strcmp0(part, "elm.text.main")) {
 249                 snprintf(buf, 1023, "%s", sc(PACKAGE, I18N_TYPE_Network_notification));
 250                 return strdup(buf);
 251         } else if (!g_strcmp0(part, "elm.text.multiline")) {
 252                 snprintf(buf, 1023, "%s", sc(PACKAGE, I18N_TYPE_Network_notify_me_later));
 253                 return strdup(buf);
 254         }
 255         return NULL;
 256 }
 257
 258 static char *_gl_text_get(void *data, Evas_Object *obj,
 259                 const char *part)
 260 {
 261         char buf[1024];
 262         if (!g_strcmp0(part, "elm.text.main.left")) {
 263                 if ((int) data != 0) {
 264                         snprintf(buf, 1023, "%s", sc(PACKAGE, (int) data));
 265                         return strdup(buf);
 266                 }
 267         }
 268
 269         return NULL;
 270 }
 271
 272 static char *_gl_keep_wifi_on_during_sleep_text_get(void *data, Evas_Object *obj, const char *part)
 273 {
 274         char buf[1024];
 275
 276         if(!strcmp(part, "elm.text.main.left.top")) {
 277                 snprintf(buf, 1023, "%s", sc(PACKAGE, I18N_TYPE_Keep_WIFI_on_during_sleep));
 278                 return strdup(buf);
 279         }
 280
 281         if(!strcmp(part, "elm.text.sub.left.bottom")) {
 282                 int value;
 283                 value = _convert_vconf_to_wifi_keep_value(
 284                                 common_util_get_system_registry(VCONF_SLEEP_POLICY));
 285                 if (value >= 0) {
 286                         if (value == I18N_TYPE_Donot_Use) {
 287                                 snprintf(buf, 1023, "%s", sc(PACKAGE, I18N_TYPE_Donot_Use));
 288                                 return strdup(buf);
 289                         } else {
 290                                 snprintf(buf, 1023, "%s", sc(PACKAGE, value));
 291                                 return strdup(buf);
 292                         }
 293                 }
 294         }
 295         return NULL;
 296 }
 297 static char *_gl_never_text_get(void *data, Evas_Object *obj,
 298                 const char *part)
 299 {
 300         if (!g_strcmp0(part, "elm.text.main.left.top")) {
 301                 return g_strdup(sc(PACKAGE, I18N_TYPE_Donot_Use));
 302         } else if (!g_strcmp0(part, "elm.text.sub.left.bottom")) {
 303                 return g_strdup(sc(PACKAGE, I18N_TYPE_Increases_Data_Usage));
 304         }
 305
 306         return NULL;
 307 }
 308
 309 static void _gl_changed_network_noti(void *data, Evas_Object *obj,
 310                 void *event_info)
 311 {
 312         int value;
 313         const char *object_type;
 314
 315         __COMMON_FUNC_ENTER__;
 316
 317         object_type = evas_object_type_get(obj);
 318         if (!object_type) {
 319                 INFO_LOG(UG_NAME_SCAN, "object_type is NULL");
 320                 return;
 321         }
 322
 323         value = common_util_get_system_registry(VCONFKEY_WIFI_ENABLE_QS);
 324
 325         if (g_strcmp0(object_type, "elm_check") == 0) {
 326                 Eina_Bool check_enable = elm_check_state_get(obj);
 327
 328                 if (check_enable == TRUE) {
 329                         value = VCONFKEY_WIFI_QS_ENABLE;
 330                 } else {
 331                         value = VCONFKEY_WIFI_QS_DISABLE;
 332                 }
 333         } else if (g_strcmp0(object_type, "elm_genlist") == 0) {
 334                 if (value == VCONFKEY_WIFI_QS_ENABLE) {
 335                         value = VCONFKEY_WIFI_QS_DISABLE;
 336                 } else {
 337                         value = VCONFKEY_WIFI_QS_ENABLE;
 338                 }
 339         }
 340
 341         common_util_set_system_registry(VCONFKEY_WIFI_ENABLE_QS, value);
 342
 343         if(g_pd.item_network_noti != NULL)
 344                 elm_genlist_item_update(g_pd.item_network_noti);
 345         elm_genlist_item_selected_set(g_pd.item_network_noti, EINA_FALSE);
 346
 347         __COMMON_FUNC_EXIT__;
 348 }
 349
 350 static Evas_Object *_gl_content_get_network_noti(void *data,
 351                 Evas_Object *obj, const char *part)
 352 {
 353         Evas_Object *toggle_btn = NULL;
 354         int ret;
 355
 356
 357         if (!strncmp(part, "elm.icon", strlen(part))) {
 358                 toggle_btn = elm_check_add(obj);
 359                 evas_object_size_hint_align_set(toggle_btn, EVAS_HINT_FILL, EVAS_HINT_FILL);
 360                 evas_object_size_hint_weight_set(toggle_btn, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
 361
 362                 elm_object_style_set(toggle_btn, "on&off");
 363                 evas_object_propagate_events_set(toggle_btn, EINA_FALSE);
 364 #ifdef ACCESSIBLITY_FEATURE
 365                 Evas_Object *ao = NULL;
 366                 char buf[100];
 367                 ao = elm_object_item_access_object_get(g_pd.item_network_noti);
 368                 if (ao) {
 369                         g_snprintf(buf, sizeof(buf), "%s%s%s",
 370                                         sc(PACKAGE, I18N_TYPE_On),
 371                                         sc(PACKAGE, I18N_TYPE_Off),
 372                                         sc(PACKAGE, I18N_TYPE_Button));
 373                         elm_access_info_set(ao, ELM_ACCESS_TYPE, buf);
 374                 }
 375 #endif
 376                 ret = common_util_get_system_registry(VCONFKEY_WIFI_ENABLE_QS);
 377                 switch (ret) {
 378                 case 1:
 379 #ifdef ACCESSIBLITY_FEATURE
 380                         if (ao)
 381                                 elm_access_info_set(ao, ELM_ACCESS_STATE,
 382                                                 sc(PACKAGE, I18N_TYPE_On));
 383 #endif
 384                         elm_check_state_set(toggle_btn, EINA_TRUE);
 385                         evas_object_smart_callback_add(toggle_btn, "changed",
 386                                         _gl_changed_network_noti, NULL);
 387                         break;
 388                 case 0:
 389 #ifdef ACCESSIBLITY_FEATURE
 390                         if (ao)
 391                                 elm_access_info_set(ao, ELM_ACCESS_STATE,
 392                                                 sc(PACKAGE, I18N_TYPE_Off));
 393 #endif
 394                         elm_check_state_set(toggle_btn, EINA_FALSE);
 395                         evas_object_smart_callback_add(toggle_btn, "changed",
 396                                         _gl_changed_network_noti, NULL);
 397                         break;
 398                 default:
 399                         ERROR_LOG(COMMON_NAME_ERR, "Setting fail!!");
 400                         break;
 401                 }
 402         }
 403         return toggle_btn;
 404 }
 405
 406 static void _gl_changed_keep_wifi_sub(void *data, Evas_Object *obj,
 407                 void *event_info)
 408 {
 409         Elm_Object_Item *item;
 410         const char *object_type;
 411         int value;
 412         Elm_Object_Item *parent = NULL;
 413
 414         __COMMON_FUNC_ENTER__;
 415
 416         item = (Elm_Object_Item *) event_info;
 417         object_type = evas_object_type_get(obj);
 418         if (!object_type) {
 419                 INFO_LOG(UG_NAME_SCAN, "object_type is NULL");
 420                 return;
 421         }
 422
 423         value = _convert_wifi_keep_value_to_vconf((int) data);
 424
 425         if (value >= 0) {
 426                 common_util_set_system_registry(VCONF_SLEEP_POLICY, value);
 427         }
 428
 429         if (g_strcmp0(object_type, "elm_genlist") == 0) {
 430                 elm_radio_value_set(g_pd.keep_wifi_radio_group, (int) data);
 431         }
 432
 433         if (item != NULL) {
 434                 elm_genlist_item_update(item);
 435                 elm_genlist_item_selected_set(item, EINA_FALSE);
 436
 437                 parent = elm_genlist_item_parent_get(item);
 438                 if(parent != NULL)
 439                         elm_genlist_item_update(parent);
 440         }
 441
 442         if(g_pd.item_keep_wifi_switch != NULL)
 443                 elm_genlist_item_update(g_pd.item_keep_wifi_switch);
 444
 445         evas_object_del(g_pd.keep_wifi_popup);
 446         __COMMON_FUNC_EXIT__;
 447 }
 448
 449 static Evas_Object *_gl_content_get_keep_wifi_sub(void *data,
 450                 Evas_Object *obj, const char *part)
 451 {
 452         __COMMON_FUNC_ENTER__;
 453         Evas_Object *radio;
 454         int value;
 455         Evas_Object *content = elm_layout_add(obj);
 456
 457         if (!g_pd.keep_wifi_radio_group) {
 458                 g_pd.keep_wifi_radio_group = elm_radio_add(obj);
 459                 elm_radio_state_value_set (g_pd.keep_wifi_radio_group, -1);
 460         }
 461
 462         if (!g_strcmp0(part, "elm.icon.2")) {
 463                 elm_layout_theme_set(content, "layout", "list/C/type.2", "default");
 464                 radio = elm_radio_add(content);
 465 #ifdef ACCESSIBLITY_FEATURE
 466                 elm_access_object_unregister(radio);
 467 #endif
 468                 elm_radio_state_value_set(radio, (int) data);
 469                 elm_radio_group_add(radio, g_pd.keep_wifi_radio_group);
 470
 471                 elm_layout_content_set(content, "elm.swallow.content", radio);
 472
 473                 value = _convert_vconf_to_wifi_keep_value(
 474                                 common_util_get_system_registry(VCONF_SLEEP_POLICY));
 475                 if (value == (int) data) {
 476                         elm_radio_value_set(g_pd.keep_wifi_radio_group, (int) data);
 477                 }
 478
 479                 evas_object_smart_callback_add(radio, "changed", _gl_changed_keep_wifi_sub, data);
 480         }
 481
 482         __COMMON_FUNC_EXIT__;
 483         return content;
 484 }
 485
 486 static void _gl_changed_sort_by_sub(void *data, Evas_Object *obj,
 487                 void *event_info)
 488 {
 489         Elm_Object_Item *item;
 490         const char *object_type;
 491         int value;
 492         Elm_Object_Item *parent = NULL;
 493
 494         __COMMON_FUNC_ENTER__;
 495
 496         item = (Elm_Object_Item *) event_info;
 497         object_type = evas_object_type_get(obj);
 498         if (!object_type) {
 499                 INFO_LOG(UG_NAME_SCAN, "object_type is NULL");
 500                 return;
 501         }
 502
 503         value = _convert_sort_by_value_to_vconf((int) data);
 504         if (value >= 0) {
 505                 common_util_set_system_registry(VCONF_SORT_BY, value);
 506         }
 507
 508         if (g_strcmp0(object_type, "elm_genlist") == 0) {
 509                 elm_radio_value_set(g_pd.sort_by_radio_group, (int) data);
 510         }
 511
 512         if (item != NULL) {
 513                 elm_genlist_item_update(item);
 514                 elm_genlist_item_selected_set(item, EINA_FALSE);
 515
 516                 parent = elm_genlist_item_parent_get(item);
 517                 if(parent != NULL)
 518                         elm_genlist_item_update(parent);
 519         }
 520
 521         if(g_pd.item_sort_by != NULL)
 522                 elm_genlist_item_update(g_pd.item_sort_by);
 523
 524         evas_object_del(g_pd.sort_by_popup);
 525
 526         __COMMON_FUNC_EXIT__;
 527 }
 528
 529 static Evas_Object *_gl_content_get_sort_by_sub(void *data,
 530                 Evas_Object *obj, const char *part)
 531 {
 532         __COMMON_FUNC_ENTER__;
 533
 534         Evas_Object *radio;
 535         int value;
 536         Evas_Object *content = elm_layout_add(obj);
 537
 538         if (!g_pd.sort_by_radio_group) {
 539                 g_pd.sort_by_radio_group = elm_radio_add(obj);
 540                 elm_radio_state_value_set (g_pd.sort_by_radio_group, -1);
 541         }
 542
 543         if (!g_strcmp0(part, "elm.icon.2")) {
 544                 elm_layout_theme_set(content, "layout", "list/C/type.2", "default");
 545                 radio = elm_radio_add(content);
 546 #ifdef ACCESSIBLITY_FEATURE
 547                 elm_access_object_unregister(radio);
 548 #endif
 549                 elm_radio_state_value_set(radio, (int) data);
 550                 elm_radio_group_add(radio, g_pd.sort_by_radio_group);
 551
 552                 elm_layout_content_set(content, "elm.swallow.content", radio);
 553
 554                 value = _convert_vconf_to_sort_by_value(
 555                                 common_util_get_system_registry(VCONF_SORT_BY));
 556
 557                 if (value == (int) data) {
 558                         elm_radio_value_set(g_pd.sort_by_radio_group, (int) data);
 559                 }
 560
 561                 evas_object_smart_callback_add(radio, "changed",
 562                                 _gl_changed_sort_by_sub, data);
 563         }
 564
 565         __COMMON_FUNC_EXIT__;
 566         return content;
 567 }
 568
 569 static void _block_clicked_cb(void *data, Evas_Object *obj,
 570                 void *event_info)
 571 {
 572         Evas_Object *popup = (Evas_Object *)data;
 573
 574         if (popup != NULL) {
 575                 evas_object_del(popup);
 576         }
 577 }
 578
 579 static void _gl_keep_wifi(void *data, Evas_Object *obj, void *event_info)
 580 {
 581         __COMMON_FUNC_ENTER__;
 582         Evas_Object *genlist;
 583
 584         g_pd.keep_wifi_popup = elm_popup_add(obj);
 585         eext_object_event_callback_add(g_pd.keep_wifi_popup, EA_CALLBACK_BACK, eext_popup_back_cb, NULL);
 586         elm_object_domain_translatable_part_text_set(g_pd.keep_wifi_popup,
 587                         "title,text", PACKAGE, "IDS_ST_BODY_KEEP_WI_FI_ON_DURING_SLEEP");
 588         elm_popup_align_set(g_pd.keep_wifi_popup, ELM_NOTIFY_ALIGN_FILL, 1.0);
 589         evas_object_size_hint_weight_set(g_pd.keep_wifi_popup, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
 590         evas_object_smart_callback_add(g_pd.keep_wifi_popup, "block,clicked",
 591                         _block_clicked_cb, g_pd.keep_wifi_popup);
 592
 593         /* genlist */
 594         genlist = elm_genlist_add(g_pd.keep_wifi_popup);
 595         evas_object_size_hint_weight_set(genlist, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
 596         evas_object_size_hint_align_set(genlist, EVAS_HINT_FILL, EVAS_HINT_FILL);
 597         elm_genlist_mode_set(genlist, ELM_LIST_COMPRESS);
 598         elm_scroller_content_min_limit(genlist, EINA_FALSE, EINA_TRUE);
 599
 600         /* radio */
 601         g_pd.keep_wifi_radio_group = elm_radio_add(genlist);
 602         evas_object_data_set(genlist, "radio", g_pd.keep_wifi_radio_group);
 603
 604         elm_genlist_item_append(genlist, &itc_keep_wifi_sub,
 605                         (const void *) I18N_TYPE_Always, NULL, ELM_GENLIST_ITEM_NONE,
 606                         _gl_changed_keep_wifi_sub, (const void *)I18N_TYPE_Always);
 607
 608         elm_genlist_item_append(genlist, &itc_keep_wifi_sub,
 609                         (const void *) I18N_TYPE_Plugged, NULL, ELM_GENLIST_ITEM_NONE,
 610                         _gl_changed_keep_wifi_sub, (const void *)I18N_TYPE_Plugged);
 611
 612         elm_genlist_item_append(genlist, &itc_keep_wifi_sub_never,
 613                         (const void *) I18N_TYPE_Donot_Use, NULL, ELM_GENLIST_ITEM_NONE,
 614                         _gl_changed_keep_wifi_sub, (const void *)I18N_TYPE_Donot_Use);
 615
 616         evas_object_show(genlist);
 617         elm_object_content_set(g_pd.keep_wifi_popup, genlist);
 618         evas_object_show(g_pd.keep_wifi_popup);
 619
 620         elm_genlist_item_selected_set(g_pd.item_keep_wifi_switch, EINA_FALSE);
 621         __COMMON_FUNC_EXIT__;
 622 }
 623
 624 static void _gl_sort_by(void *data, Evas_Object *obj, void *event_info)
 625 {
 626         __COMMON_FUNC_ENTER__;
 627         Evas_Object *genlist = NULL;
 628
 629         g_pd.sort_by_popup = elm_popup_add(obj);
 630         eext_object_event_callback_add(g_pd.sort_by_popup, EA_CALLBACK_BACK, eext_popup_back_cb, NULL);
 631         elm_object_domain_translatable_part_text_set(g_pd.sort_by_popup,
 632                         "title,text", PACKAGE, "IDS_WIFI_BODY_SORT_BY");
 633         elm_popup_align_set(g_pd.sort_by_popup, ELM_NOTIFY_ALIGN_FILL, 1.0);
 634         evas_object_size_hint_weight_set(g_pd.sort_by_popup, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
 635         evas_object_smart_callback_add(g_pd.sort_by_popup, "block,clicked",
 636                         _block_clicked_cb, g_pd.sort_by_popup);
 637
 638         /* genlist */
 639         genlist = elm_genlist_add(g_pd.sort_by_popup);
 640         evas_object_size_hint_weight_set(genlist, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
 641         evas_object_size_hint_align_set(genlist, EVAS_HINT_FILL, EVAS_HINT_FILL);
 642         elm_genlist_mode_set(genlist, ELM_LIST_COMPRESS);
 643         elm_scroller_content_min_limit(genlist, EINA_FALSE, EINA_TRUE);
 644
 645         /* radio */
 646         g_pd.sort_by_radio_group = elm_radio_add(genlist);
 647         evas_object_data_set(genlist, "radio", g_pd.sort_by_radio_group);
 648
 649         elm_genlist_item_append(genlist, &itc_sort_by_sub,
 650                         (const void *) I18N_TYPE_Alphabetical, NULL, ELM_GENLIST_ITEM_NONE,
 651                         _gl_changed_sort_by_sub, (const void *)I18N_TYPE_Alphabetical);
 652
 653         elm_genlist_item_append(genlist, &itc_sort_by_sub,
 654                         (const void *) I18N_TYPE_Signal_Strength, NULL, ELM_GENLIST_ITEM_NONE,
 655                         _gl_changed_sort_by_sub, (const void *)I18N_TYPE_Signal_Strength);
 656
 657         evas_object_show(genlist);
 658         elm_object_content_set(g_pd.sort_by_popup, genlist);
 659         evas_object_show(g_pd.sort_by_popup);
 660
 661         elm_genlist_item_selected_set(g_pd.item_sort_by, EINA_FALSE);
 662         __COMMON_FUNC_EXIT__;
 663 }
 664
 665 static Evas_Object *_create_list(Evas_Object *parent)
 666 {
 667         Evas_Object *gl;
 668         int wifi_state = 0;
 669
 670         vconf_get_int(VCONFKEY_WIFI_STATE, &wifi_state);
 671         INFO_LOG(UG_NAME_NORMAL, "Wi-Fi state %d", wifi_state);
 672
 673         gl = elm_genlist_add(parent);
 674         assertm_if(NULL == gl, "NULL!!");
 675
 676         elm_object_style_set(gl, "dialogue");
 677         elm_genlist_mode_set(gl, ELM_LIST_LIMIT);
 678
 679         evas_object_size_hint_weight_set(gl, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
 680         evas_object_size_hint_align_set(gl, EVAS_HINT_FILL, EVAS_HINT_FILL);
 681
 682         elm_genlist_mode_set(gl, ELM_LIST_COMPRESS);
 683
 684         /* Network Notification */
 685         g_pd.item_network_noti = elm_genlist_item_append(gl, &itc_network_noti,
 686                         (const void *) I18N_TYPE_Network_notification, NULL,
 687                         ELM_GENLIST_ITEM_NONE, _gl_changed_network_noti, NULL);
 688
 689         /* Keep WI-FI on during sleep */
 690         g_pd.item_keep_wifi_switch = elm_genlist_item_append(gl, &itc_keep_wifi,
 691                         (const void *) I18N_TYPE_Keep_WIFI_on_during_sleep, NULL,
 692                         ELM_GENLIST_ITEM_NONE, _gl_keep_wifi, NULL);
 693
 694         /* Sort By */
 695         g_pd.item_sort_by= elm_genlist_item_append(gl, &itc_sort_by,
 696                         (const void *) I18N_TYPE_Sort_by, NULL,
 697                         ELM_GENLIST_ITEM_NONE, _gl_sort_by, NULL);
 698
 699         /* Install Certificate */
 700         g_pd.item_install_cert = elm_genlist_item_append(gl, &itc_install_cert,
 701                         NULL, NULL, ELM_GENLIST_ITEM_NONE, _gl_cert_sel_cb, NULL);
 702
 703         evas_object_show(gl);
 704
 705         return gl;
 706 }
 707
 708 static void __vconf_noti_change_cb(keynode_t *node, void *user_data)
 709 {
 710         int state = 0;
 711
 712         vconf_get_int(VCONFKEY_WIFI_ENABLE_QS, &state);
 713         INFO_LOG(UG_NAME_NORMAL, "New notification option - %d", state);
 714
 715         if (g_pd.item_network_noti != NULL) {
 716                 elm_genlist_item_update(g_pd.item_network_noti);
 717         }
 718 }
 719
 720 static void __vconf_sleep_change_cb(keynode_t *node, void *user_data)
 721 {
 722         int state = 0;
 723
 724         vconf_get_int(VCONF_SLEEP_POLICY, &state);
 725         INFO_LOG(UG_NAME_NORMAL, "New sleep policy - %d", state);
 726
 727         if (g_pd.item_keep_wifi_switch != NULL) {
 728                 elm_genlist_item_update(g_pd.item_keep_wifi_switch);
 729         }
 730 }
 731
 732 static void __vconf_sort_change_cb(keynode_t *node, void *user_data)
 733 {
 734         int state = 0;
 735
 736         vconf_get_int(VCONF_SORT_BY, &state);
 737         INFO_LOG(UG_NAME_NORMAL, "New sort by option - %d", state);
 738
 739         if (g_pd.item_sort_by != NULL) {
 740                 elm_genlist_item_update(g_pd.item_sort_by);
 741         }
 742 }
 743
 744 static void __vconf_smart_switch_change_cb(keynode_t *node, void *user_data)
 745 {
 746         int state = 0;
 747
 748         vconf_get_int(VCONF_SMART_SWITCHING, &state);
 749         INFO_LOG(UG_NAME_NORMAL, "New smart switch option - %d", state);
 750
 751         if (g_pd.item_smart_switch != NULL) {
 752                 elm_genlist_item_update(g_pd.item_smart_switch);
 753         }
 754 }
 755
 756 static Eina_Bool __back_key_cb(void *data, Elm_Object_Item *it)
 757 {
 758         __COMMON_FUNC_ENTER__;
 759
 760         /* Delete vconf listeners for the different options */
 761         vconf_ignore_key_changed(VCONFKEY_WIFI_ENABLE_QS, __vconf_noti_change_cb);
 762         vconf_ignore_key_changed(VCONF_SLEEP_POLICY, __vconf_sleep_change_cb);
 763         vconf_ignore_key_changed(VCONF_SORT_BY, __vconf_sort_change_cb);
 764         vconf_ignore_key_changed(VCONF_SMART_SWITCHING,
 765                         __vconf_smart_switch_change_cb);
 766
 767         __COMMON_FUNC_EXIT__;
 768
 769         return EINA_TRUE;
 770 }
 771
 772 void view_advanced(void)
 773 {
 774         Evas_Object *layout = NULL;
 775         Evas_Object *navi_frame = NULL;
 776         Elm_Object_Item *navi_it = NULL;
 777         char title[100];
 778
 779         __COMMON_FUNC_ENTER__;
 780
 781         memset (&g_pd, 0, sizeof(struct _private_data));
 782
 783         navi_frame = viewer_manager_get_naviframe();
 784         if (navi_frame == NULL) {
 785                 ERROR_LOG(UG_NAME_NORMAL, "Failed to get naviframe");
 786                 return;
 787         }
 788
 789         layout = common_utils_create_layout(navi_frame);
 790         evas_object_show(layout);
 791
 792         g_pd.list = _create_list(layout);
 793         assertm_if(NULL == g_pd.list, "_create_list failed");
 794
 795         elm_object_part_content_set(layout, "elm.swallow.content", g_pd.list);
 796
 797         g_strlcpy(title, "IDS_WIFI_BODY_ADVANCED_SETTINGS", sizeof(title));
 798         navi_it = elm_naviframe_item_push(navi_frame, title, NULL, NULL,
 799                         layout, NULL);
 800         elm_object_item_domain_text_translatable_set(navi_it, PACKAGE, EINA_TRUE);
 801
 802         evas_object_data_set(navi_frame, SCREEN_TYPE_ID_KEY,
 803                         (void *) VIEW_MANAGER_VIEW_TYPE_ADVANCED);
 804
 805         elm_naviframe_item_pop_cb_set(navi_it, __back_key_cb, NULL);
 806
 807         /* Add vconf listeners for the different options */
 808         vconf_notify_key_changed(VCONFKEY_WIFI_ENABLE_QS, __vconf_noti_change_cb,
 809                         NULL);
 810         vconf_notify_key_changed(VCONF_SLEEP_POLICY, __vconf_sleep_change_cb,
 811                         NULL);
 812         vconf_notify_key_changed(VCONF_SORT_BY, __vconf_sort_change_cb,
 813                         NULL);
 814         vconf_notify_key_changed(VCONF_SMART_SWITCHING,
 815                         __vconf_smart_switch_change_cb, NULL);
 816
 817         __COMMON_FUNC_EXIT__;
 818 }