src/setting.c

   1 /*
   2  * setting
   3  * * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd.
   4  *
   5  * Contact: MyoungJune Park <mj2004.park@samsung.com>
   6  *
   7  * Licensed under the Apache License, Version 2.0 (the "License");
   8  * you may not use this file except in compliance with the License.
   9  * You may obtain a copy of the License at
  10  *
  11  * http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  * Unless required by applicable law or agreed to in writing, software
  14  * distributed under the License is distributed on an "AS IS" BASIS,
  15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  * See the License for the specific language governing permissions and
  17  * limitations under the License.
  18  *
  19  */
  20 #include <setting.h>
  21 #include <app.h>
  22 #include <sound_manager.h>
  23
  24 #include <appcore-common.h>
  25 #include <Ecore_X.h>
  26 #include <sensor.h>
  27 #include <aul.h>
  28 #include <app_preference.h>
  29
  30 #include "setting-helper.h"
  31 #include "setting-main.h"
  32 #include <setting-cfg.h>
  33
  34 #include <setting-common-search.h>
  35 #include <elm_object.h>
  36 #include <appsvc.h>
  37 /*#include <nfc.h> */
  38 #include <signal.h>
  39 #include <system_settings.h>
  40 #include <bundle_internal.h>
  41
  42 #define KEY_END "XF86Stop"
  43 /*#define SUPPORT_UG_MESSAGE */
  44
  45
  46 #define SETTING_SOUND_VOL_MAX 15
  47 #define SETTING_DEFAULT_RINGTONE_VOL_INT        11
  48 #define SETTING_DEFAULT_NOTI_VOL_INT            11
  49 #define SETTING_DEFAULT_MEDIA_VOL_INT           9
  50
  51 int g_geometry_x, g_geometry_y, g_geometry_w, g_geometry_h;
  52 extern int aul_listen_app_dead_signal(int (*func)(int signal, void *data), void *data);
  53
  54 /* This API is defined in <app_service_private.h>. But, cannot include and it is not a managed API.
  55         The way to resolve : 1. Add extern.
  56                                                  2. Use bundle pointer originally
  57         At first, choose No.1 */
  58 extern int app_control_create_request(bundle *data, app_control_h *service);
  59
  60
  61 setting_main_appdata *g_main_ad;
  62
  63 void termination_handler(int signum)
  64 {
  65         SETTING_TRACE_BEGIN;
  66         /* do something for signal handling */
  67         /*SETTING_TRACE_DEBUG(">>>>>>>>>>>>>>>>> SIGTERM >>>>>>>>>>>>>>> SETTING "); */
  68
  69         elm_exit();
  70 }
  71
  72
  73 #if LOW_BATTERY_DO_NOTHING
  74
  75 /*  in case of low battery, don't terminate itself.*/
  76
  77 /**
  78 * The event process when battery becomes low.
  79 */
  80 static void setting_main_low_battery_cb(app_event_info_h event_info, void *data)
  81 {
  82         SETTING_TRACE_BEGIN;
  83         retm_if(!data, "Invalid argument: data is NULL");
  84         setting_main_appdata *ad = data;
  85
  86         if (ad->ug) {
  87                 ug_send_event(UG_EVENT_LOW_BATTERY);
  88         }
  89 }
  90 #endif
  91
  92
  93 #if SUPPORT_APP_ROATION
  94 static void _rot_changed_cb(void *data, Evas_Object *obj, void *event_info)
  95 {
  96         SETTING_TRACE_BEGIN;
  97         setting_main_appdata *ad = (setting_main_appdata *)data;
  98         if (ad == NULL || ad->win_main == NULL) {
  99                 return;
 100         }
 101         int change_ang = elm_win_rotation_get(ad->win_main);
 102         SETTING_TRACE_DEBUG("....change_ang:%d", change_ang);
 103         SETTING_TRACE_DEBUG("current_rotation:%d", ad->current_rotation);
 104         /*Send the rotation event to UGs.. */
 105         enum ug_event event = UG_EVENT_ROTATE_PORTRAIT;
 106         switch (change_ang) {
 107                 case APP_DEVICE_ORIENTATION_0:
 108                         event = UG_EVENT_ROTATE_PORTRAIT;
 109                         break;
 110                 case APP_DEVICE_ORIENTATION_180:
 111                         event = UG_EVENT_ROTATE_PORTRAIT_UPSIDEDOWN;
 112                         break;
 113                 case APP_DEVICE_ORIENTATION_270:
 114                         event = UG_EVENT_ROTATE_LANDSCAPE;
 115                         break;
 116                 case APP_DEVICE_ORIENTATION_90:
 117                         event = UG_EVENT_ROTATE_LANDSCAPE_UPSIDEDOWN;
 118                         break;
 119                 default:
 120                         return;
 121         }
 122         SETTING_TRACE_DEBUG("diff:%d", elm_win_rotation_get(ad->win_main) - ad->current_rotation);
 123
 124         if (change_ang != ad->current_rotation) {
 125                 int diff = change_ang - ad->current_rotation;
 126                 if (diff < 0) {
 127                         diff = -diff;
 128                 }
 129                 /**
 130                 * @todo if app didn't launch UG, is the call required to invoke?
 131                 */
 132                 ug_send_event(event);
 133                 if (diff == 180) {
 134                         /* do nothing */
 135                 }
 136                 ad->current_rotation = change_ang;
 137         }
 138 }
 139 #endif
 140
 141
 142 /**
 143 * The event process when region is changes.
 144 */
 145 static void setting_main_region_changed_cb(app_event_info_h event_info, void *data)
 146 {
 147         retm_if(!data, "Invalid argument: data is NULL");
 148         setting_main_appdata *ad = data;
 149
 150         if (ad->ug) {
 151                 ug_send_event(UG_EVENT_REGION_CHANGE);
 152         }
 153 }
 154
 155 /**
 156 * The event process when win object is destroyed
 157 */
 158 static void setting_main_del_win(void *data, Evas_Object *obj, void *event)
 159 {
 160         elm_exit();
 161 }
 162
 163 void profile_changed_cb(void *data, Evas_Object *obj, void *event)
 164 {
 165         const char *profile = elm_config_profile_get();
 166
 167         if (strcmp(profile, "desktop") == 0) {
 168                 elm_win_indicator_mode_set(obj, ELM_WIN_INDICATOR_HIDE);
 169         } else {
 170                 elm_win_indicator_mode_set(obj, ELM_WIN_INDICATOR_SHOW);
 171         }
 172 }
 173
 174 /**
 175 * To create a win object, the win is shared between the App and all its UGs
 176 */
 177 static Evas_Object *setting_main_create_win(const char *name)
 178 {
 179         SETTING_TRACE_BEGIN;
 180         LAUNCH_SETTING_IN();
 181         Evas_Object *eo;
 182         int w, h;
 183
 184         eo = (Evas_Object *) elm_win_add(NULL, name, ELM_WIN_BASIC);
 185         if (!eo)
 186                 eo = elm_win_util_standard_add(name, name);
 187         else {
 188                 /* elm_win_util_standard_add creates bg inside */
 189                 Evas_Object *bg;
 190
 191                 bg = elm_bg_add(eo);
 192
 193                 if (!bg) {
 194                         evas_object_del(eo);
 195                         return NULL;
 196                 }
 197                 evas_object_size_hint_weight_set(bg, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
 198                 elm_win_resize_object_add(eo, bg);
 199                 evas_object_show(bg);
 200         }
 201         if (eo) {
 202                 elm_win_title_set(eo, name);
 203                 evas_object_smart_callback_add(eo, "delete,request", setting_main_del_win, NULL);
 204                 evas_object_smart_callback_add(eo, "profile,changed", profile_changed_cb, NULL);
 205                 /*elm_win_conformant_set(eo, EINA_TRUE); */
 206                 ecore_x_window_size_get(ecore_x_window_root_first_get(),
 207                                         &w, &h);
 208                 evas_object_resize(eo, w, h);
 209         }
 210         LAUNCH_SETTING_OUT();
 211         return eo;
 212 }
 213
 214
 215 /**
 216 * exceptional process, reset the env vars by Setting vconf VCONFKEY_LANGSET
 217 */
 218 static void setting_main_lang_changed_cb(app_event_info_h event_info, void *data)
 219 {
 220         SETTING_TRACE_BEGIN;
 221         retm_if(!data, "Invalid argument: data is NULL");
 222         /*FIX the crash when switch from Portrait mode to landscape mode, */
 223         /*It is so strange the data is no longer correct */
 224         /*and ....why it is invoked */
 225         /*setting_main_appdata *ad = data; */
 226         setting_main_appdata *ad = g_main_ad;
 227
 228         char *tab_str[] = {
 229                 Keystr_Connection,
 230                 KeyStr_Device,
 231                 KeyStr_MotionControl,
 232                 "IDS_ST_BODY_GENERAL",
 233                 KeyStr_DownloadedAPPs
 234         };
 235         int i = 0;
 236
 237         for (; i < SETTING_TAB_VIEW_MAX; i++) {
 238                 if (ad->ctrl_item[i])
 239                         elm_object_item_text_set(ad->ctrl_item[i], _(tab_str[i]));
 240         }
 241
 242         char *tmp = NULL;
 243         if (ad->data_bright) {
 244                 tmp = ad->data_bright->sub_desc;
 245                 ad->data_bright->sub_desc = (char *)g_strdup(get_brightness_mode_str());
 246                 FREE(tmp)
 247         }
 248         if (ad->data_backlight) {
 249                 tmp = ad->data_backlight->sub_desc;
 250                 ad->data_backlight->sub_desc = get_pa_backlight_time_str();
 251                 FREE(tmp)
 252         }
 253         if (ad->data_screenmode) {
 254                 tmp = ad->data_screenmode->sub_desc;
 255                 ad->data_screenmode->sub_desc = get_pa_screen_mode_str();
 256                 FREE(tmp)
 257         }
 258
 259         Eina_List *list, *l;
 260         Elm_Object_Item *it;
 261         i = SETTING_TAB_VIEW_INVALID;
 262         for (i = SETTING_TAB_VIEW_CONNECTION; i < SETTING_TAB_VIEW_MAX; i++) {
 263                 if (ad->sub_view[i]) {
 264                         list = elm_genlist_realized_items_get(ad->sub_view[i]);
 265                         EINA_LIST_FOREACH(list, l, it) {
 266                                 __add_gl_tts_feature(it);
 267                                 elm_genlist_item_update(it);
 268                         }
 269                 }
 270         }
 271
 272         /* update all tabs */
 273         for (i = SC_All_List; i < SC_Max; i++) {
 274                 if (ad->sc_gl[i]) {
 275                         list = elm_genlist_realized_items_get(ad->sc_gl[i]);
 276                         EINA_LIST_FOREACH(list, l, it) {
 277                                 __add_gl_tts_feature(it);
 278                                 elm_genlist_item_update(it);
 279                         }
 280                 }
 281         }
 282         /* For UGs */
 283
 284         elm_object_item_part_text_set(ad->main_navi_it, "elm.text.title", _("IDS_ST_OPT_SETTINGS"));
 285         setting_navi_items_update(ad->navibar_main);
 286
 287         if (ad->isInUGMode && ad->ug) {
 288                 Evas_Object *layout = (Evas_Object *)ug_get_layout(ad->ug);
 289                 if (layout) {
 290                         Evas_Object *navi_bar = NULL;
 291                         navi_bar = elm_object_part_content_get(layout, "elm.swallow.content");
 292                         setting_navi_items_update(navi_bar);
 293                 }
 294                 ug_send_event(UG_EVENT_LANG_CHANGE);
 295         }
 296
 297 }
 298
 299 /**
 300 * the event process when other VCONFS changes
 301 */
 302 static void setting_other_vconf_change_cb(keynode_t *key, void *data)
 303 {
 304         setting_main_appdata *ad = data;
 305         retm_if(!data, "Invalid argument: data is NULL");
 306
 307         Setting_GenGroupItem_Data *item_to_update = NULL;
 308         char *vconf_name = vconf_keynode_get_name(key);
 309         SETTING_TRACE("the value of [ %s ] just changed", vconf_name);
 310         int i = 0;
 311
 312         if (!safeStrCmp(vconf_name, VCONFKEY_TELEPHONY_FLIGHT_MODE)) {
 313                 int flightmode = 0;
 314                 vconf_get_bool(VCONFKEY_TELEPHONY_FLIGHT_MODE, &flightmode);
 315                 /*Flight mode is ON : Network menu dimmed */
 316                 SETTING_TRACE("vconf flight [%d]", flightmode);
 317                 for (i = VIEW_All_List; i < VIEW_Max; i++) {
 318                         setting_genlist_item_disabled_set(ad->gl_data_item[i][GL_Network], flightmode);
 319                         setting_genlist_item_disabled_set(ad->gl_data_item[i][GL_PM], flightmode);
 320                         item_to_update = ad->gl_data_item[i][GL_FlightMode];
 321                         if (item_to_update) {
 322                                 item_to_update->chk_status = flightmode;
 323                                 const char *tmp = item_to_update->l_swallow_path;
 324                                 SETTING_TRACE("status:%d", flightmode);
 325                                 if (!flightmode) {
 326                                         item_to_update->l_swallow_path = (char *)g_strdup(SETTING_ICON_PATH_CFG"settings_flightoff1.png");
 327                                 } else {
 328                                         item_to_update->l_swallow_path = (char *)g_strdup(SETTING_ICON_PATH_CFG"A01-1_icon_Flight_Mode.png");
 329                                 }
 330                                 G_FREE(tmp);
 331
 332                                 elm_genlist_item_fields_update(item_to_update->item, "*", ELM_GENLIST_ITEM_FIELD_CONTENT);
 333                         }
 334
 335                 }
 336
 337                 SETTING_TRACE_END;
 338                 return;
 339 #if SUPPORT_NETWORK_RESTRICTION
 340         } else if (!safeStrCmp(vconf_name, VCONFKEY_SETAPPL_NETWORK_RESTRICT_MODE)) {
 341                 int status = 0;
 342                 vconf_get_bool(VCONFKEY_SETAPPL_NETWORK_RESTRICT_MODE, &status);
 343
 344                 /* Update network restriction mode UI */
 345                 for (i = VIEW_All_List; i < VIEW_Max; i++) {
 346                         setting_genlist_item_disabled_set(ad->gl_data_item[i][GL_MobileApp], status);
 347                         setting_genlist_item_disabled_set(ad->gl_data_item[i][GL_WiFi], status);
 348                         setting_force_update_gl_item_chk_status(ad->gl_data_item[i][GL_NetRestriction], status);
 349                 }
 350
 351                 return;
 352 #endif
 353         } else if (!safeStrCmp(vconf_name, VCONFKEY_SETAPPL_AUTO_ROTATE_SCREEN_BOOL)) {
 354                 SETTING_TRACE_DEBUG("%s updated", vconf_name);
 355                 int status = 0;
 356                 vconf_get_bool(VCONFKEY_SETAPPL_AUTO_ROTATE_SCREEN_BOOL, &status);
 357                 for (i = VIEW_All_List; i < VIEW_Max; i++) {
 358                         setting_force_update_gl_item_chk_status(ad->gl_data_item[i][GL_Landscape], status);
 359                 }
 360
 361                 if (status) {
 362                         int angle = elm_win_rotation_get(ad->win_main);
 363                         elm_win_rotation_with_resize_set(ad->win_main, angle);
 364                 } else {
 365                         elm_win_rotation_with_resize_set(ad->win_main, 0);
 366                 }
 367                 return;
 368         } else if (!safeStrCmp(vconf_name, VCONFKEY_NFC_STATE)) {
 369                 SETTING_TRACE_DEBUG("%s updated", vconf_name);
 370                 if (ad->nfc_timer) {
 371                         ecore_timer_del(ad->nfc_timer);
 372                         ad->nfc_timer = NULL;
 373                 }
 374
 375                 int status = 0;
 376                 vconf_get_bool(VCONFKEY_NFC_STATE, &status);
 377
 378                 for (i = VIEW_All_List; i < VIEW_Max; i++) {
 379                         item_to_update = ad->gl_data_item[i][GL_NFC];
 380                         if (item_to_update) {
 381                                 item_to_update->swallow_type = SWALLOW_Type_1ICON_1RADIO;
 382                                 item_to_update->chk_status = status;
 383                                 elm_object_item_data_set(item_to_update->item, item_to_update);
 384                                 elm_genlist_item_fields_update(item_to_update->item, "elm.icon.2", ELM_GENLIST_ITEM_FIELD_CONTENT);
 385                         }
 386                 }
 387         } else if (!safeStrCmp(vconf_name, VCONFKEY_SETAPPL_DM_DRIVING_MODE)) {
 388                 SETTING_TRACE_DEBUG("%s updated", vconf_name);
 389                 /* cfg set_item_state has do the work, need to del it, or it will be a issue */
 390
 391                 int status = 0;
 392                 vconf_get_bool(VCONFKEY_SETAPPL_DM_DRIVING_MODE, &status);
 393                 for (i = VIEW_All_List; i < VIEW_Max; i++) {
 394                         item_to_update = ad->gl_data_item[i][GL_DM];
 395                         setting_force_update_gl_item_chk_status(item_to_update, status);
 396                 }
 397         } else if (!safeStrCmp(vconf_name, VCONFKEY_SETAPPL_DEVELOPER_OPTION_STATE)) {
 398 #ifndef BINARY_RELEASE_TYPE_ENG
 399                 /*for user binary: need to check develop_option_state vconf value*/
 400                 if (ad->sub_view[SETTING_TAB_VIEW_GENERAL]) {
 401                         SETTING_TRACE("redraw Gernel Tab");
 402                         evas_object_del(ad->sub_view[SETTING_TAB_VIEW_GENERAL]);
 403                         ad->sub_view[SETTING_TAB_VIEW_GENERAL] = NULL;
 404                 }
 405                 setting_search_genlist_update(ad);
 406 #endif
 407
 408         }  else if (!safeStrCmp(vconf_name, VCONFKEY_SETAPPL_ENHANCED_TOUCH)) {
 409                 int status = 0;
 410                 vconf_get_bool(VCONFKEY_SETAPPL_ENHANCED_TOUCH, &status);
 411
 412                 for (i = VIEW_All_List; i < VIEW_Max; i++) {
 413                         SETTING_TRACE("ad->gl_data_item[%d][GL_TouchSens]:%p", i, ad->gl_data_item[i][GL_TouchSens]);
 414                         item_to_update = ad->gl_data_item[i][GL_TouchSens];
 415                         setting_force_update_gl_item_chk_status(item_to_update, status);
 416                 }
 417         }
 418 }
 419
 420 /**
 421 * the event process when int VCONFS changes
 422 * @todo code clean - it has big if-else structure
 423 */
 424 static void setting_int_vconf_change_cb(keynode_t *key, void *data)
 425 {
 426         setting_main_appdata *ad = data;
 427         retm_if(!data, "Invalid argument: data is NULL");
 428
 429         int status = vconf_keynode_get_int(key);
 430         char *vconf_name = vconf_keynode_get_name(key);
 431         SETTING_TRACE("Enter %s(%s=%d)", __FUNCTION__, vconf_name, status);
 432
 433         Setting_GenGroupItem_Data *item_to_update = NULL;
 434         int i = 0;
 435         if (!safeStrCmp(vconf_name, VCONFKEY_WIFI_STATE)) {
 436                 /* do handling in case of VCONFKEY_WIFI_STATE */
 437                 SETTING_TRACE_DEBUG("%s updated", vconf_name);
 438                 SETTING_TRACE("status:%d", status);
 439                 int on_off_state = EINA_FALSE;
 440                 switch (status) {
 441                         case VCONFKEY_WIFI_OFF:
 442                                 on_off_state = EINA_FALSE;
 443                                 break;
 444
 445                         case VCONFKEY_WIFI_UNCONNECTED: {
 446                                         /*item_to_update->chk_status = EINA_FALSE; */
 447                                         /*item_to_update->swallow_type = SWALLOW_Type_1ICON_1PROCESS; */
 448                                         /*elm_object_item_data_set(item_to_update->item, item_to_update); */
 449                                         /*elm_genlist_item_update(item_to_update->item); */
 450                                         /*return; */
 451                                         bool last_state = FALSE;
 452                                         int r = preference_get_boolean(WIFI_LAST_ON_OFF_STATE, &last_state);
 453                                         if (0 != r) {
 454                                                 SETTING_TRACE("ERROR, r:%d", r);
 455                                         }
 456                                         char *ap_name = vconf_get_str(VCONFKEY_WIFI_CONNECTED_AP_NAME);
 457                                         SETTING_TRACE("Connect AP:%s", ap_name);
 458                                         if (last_state) {
 459                                                 /*on -> off */
 460                                                 SETTING_TRACE("on -> off");
 461                                                 if (isEmptyStr(ap_name)) {
 462                                                         if (OP_WIFI_TURNING_ON == ad->wifi_op
 463                                                             || OP_WIFI_TURNING_OFF == ad->wifi_op) {
 464                                                                 SETTING_TRACE("Operating in Setting(ad->wifi_op:%d)", ad->wifi_op);
 465                                                                 /*ad->wifi_op = OP_WIFI_TURNING_INVALID; */
 466                                                                 /*on_off_state = EINA_FALSE; */
 467                                                                 return;
 468                                                         } else {
 469                                                                 SETTING_TRACE("Operating in Other App");
 470                                                                 return;
 471                                                         }
 472                                                 } else {
 473                                                         on_off_state = EINA_FALSE;
 474                                                 }
 475                                         } else {
 476                                                 /*off -> on */
 477                                                 SETTING_TRACE("off -> on");
 478                                                 on_off_state = EINA_TRUE;
 479                                         }
 480                                         break;
 481                                 }
 482                         case VCONFKEY_WIFI_CONNECTED:
 483                         case VCONFKEY_WIFI_TRANSFER:
 484
 485                                 on_off_state = EINA_TRUE;
 486                                 break;
 487                         default:
 488                                 SETTING_TRACE_ERROR("Invalid wifi status!");
 489                                 return;
 490                 }
 491                 ad->wifi_op = OP_WIFI_TURNING_INVALID;
 492                 if (ad->wifi_timer) {
 493                         ecore_timer_del(ad->wifi_timer);
 494                         ad->wifi_timer = NULL;
 495                 }
 496
 497                 for (i = VIEW_All_List; i < VIEW_Max; i++) {
 498                         item_to_update = ad->gl_data_item[i][GL_WiFi];
 499                         if (item_to_update) {
 500
 501                                 item_to_update->chk_status = on_off_state;
 502                                 item_to_update->swallow_type = SWALLOW_Type_1ICON_1RADIO;
 503                                 elm_object_item_data_set(item_to_update->item, item_to_update);
 504                                 elm_genlist_item_update(item_to_update->item);
 505                         }
 506                 }
 507                 preference_set_boolean(WIFI_LAST_ON_OFF_STATE, on_off_state);
 508         } else if (!safeStrCmp(vconf_name, VCONFKEY_CALL_STATE)) {
 509                 /* do handling in case of VCONFKEY_CALL_STATE */
 510                 /*In call situation : Wi-fi / Tethering / Network menu dimmed */
 511                 for (i = VIEW_All_List; i < VIEW_Max; i++) {
 512                         status = (VCONFKEY_CALL_OFF != status);
 513                         setting_genlist_item_disabled_set(ad->gl_data_item[i][GL_WiFi], status);
 514                         setting_genlist_item_disabled_set(ad->gl_data_item[i][GL_MobileApp], status);
 515                 }
 516
 517         } else if (!safeStrCmp(vconf_name, VCONFKEY_BT_STATUS)) {
 518                 /* do handling in case of VCONFKEY_BT_STATUS */
 519                 SETTING_TRACE_DEBUG("%s updated", vconf_name);
 520                 if (ad->bt_timer) {
 521                         ecore_timer_del(ad->bt_timer);
 522                         ad->bt_timer = NULL;
 523                 }
 524
 525                 for (i = VIEW_All_List; i < VIEW_Max; i++) {
 526                         item_to_update = ad->gl_data_item[i][GL_BT];
 527                         if (item_to_update) {
 528                                 item_to_update->swallow_type = SWALLOW_Type_1ICON_1RADIO;
 529                                 item_to_update->chk_status = status;
 530                                 elm_object_item_data_set(item_to_update->item, item_to_update);
 531                                 elm_genlist_item_fields_update(item_to_update->item, "elm.icon.2", ELM_GENLIST_ITEM_FIELD_CONTENT);
 532                         }
 533                 }
 534
 535         } else if (!safeStrCmp(vconf_name, VCONFKEY_MOBILE_HOTSPOT_MODE)) {
 536         } else if (!safeStrCmp(vconf_name, VCONFKEY_SYSMAN_BATTERY_STATUS_LOW)) {
 537                 /* do handling in case of VCONFKEY_SYSMAN_BATTERY_STATUS_LOW */
 538                 status  = (status <= VCONFKEY_SYSMAN_BAT_CRITICAL_LOW);
 539                 for (i = VIEW_All_List; i < VIEW_Max; i++) {
 540                         setting_genlist_item_disabled_set(ad->gl_data_item[i][GL_Bright], status);
 541                 }
 542
 543         } else if (!safeStrCmp(vconf_name, VCONFKEY_SETAPPL_BRIGHTNESS_AUTOMATIC_INT)) {
 544                 /* do handling in case of VCONFKEY_SETAPPL_BRIGHTNESS_AUTOMATIC_INT */
 545                 /*update directly */
 546                 for (i = VIEW_All_List; i < VIEW_Max; i++) {
 547                         item_to_update = ad->gl_data_item[i][GL_Bright];
 548                         if (item_to_update) {
 549                                 G_FREE(item_to_update->sub_desc);
 550                                 item_to_update->sub_desc = (char *)g_strdup(get_brightness_mode_str());
 551                                 elm_object_item_data_set(item_to_update->item, item_to_update);
 552                                 elm_genlist_item_update(item_to_update->item);
 553                         }
 554                 }
 555         } else if (!safeStrCmp(vconf_name, VCONFKEY_SETAPPL_LCD_TIMEOUT_NORMAL)) {
 556                 /*update directly */
 557                 for (i = VIEW_All_List; i < VIEW_Max; i++) {
 558                         item_to_update = ad->gl_data_item[i][GL_Backlight];
 559                         if (item_to_update) {
 560                                 char backlight_time_str[MAX_DISPLAY_NAME_LEN_ON_UI];
 561                                 if (status == 0) {
 562                                         snprintf(backlight_time_str, sizeof(backlight_time_str), "%s",
 563                                                  _("IDS_ST_BODY_ALWAYS_ON"));
 564                                 } else if (status == 60) {
 565                                         snprintf(backlight_time_str, sizeof(backlight_time_str), "%s",
 566                                                  _("IDS_ST_BODY_1MINUTE"));
 567                                 } else if (status > 60) {
 568                                         snprintf(backlight_time_str, sizeof(backlight_time_str),
 569                                                  "%d %s", status / 60, (char *)(_("IDS_CLD_OPT_MINUTES_LC_ABB")));
 570                                 } else {
 571                                         snprintf(backlight_time_str, sizeof(backlight_time_str),
 572                                                  "%d %s", status, (char *)(_("IDS_ST_BODY_SECONDS")));
 573                                 }
 574                                 SETTING_TRACE("backlight_time_str:%s", backlight_time_str);
 575                                 G_FREE(item_to_update->sub_desc);
 576                                 item_to_update->sub_desc = (char *)g_strdup(backlight_time_str);
 577                                 elm_object_item_data_set(item_to_update->item, item_to_update);
 578                                 elm_genlist_item_update(item_to_update->item);
 579                         }
 580                 }
 581         } else if (!safeStrCmp(vconf_name, VCONFKEY_SETAPPL_ACCESSIBILITY_FONT_SIZE)) {
 582
 583                 /* do nothing */
 584
 585         } else if (!safeStrCmp(vconf_name, VCONFKEY_SYSMAN_BATTERY_CAPACITY)) {
 586         } else {
 587                 SETTING_TRACE_ERROR("vconf_name is bad[%s]", vconf_name);
 588         }
 589
 590         return;
 591 }
 592
 593
 594 /**
 595 * the event process when string VCONFS changes
 596 */
 597 static void setting_string_vconf_change_cb(keynode_t *key, void *data)
 598 {
 599         setting_main_appdata *ad = data;
 600         retm_if(!data, "Invalid argument: data is NULL");
 601
 602         char *value = vconf_keynode_get_str(key);
 603         char *vconf_name = vconf_keynode_get_name(key);
 604         SETTING_TRACE("Enter %s(%s=%s)", __FUNCTION__, vconf_name, value);
 605
 606         if (!safeStrCmp(vconf_name, VCONFKEY_WIFI_CONNECTED_AP_NAME)) {
 607         } /* vconf_name == VCONFKEY_WIFI_CONNECTED_AP_NAME */
 608         else if (!safeStrCmp(vconf_name, VCONFKEY_SETAPPL_SCREENMODE_SELNAME)) {
 609                 int i;
 610                 for (i = VIEW_All_List; i < VIEW_Max; i++) {
 611                         Setting_GenGroupItem_Data *item_to_update = ad->gl_data_item[i][GL_Screenmode];
 612                         if (item_to_update) {
 613                                 char *tmp = item_to_update->sub_desc;
 614                                 item_to_update->sub_desc = get_pa_screen_mode_str();
 615
 616                                 SETTING_TRACE("item_to_update->sub_desc:%s", item_to_update->sub_desc);
 617                                 elm_object_item_data_set(item_to_update->item, item_to_update);
 618                                 elm_genlist_item_update(item_to_update->item);
 619                                 G_FREE(tmp);
 620                         }
 621                 }
 622         } else if (!safeStrCmp(vconf_name, VCONFKEY_BGSET)
 623                    || !safeStrCmp(vconf_name, VCONFKEY_IDLE_LOCK_BGSET)) {
 624         }
 625 }
 626
 627 /**
 628 * The function is called to create Setting view widgets
 629 */
 630 static bool setting_main_app_create(void *data)
 631 {
 632         SETTING_TRACE_BEGIN;
 633         LAUNCH_SETTING_IN();
 634         SETTING_TRACE_DEBUG("[TIME] 3. it taked %d msec from main to setting_main_app_create ", appcore_measure_time());
 635         appcore_measure_start();
 636
 637         /*elm_config_preferred_engine_set("opengl_x11"); */
 638         ug_create_cb(setting_ug_create_cb, NULL);
 639
 640 #ifdef TIZEN_BUILD_TARGET
 641         SETTING_TRACE_DEBUG(" ------------------------> TIZEN_BUILD_TARGET is ON");
 642 #endif
 643
 644 #ifdef TIZEN_BUILD_EMULATOR
 645         SETTING_TRACE_DEBUG(" ------------------------> TIZEN_BUILD_EMULATOR is ON");
 646 #endif
 647
 648 #if SUPPORT_DRI
 649         setenv("EVAS_DRI_SWAPBUF", "1", 1);
 650 #endif
 651
 652         setting_main_appdata *ad = data;
 653         /* regitering sigterm */
 654         if (signal(SIGTERM, termination_handler) == SIG_IGN) {
 655                 signal(SIGTERM, SIG_IGN);
 656         }
 657
 658         app_event_handler_h handlers[5] = {NULL, };
 659         ui_app_add_event_handler(&handlers[APP_EVENT_LOW_BATTERY], APP_EVENT_LOW_BATTERY, setting_main_low_battery_cb, ad);
 660         ui_app_add_event_handler(&handlers[APP_EVENT_LANGUAGE_CHANGED], APP_EVENT_LANGUAGE_CHANGED, setting_main_lang_changed_cb, ad);
 661         ui_app_add_event_handler(&handlers[APP_EVENT_REGION_FORMAT_CHANGED], APP_EVENT_REGION_FORMAT_CHANGED, setting_main_region_changed_cb, ad);
 662         ui_app_add_event_handler(&handlers[APP_EVENT_DEVICE_ORIENTATION_CHANGED], APP_EVENT_DEVICE_ORIENTATION_CHANGED, NULL, NULL);    /* no callback */
 663
 664
 665 #if 0
 666         app_control_h svc;
 667         app_control_create(&svc);
 668         /*app_control_create_request(b, &svc); */
 669         /*ad->is_searchmode = setting_main_sfinder_handler(svc, ad, NULL); */
 670         app_control_destroy(svc);
 671         svc = NULL;
 672 #endif
 673         /*--------------------------------------------------------------------------------------------- */
 674         ad->data_roaming_popup = NULL;
 675
 676         elm_app_base_scale_set(2.4);
 677
 678         /* create window */
 679         ad->win_main = setting_main_create_win(SETTING_PACKAGE);
 680         setting_retvm_if(ad->win_main == NULL, SETTING_RETURN_FAIL, "window is null");
 681         UG_INIT_EFL(ad->win_main, UG_OPT_INDICATOR_ENABLE);
 682         ad->evas = evas_object_evas_get(ad->win_main);
 683         ad->current_rotation = elm_win_rotation_get(ad->win_main);
 684         SETTING_TRACE_DEBUG("ad->current_rotation:%d", ad->current_rotation);
 685         if (elm_win_wm_rotation_supported_get(ad->win_main)) {
 686                 int rots[4] = { 0, 90, 180, 270 };  /* rotation value that app may want */
 687                 elm_win_wm_rotation_available_rotations_set(ad->win_main, rots, 4);
 688         }
 689         evas_object_smart_callback_add(ad->win_main, "wm,rotation,changed", _rot_changed_cb, ad);
 690
 691         /* load config file */
 692         int cfg_operation_ret = setting_cfg_init();
 693         /*PLUGIN_INIT(ad); */
 694         /*if ( ! ad->is_searchmode) */
 695         /*{ */
 696         elm_theme_extension_add(NULL, SETTING_THEME_EDJ_NAME);
 697         elm_theme_extension_add(NULL, SETTING_NEWUX_EDJ_NAME);
 698         elm_theme_extension_add(NULL, SETTING_GENLIST_EDJ_NAME);
 699         elm_theme_extension_add(NULL, SETTING_NEW_GENLIST_EDJ_NAME);
 700         elm_theme_extension_add(NULL, SETTING_SLIDER_EDJ_NAME);
 701         /*} */
 702
 703         elm_win_indicator_mode_set(ad->win_main, ELM_WIN_INDICATOR_SHOW);
 704         elm_win_indicator_opacity_set(ad->win_main, ELM_WIN_INDICATOR_OPAQUE);
 705
 706         evas_object_show(ad->win_main);
 707
 708         g_main_ad = ad;
 709         setting_view_create(&setting_view_main, ad);
 710
 711         /* error handling */
 712         if (Cfg_Error_Type_Sucess != cfg_operation_ret) {
 713                 SETTING_TRACE_ERROR("cfg_operation_ret: %d", cfg_operation_ret);
 714                 const char *notifyStr = NULL;
 715                 switch (cfg_operation_ret) {
 716
 717                         case Cfg_Error_Type_CreateCfg_Failed: {
 718                                         notifyStr = _("failed to create config file, <br>re-install org.tizen.setting please");
 719                                         break;
 720                                 }
 721                         case Cfg_Error_Type_Mkdir_Failed: {
 722                                         notifyStr = _("file system missed<br>/opt/usr/data/setting, <br>re-install org.tizen.setting please");
 723                                         break;
 724                                 }
 725                         case Cfg_Error_Type_RemoveCfg_Failed: {
 726                                         notifyStr = _("config file size 0 byte<br>and failed to re-create it.<br>try to startup the app again");
 727                                         break;
 728                                 }
 729                         case Cfg_Error_Type_ReadCfg_Failed: {
 730                                         notifyStr = _("failed to read config file, <br>try to startup the app again");
 731                                         break;
 732                                 }
 733                         case Cfg_Error_Type_DirPermissionDenied: {
 734                                         notifyStr =
 735                                             _("the dir of config file permission denied");
 736                                         break;
 737                                 }
 738                         case Cfg_Error_Type_FilePermissionDenied: {
 739                                         notifyStr = _("config file permission denied");
 740                                         break;
 741                                 }
 742                         default: {
 743                                         notifyStr = _("Invalid Result, try to startup the app again");
 744                                         break;
 745                                 }
 746                 }
 747                 setting_create_popup_without_btn(ad, ad->win_main, NULL, (char *)notifyStr, NULL, 10, FALSE, FALSE);
 748                 return SETTING_RETURN_FAIL;
 749         }
 750
 751
 752         SETTING_TRACE_DEBUG("[TIME] 4. setting_main_app_create taked %d msec ", appcore_measure_time());
 753         appcore_measure_start();
 754         LAUNCH_SETTING_OUT();
 755         return true;
 756 }
 757
 758 /**
 759 * The function is called when Setting is terminated
 760 */
 761 static void setting_main_app_terminate(void *data)
 762 {
 763         SETTING_TRACE_BEGIN;
 764         setting_main_appdata *ad = data;
 765         if (ad->account_subscribe_handle) {
 766                 (void)account_unsubscribe_notification(ad->account_subscribe_handle);
 767         }
 768         vconf_set_bool(VCONFKEY_SETAPPL_ROTATE_HOLD_BOOL, FALSE);
 769         evas_object_smart_callback_del(ad->win_main, "wm,rotation,changed", _rot_changed_cb);
 770
 771         /*PLUGIN_FINI; */
 772         setting_cfg_exit();
 773         clear_system_service_data();
 774
 775         ug_destroy_all();
 776         ad->ug = NULL;
 777
 778         ug_create_cb(NULL , NULL);
 779
 780         SETTING_TRACE_DEBUG("%s*** SETTING APPLICATION CLOSED ***%s", SETTING_FONT_BGREEN, SETTING_FONT_BLACK);
 781         DEREGISTER_VCONFS(ad->listened_list);
 782
 783
 784 #if SUPPORT_LCD_TIMEOUT_KEEPING
 785         /* once Setting is not running, LCD_TIMEOUT must be backuped */
 786         int back_value = 0;
 787         vconf_get_int(VCONFKEY_LCD_TIMEOUT_NORMAL_BACKUP, &back_value);
 788         vconf_set_int(VCONFKEY_SETAPPL_LCD_TIMEOUT_NORMAL, back_value);
 789 #endif
 790         setting_view_destroy(&setting_view_main, ad);
 791
 792         SETTING_TRACE_DEBUG("!!! After setting_view_destroy");
 793         if (ad->win_main) {
 794                 evas_object_del(ad->win_main);
 795                 ad->win_main = NULL;
 796         }
 797
 798         if (ad->b) {
 799                 bundle_free(ad->b);
 800                 ad->b = NULL;
 801         }
 802
 803         SETTING_TRACE_END;
 804         return;
 805 }
 806
 807 /**
 808 * The function is called when Setting begins run in background from forground
 809 */
 810 static void setting_main_app_pause(void *data)
 811 {
 812         SETTING_TRACE_BEGIN;
 813         setting_main_appdata *ad = data;
 814         if (ad->ug) {
 815                 ug_pause();
 816         }
 817
 818 #if SUPPORT_LCD_TIMEOUT_KEEPING
 819         /* once Setting is running in background, LCD_TIMEOUT must be backuped */
 820         int back_value = 0;
 821         vconf_get_int(VCONFKEY_LCD_TIMEOUT_NORMAL_BACKUP, &back_value);
 822         vconf_set_int(VCONFKEY_SETAPPL_LCD_TIMEOUT_NORMAL, back_value);
 823 #endif
 824
 825 }
 826
 827 /**
 828 * The function is called when Setting begins run in forground from background
 829 */
 830 static void setting_main_app_resume(void *data)
 831 {
 832         SETTING_TRACE_BEGIN;
 833         setting_main_appdata *ad = data;
 834
 835 #if SUPPORT_LCD_TIMEOUT_KEEPING
 836         /* once Setting is running in foreground, LCD_TIMEOUT must be reset to 600 */
 837         vconf_set_int(VCONFKEY_SETAPPL_LCD_TIMEOUT_NORMAL, 600);
 838 #endif
 839         _rot_changed_cb(ad, ad->win_main, NULL);/*to fix P131121-02103 */
 840
 841         if (ad->is_searchmode % 10 == Cfg_Item_AppLauncher_Node) {
 842                 /* app-launching exit */
 843                 elm_exit();
 844         }
 845
 846         if (!(ad->isInUGMode && ad->ug)) {      /* top-level view is not on UG */
 847                 SETTING_TRACE("update main genlist in resuming app without UG");
 848                 Eina_Bool is_freezed = evas_object_freeze_events_get(ad->navibar_main);
 849                 SETTING_TRACE_DEBUG("is_freezed : %d", is_freezed);
 850                 if (is_freezed) {
 851                         evas_object_freeze_events_set(ad->navibar_main, EINA_FALSE);
 852                 }
 853
 854                 /* update personal mode toggle */
 855                 Setting_GenGroupItem_Data *item_to_update;
 856                 int status = 0;
 857                 vconf_get_bool(VCONFKEY_SETAPPL_PERSONAL_MODE_STATUS_BOOL, &status);
 858                 int i;
 859                 for (i = VIEW_All_List; i < VIEW_Max; i++) {
 860                         item_to_update = ad->gl_data_item[i][GL_PersonalPage];
 861                         setting_force_update_gl_item_chk_status(item_to_update, status);
 862                 }
 863         } else if (ad->ug) {
 864                 ug_resume();
 865         }
 866 }
 867
 868 /**
 869  * The function is called by app-fwk after app_create. It always do the process which cost much time.
 870  */
 871 static void setting_main_app_reset(app_control_h service, void *data)
 872 {
 873         SETTING_TRACE_BEGIN;
 874         setting_main_appdata *ad = data;
 875
 876         if (is_searchmode_app(ad->is_searchmode)) {
 877                 evas_object_hide(ad->view_layout);
 878         } else {
 879                 evas_object_show(ad->view_layout);
 880         }
 881         vconf_callback_fn cb = NULL;
 882
 883         cb = setting_int_vconf_change_cb;
 884         REGISTER_VCONF_NODE(ad->listened_list, VCONFKEY_BT_STATUS, cb, data);
 885         REGISTER_VCONF_NODE(ad->listened_list, VCONFKEY_WIFI_STATE, cb, ad);
 886
 887         REGISTER_VCONF_NODE(ad->listened_list, VCONFKEY_SETAPPL_BRIGHTNESS_AUTOMATIC_INT, cb, data);
 888         REGISTER_VCONF_NODE(ad->listened_list, VCONFKEY_SETAPPL_LCD_TIMEOUT_NORMAL, cb, data);
 889         REGISTER_VCONF_NODE(ad->listened_list, VCONFKEY_SETAPPL_ACCESSIBILITY_FONT_SIZE, cb, data);
 890         REGISTER_VCONF_NODE(ad->listened_list, VCONFKEY_SYSMAN_BATTERY_CAPACITY, cb, data);
 891
 892         cb = setting_string_vconf_change_cb;
 893         REGISTER_VCONF_NODE(ad->listened_list, VCONFKEY_WIFI_CONNECTED_AP_NAME, cb, ad);
 894         REGISTER_VCONF_NODE(ad->listened_list, VCONFKEY_SETAPPL_SCREENMODE_SELNAME, cb, ad);
 895         REGISTER_VCONF_NODE(ad->listened_list, VCONFKEY_BGSET, cb, ad);
 896         REGISTER_VCONF_NODE(ad->listened_list, VCONFKEY_IDLE_LOCK_BGSET, cb, ad);
 897
 898         cb = setting_other_vconf_change_cb;
 899         REGISTER_VCONF_NODE(ad->listened_list, VCONFKEY_SETAPPL_USB_MODE_INT, cb, ad);
 900         REGISTER_VCONF_NODE(ad->listened_list, VCONFKEY_SETAPPL_AUTO_ROTATE_SCREEN_BOOL, cb, ad);
 901         REGISTER_VCONF_NODE(ad->listened_list, VCONFKEY_TELEPHONY_FLIGHT_MODE, cb, ad);
 902 #if SUPPORT_NETWORK_RESTRICTION
 903         REGISTER_VCONF_NODE(ad->listened_list, VCONFKEY_SETAPPL_NETWORK_RESTRICT_MODE, cb, ad);
 904 #endif
 905         REGISTER_VCONF_NODE(ad->listened_list, VCONFKEY_SETAPPL_SOUND_STATUS_BOOL, cb, ad);
 906         REGISTER_VCONF_NODE(ad->listened_list, VCONFKEY_SETAPPL_VIBRATION_STATUS_BOOL, cb, ad);
 907 #ifndef BINARY_RELEASE_TYPE_ENG
 908         REGISTER_VCONF_NODE(ad->listened_list, VCONFKEY_SETAPPL_DEVELOPER_OPTION_STATE, cb, ad);
 909 #endif
 910         REGISTER_VCONF_NODE(ad->listened_list, VCONFKEY_SETAPPL_ENHANCED_TOUCH, cb, ad);
 911         /*---------------------------------------------------------------------------------- */
 912
 913         /*---------------------------------------------------------------------------------- */
 914
 915         if (ad->win_main) {
 916                 elm_win_activate(ad->win_main);
 917         }
 918         int flight_mode = 0;
 919         vconf_get_bool(VCONFKEY_TELEPHONY_FLIGHT_MODE, &flight_mode);
 920         if (flight_mode) {
 921                 if (ad->data_network) setting_disable_genlist_item(ad->data_network->item);
 922                 if (ad->data_powersaving) setting_disable_genlist_item(ad->data_powersaving->item);
 923         }
 924 }
 925
 926 EXPORT_PUBLIC
 927 int main(int argc, char *argv[])
 928 {
 929         int r = 0;
 930         setting_main_appdata ad;
 931
 932         SETTING_TRACE_DEBUG("[TIME] 1. aul_launch -> main :: Setting main : %d msec ", appcore_measure_time_from("APP_START_TIME"));
 933         appcore_measure_start();
 934
 935
 936         ui_app_lifecycle_callback_s ops = {
 937                 .create = setting_main_app_create,
 938                 .terminate = setting_main_app_terminate,
 939                 .pause = setting_main_app_pause,
 940                 .resume = setting_main_app_resume,
 941                 .app_control = setting_main_app_reset,
 942         };
 943         memset(&ad, 0x00, sizeof(setting_main_appdata));
 944
 945         bundle *b = NULL;
 946         b = bundle_import_from_argv(argc, argv);
 947         ad.b = b;
 948
 949         SETTING_TRACE_DEBUG("[TIME] 2. main : %d msec ", appcore_measure_time());
 950         appcore_measure_start();
 951         r = ui_app_main(argc, argv, &ops, &ad);
 952         retv_if(r == -1, -1);
 953
 954         return 0;
 955 }