src/setting.c

   1 /*
   2  * setting
   3  *
   4  * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd.
   5  *
   6  * Contact: MyoungJune Park <mj2004.park@samsung.com>
   7  *
   8  * Licensed under the Apache License, Version 2.0 (the "License");
   9  * you may not use this file except in compliance with the License.
  10  * You may obtain a copy of the License at
  11  *
  12  * http://www.apache.org/licenses/LICENSE-2.0
  13  *
  14  * Unless required by applicable law or agreed to in writing, software
  15  * distributed under the License is distributed on an "AS IS" BASIS,
  16  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  17  * See the License for the specific language governing permissions and
  18  * limitations under the License.
  19  *
  20  */
  21 #include <setting.h>
  22 #include <app.h>
  23
  24 #include <appcore-common.h>
  25 #include <Ecore_X.h>
  26 #include <sensor.h>
  27 #include <aul.h>
  28 #include "setting-plugin.h"
  29 #include "setting-main.h"
  30 #include <elm_object.h>
  31 #include <appsvc.h>
  32 #include <EWebKit2.h>
  33 #include <nfc.h>
  34
  35 extern void setting_update_gl_item(void* data);
  36
  37 #define KEY_END "XF86Stop"
  38 #define SUPPORT_UG_MESSAGE
  39
  40 int g_geometry_x, g_geometry_y, g_geometry_w, g_geometry_h;
  41 extern int aul_listen_app_dead_signal(int (*func)(int signal, void *data), void *data);
  42
  43 static void __main_motion_sensor_cb( unsigned long long timestamp, void *data)
  44 {
  45         /* The code 'return ;' will be deleted after the defect of elm_genlist_item_top_show() is fixed */
  46
  47         setting_retm_if(NULL == data, "NULL == data");
  48         setting_main_appdata *ad = (setting_main_appdata *) data;
  49
  50         SETTING_TRACE(">>>>>>>Double tap event detected");
  51         //If it is in UG mode, Setting just send the event to the loaded UG
  52
  53         if (ad->isInUGMode && ad->ug) {
  54         #ifdef SUPPORT_UG_MESSAGE
  55                 SETTING_TRACE(">>>>>>>Send event to UG");
  56
  57                 service_h svc;
  58                 if(service_create(&svc))
  59                         return;
  60
  61                 service_add_extra_data(svc, "Detected", "Double_tap_event");
  62                 if (ug_send_message(ad->ug, svc) != 0) {
  63                         SETTING_TRACE_ERROR("call ug_send_message fail");
  64                 }
  65
  66                 service_destroy(svc);
  67         #else
  68                 //Methord: instead of send message to UG and its sub-UGs,
  69                 //1.To get the layout of UG ,and then
  70                 //2.To get the naviframe of the layout, and then,
  71                 //3.To get the toppest item  of naviframe, and then
  72                 //4.To get the content of naviframe toppest item,that is content
  73                 //5.content ia mainly a genlist,but it is not fixed,it maybe a conformant or another layout
  74                 //  if it is a genlist,directly show its top item
  75                 //  if it is a conformant or another layout,to get all of its sub-objects,then ask turnly
  76                 //     whether it is a genlist,if it is(some sub-object), topply show it.
  77                 //That's all
  78                 Evas_Object *layout = (Evas_Object *)ug_get_layout(ad->ug);
  79                 if (layout) {
  80                         Evas_Object *genlist = NULL;
  81                         Evas_Object *navi_bar = elm_object_part_content_get(layout, "elm.swallow.content");
  82                         Elm_Object_Item *item = elm_naviframe_top_item_get(navi_bar);
  83                         Evas_Object *content = elm_object_item_content_get(item);
  84                         //SETTING_TRACE("content:%p", content);
  85
  86                         const char *type = elm_object_widget_type_get(content);
  87                         //SETTING_TRACE("content type:%s", type);
  88                         if (0 == safeStrCmp(type, "genlist")) {
  89                                 genlist = content;
  90                         } else if (NULL != type) {//type="layout","conformant" etc..
  91                                 //layout
  92                                 //genlist = elm_object_part_content_get(content, "elm.swallow.contents");
  93                                 const Eina_List *subobjs = elm_widget_sub_object_list_get(content);
  94                                 ret_if(!subobjs);
  95                                 Evas_Object *subobj;
  96                                 const Eina_List *l;
  97
  98                                 //just only search the first objects level
  99                                 EINA_LIST_FOREACH(subobjs, l, subobj) {
 100                                         if (!subobj) continue;
 101                                         type = elm_object_widget_type_get(subobj);
 102                                         if (0 == safeStrCmp(type, "genlist")) {
 103                                                 genlist = subobj;
 104                                                 Elm_Object_Item *first_item = elm_genlist_first_item_get(genlist);
 105                                                 if (first_item) {
 106                                                         elm_genlist_item_show(first_item, ELM_GENLIST_ITEM_SCROLLTO_TOP);
 107                                                 }
 108                                         }
 109                                 }
 110                                 return;//to return,because for this case,we need special process.
 111                         } else {
 112                                 //keep genlist to be NULL.
 113                         }
 114                         if (genlist && 0 == safeStrCmp(elm_object_widget_type_get(genlist), "genlist")) {
 115                                 SETTING_TRACE("Get the genlist:%p", genlist);
 116                                 Elm_Object_Item *first_item = elm_genlist_first_item_get(genlist);
 117                                 if (first_item) {
 118                                         elm_genlist_item_show(first_item, ELM_GENLIST_ITEM_SCROLLTO_TOP);
 119                                 }
 120                         }
 121                 }
 122         #endif
 123         } else {
 124                 setting_go_to_navibar_list_top(ad->navibar_main);
 125         }
 126 }
 127
 128 /**
 129 * The event process when hard key is pressed.
 130 */
 131 #if DISABLED_CODE
 132 static int setting_main_keydown_cb(void *data, int type, void *event)
 133 {
 134         SETTING_TRACE_BEGIN;
 135
 136         static int s_count = 0;
 137         Ecore_Event_Key *ev = event;
 138 #if APPLIED_BACK_KEY_UG
 139         if (!safeStrCmp(ev->keyname, KEY_END)) {
 140                 Evas_Object *popup = get_toppest_popup_window(ad->evas);
 141                 if (popup) {
 142                         /* "progressbar"ÀàÐÍµÄpopup, ²»×÷´¦Àí */
 143                         Evas_Object *content = elm_object_content_get(popup);
 144                         const char *type = elm_widget_type_get(content);
 145                         if (type && !safeStrCmp(type, "progressbar")) {
 146                                 SETTING_TRACE_DEBUG ("Found popup[%p], but it respresent a progress bar, so skip it.", popup);
 147                         } else {
 148                                 evas_object_smart_callback_call(popup, "timeout", NULL);
 149                         }
 150                 }
 151                 return;
 152         }
 153
 154         if (ad->isInUGMode) {   /* have some ug being loaded, it was reset to be FALSE in  setting_main_destroy_ug_cb() */
 155                 SETTING_TRACE("Send UG_KEY_EVENT_END to ug");
 156                 ug_send_key_event(UG_KEY_EVENT_END);
 157         } else {
 158                 if (elm_naviframe_top_item_get(ad->navibar_main)
 159                     == elm_naviframe_bottom_item_get(ad->navibar_main)) {
 160                         SETTING_TRACE("To exit Setting App");
 161                         elm_exit();
 162                 } else {
 163                         SETTING_TRACE("To pre-view of Setting App");
 164                         elm_naviframe_item_pop(ad->navibar_main);
 165                 }
 166         }
 167 }
 168 #else
 169         if (ev && !safeStrCmp(ev->keyname, KEY_END)) {
 170                 /* do nothing except exit */
 171                 SETTING_TRACE("before --- elm_exit ");
 172
 173                 elm_exit();
 174                 s_count = s_count + 1;
 175                 SETTING_TRACE("after --- elm_exit = %d ", s_count);
 176         }
 177 #endif
 178         SETTING_TRACE_END;
 179         return 1;
 180 }
 181 #endif
 182
 183 #if LOW_BATTERY_DO_NOTHING
 184
 185 /*  in case of low battery, don't terminate itself.*/
 186
 187 /**
 188 * The event process when battery becomes low.
 189 */
 190 static void setting_main_low_battery_cb(void *data)
 191 {
 192         SETTING_TRACE_BEGIN;
 193         setting_main_appdata *ad = data;
 194
 195         if (ad->ug)
 196                 ug_send_event(UG_EVENT_LOW_BATTERY);
 197 }
 198 #endif
 199
 200 #if SUPPORT_APP_ROATION
 201
 202 /**
 203 * To active rotation effect in Setting App
 204 */
 205 static void setting_main_rotate(app_device_orientation_e m, void *data)
 206 {
 207         SETTING_TRACE_BEGIN;
 208         setting_main_appdata *ad = data;
 209
 210         if (ad == NULL || ad->win_main == NULL)
 211                 return;
 212
 213 #if 0
 214                                 int value = 0;
 215                                 vconf_get_bool
 216                                     (VCONFKEY_SETAPPL_ROTATE_LOCK_BOOL, &value);
 217                                 // true  : aoto rotation OFF
 218                                 // false : auto rotation ON
 219                                 value = !value;
 220 #else
 221         //int hold_flag = 0;
 222         //vconf_get_bool (VCONFKEY_SETAPPL_ROTATE_HOLD_BOOL, &hold_flag);
 223         //SETTING_TRACE("hold_flag:%d", hold_flag);
 224         //if (hold_flag)
 225         //{
 226                 //do nothing..
 227         //      return;
 228         //}
 229
 230         int value = 0;
 231         vconf_get_bool (VCONFKEY_SETAPPL_ROTATE_LOCK_BOOL, &value);
 232         value = !value;
 233
 234         if (value == 0)
 235                 m = 0;
 236
 237         elm_win_rotation_with_resize_set(ad->win_main, m);
 238
 239         /////Send the rotation event to UGs..
 240         enum ug_event event = UG_EVENT_ROTATE_PORTRAIT;
 241         switch (m) {
 242         case APP_DEVICE_ORIENTATION_0:
 243                 event = UG_EVENT_ROTATE_PORTRAIT;
 244                 break;
 245         case APP_DEVICE_ORIENTATION_180:
 246                 event = UG_EVENT_ROTATE_PORTRAIT_UPSIDEDOWN;
 247                 break;
 248         case APP_DEVICE_ORIENTATION_90:
 249                 event = UG_EVENT_ROTATE_LANDSCAPE;
 250                 break;
 251         case APP_DEVICE_ORIENTATION_270:
 252                 event = UG_EVENT_ROTATE_LANDSCAPE_UPSIDEDOWN;
 253                 break;
 254         default:
 255                 return;
 256         }
 257         ug_send_event(event);
 258         //elm_win_rotation_get
 259 #endif
 260
 261 }
 262 #endif
 263
 264 /**
 265 * The event process when region is changes.
 266 */
 267 static void setting_main_region_changed_cb(void *data)
 268 {
 269         setting_main_appdata *ad = data;
 270
 271         if (ad->ug)
 272                 ug_send_event(UG_EVENT_REGION_CHANGE);
 273 }
 274
 275 /**
 276 * The event process when win object is destroyed
 277 */
 278 static void setting_main_del_win(void *data, Evas_Object *obj, void *event)
 279 {
 280         elm_exit();
 281 }
 282
 283 void profile_changed_cb(void *data, Evas_Object * obj, void *event)
 284 {
 285         const char *profile = elm_config_profile_get();
 286
 287         if (strcmp(profile, "desktop") == 0)
 288                 elm_win_indicator_mode_set (obj, ELM_WIN_INDICATOR_HIDE);
 289         else
 290                 elm_win_indicator_mode_set (obj, ELM_WIN_INDICATOR_SHOW);
 291 }
 292
 293 /**
 294 * To create a win object, the win is shared between the App and all its UGs
 295 */
 296 static Evas_Object *setting_main_create_win(const char *name)
 297 {
 298         SETTING_TRACE_BEGIN;
 299         Evas_Object *eo;
 300         int w, h;
 301
 302         //eo = elm_win_add(NULL, name, ELM_WIN_BASIC);
 303         eo = elm_win_util_standard_add(name, name);
 304         if (eo) {
 305                 elm_win_title_set(eo, name);
 306                 evas_object_smart_callback_add(eo, "delete,request", setting_main_del_win, NULL);
 307                 evas_object_smart_callback_add(eo, "profile,changed", profile_changed_cb, NULL);
 308                 //elm_win_conformant_set(eo, EINA_TRUE);
 309                 ecore_x_window_size_get(ecore_x_window_root_first_get(),
 310                                         &w, &h);
 311                 evas_object_resize(eo, w, h);
 312         }
 313
 314         return eo;
 315 }
 316
 317 /**
 318 * exceptional process, reset the env vars by Setting vconf VCONFKEY_LANGSET
 319 */
 320 static void setting_main_lang_changed_cb(void *data)
 321 {
 322         SETTING_TRACE_BEGIN;
 323         setting_main_appdata *ad = data;
 324
 325         char* str = NULL;
 326         if (ad->data_wifi) {
 327             str = (char *)get_pa_Wi_Fi_on_off_str();
 328                 if ( ! str) str = g_strdup("err");
 329             ad->data_wifi->sub_desc = str;
 330         }
 331         if (ad->data_bt) {
 332             str = (char *)g_strdup(get_BT_on_off_str());
 333                 if ( ! str) str = g_strdup("err");
 334             ad->data_bt->sub_desc = str;
 335         }
 336         if (ad->data_nfc) {
 337             str = (char *)g_strdup(get_NFC_on_off_str());
 338                 if ( ! str) str = g_strdup("err");
 339             ad->data_nfc->sub_desc = str;
 340         }
 341         if (ad->data_bright) {
 342                 str = (char*)g_strdup(get_brightness_mode_str());
 343                 if ( ! str) str = g_strdup("err");
 344                 ad->data_bright->sub_desc = str;
 345         }
 346
 347         if (ad->data_moreConnect) {
 348                 char sub_text[MAX_COMMON_BUFFER_LEN] = {0, };
 349                 int idx = 0;
 350                 while (idx < MAX_MORE_MENU_NUM && ad->more_connective_menus[idx])
 351                 {
 352                         if (idx != 0)
 353                         {
 354                                 safeStrNCat(sub_text, ", ", MAX_COMMON_BUFFER_LEN);
 355                         }
 356                         safeStrNCat(sub_text, _(ad->more_connective_menus[idx]), MAX_COMMON_BUFFER_LEN);
 357                         idx++;
 358                 }
 359                 ad->data_moreConnect->sub_desc = g_strdup(sub_text);
 360         }
 361
 362         if (ad->data_moreSystem) {
 363                 char sub_text[MAX_COMMON_BUFFER_LEN] = {0, };
 364                 int idx = 0;
 365                 while (idx < MAX_MORE_MENU_NUM && ad->more_system_menus[idx])
 366                 {
 367                         if (idx != 0)
 368                         {
 369                                 safeStrNCat(sub_text, ", ", MAX_COMMON_BUFFER_LEN);
 370                         }
 371                         safeStrNCat(sub_text, _(ad->more_system_menus[idx]), MAX_COMMON_BUFFER_LEN);
 372                         idx++;
 373                 }
 374                 ad->data_moreSystem->sub_desc = g_strdup(sub_text);
 375         }
 376
 377         if (ad->main_genlist) elm_genlist_realized_items_update(ad->main_genlist);
 378         if (ad->genlist_load) elm_genlist_realized_items_update(ad->genlist_load);
 379
 380         Elm_Object_Item *navi_it = NULL;
 381 #if SUPPORT_MORE_ITEM_FUNCTION
 382         navi_it = elm_naviframe_top_item_get(ad->navibar_main);
 383         if (navi_it) elm_object_item_text_set(navi_it, _(KeyStr_MoreSystem));
 384 #endif
 385
 386         navi_it = elm_naviframe_bottom_item_get(ad->navibar_main);
 387         if (navi_it)
 388                 elm_object_item_text_set(navi_it, _("IDS_COM_BODY_SETTINGS"));
 389
 390         if (ad->edit_item)
 391         {
 392 #if SUPPORT_BOTTOM_BTNS
 393                 elm_object_item_text_set(ad->edit_item, _(EDIT_PREFERRED_STR));
 394 #else
 395                 Evas_Object *eo_btn = elm_object_item_part_content_get(ad->edit_item, "object");
 396                 setting_retm_if(eo_btn == NULL, "get eo_lbtn failed");
 397                 elm_object_text_set(eo_btn, _(EDIT_PREFERRED_STR));
 398 #endif
 399         }
 400
 401         if (ad->segment_all)
 402                 elm_object_item_text_set(ad->segment_all, _(ALL_STR));
 403         if (ad->segment_preferred)
 404                 elm_object_item_text_set(ad->segment_preferred, _(PREFERRED_STR));
 405
 406         // set toolbar text
 407         char tmp_text[MAX_DISPLAY_NAME_LEN_ON_UI + 1] = {0,};
 408         if (MAIN_PROFILE_ALL == ad->profile_type) {
 409                 snprintf(tmp_text, MAX_DISPLAY_NAME_LEN_ON_UI, "%s", _(PREFERRED_STR));
 410         } else if (MAIN_PROFILE_PREFERRED == ad->profile_type) {
 411                 snprintf(tmp_text, MAX_DISPLAY_NAME_LEN_ON_UI, "%s", _(ALL_STR));
 412         } else {
 413                 /* do nothing */
 414         }
 415         Evas_Object *btn = elm_object_item_part_content_get(navi_it, "toolbar_button1");
 416         elm_object_text_set(btn, tmp_text);
 417
 418
 419         if (ad->ug)
 420                 ug_send_event(UG_EVENT_LANG_CHANGE);
 421 }
 422
 423 /**
 424 * the event process when other VCONFS changes
 425 */
 426 static void setting_other_vconf_change_cb(keynode_t *key, void *data)
 427 {
 428         setting_main_appdata *ad = data;
 429         retm_if(!data, "Invalid argument: data is NULL");
 430
 431         Setting_GenGroupItem_Data* item_to_update = NULL;
 432         char *vconf_name = vconf_keynode_get_name(key);
 433         //SETTING_TRACE("the value of [ %s ] just changed", vconf_name);
 434
 435         if (!safeStrCmp(vconf_name, VCONFKEY_SETAPPL_WIDGET_THEME_STR)) {
 436                 return;
 437         } else if (!safeStrCmp(vconf_name, VCONFKEY_TELEPHONY_FLIGHT_MODE)) {
 438                 item_to_update = ad->data_flight;
 439                 retm_if(!item_to_update, "ad->data_flight is NULL");
 440
 441                 int status = 0;
 442                 vconf_get_bool(VCONFKEY_TELEPHONY_FLIGHT_MODE, &status);
 443                 item_to_update->chk_status = status;
 444                 //do not need delay for checks
 445                 elm_check_state_set(item_to_update->eo_check, item_to_update->chk_status);
 446
 447                 //Flight mode is ON : Network menu dimmed
 448                 if (ad->data_network)
 449                 {
 450                         if (status)
 451                         {
 452                                 setting_disable_genlist_item(ad->data_network->item);
 453                         }
 454                         else
 455                         {
 456                                 setting_enable_genlist_item(ad->data_network->item);
 457                         }
 458                 }
 459                 return;
 460         } else if (!safeStrCmp(vconf_name, VCONFKEY_SETAPPL_ROTATE_LOCK_BOOL)) {
 461                 item_to_update = ad->data_rotationMode;
 462                 retm_if(!item_to_update, "ad->data_rotationMode is NULL");
 463
 464                 int status = 0;
 465                 vconf_get_bool(VCONFKEY_SETAPPL_ROTATE_LOCK_BOOL, &status);
 466
 467                 item_to_update->chk_status = !status;
 468                 //do not need delay for checks
 469                 elm_check_state_set(item_to_update->eo_check, item_to_update->chk_status);
 470                 SETTING_TRACE("item_to_update->chk_status:%d", item_to_update->chk_status);
 471                 if (item_to_update->chk_status) //rotation function is not blocked
 472                 {
 473                         SETTING_TRACE("Rotation function is on, it is necessary to adjust the device orientation");
 474                         int mode = APP_DEVICE_ORIENTATION_0;
 475                         mode = app_get_device_orientation();
 476                         elm_win_rotation_with_resize_set(ad->win_main, mode);
 477                 }
 478
 479                 return;
 480         } else if (!safeStrCmp(vconf_name, VCONFKEY_NFC_STATE)) {
 481                 SETTING_TRACE_DEBUG("%s updated", vconf_name);
 482                 item_to_update = ad->data_nfc;
 483                 retm_if(!item_to_update, "ad->data_nfc is NULL");
 484
 485                 int status = 0;
 486                 vconf_get_bool(VCONFKEY_NFC_STATE, &status);
 487
 488                 item_to_update->chk_status = status;
 489                 //do not need delay for checks
 490                 elm_check_state_set(item_to_update->eo_check, item_to_update->chk_status);
 491                 SETTING_TRACE("item_to_update->chk_status:%d", item_to_update->chk_status);
 492
 493                 item_to_update->sub_desc = (char *)g_strdup(get_NFC_on_off_str());
 494                 SETTING_TRACE_DEBUG("%s", item_to_update->sub_desc);
 495
 496                 if (ad->bAppPause || ad->ug) {
 497                         ad->updateItems[GL_ITEM_NFC] = EINA_TRUE;
 498                 } else { // app is not in pause without ug
 499                         elm_object_item_data_set(item_to_update->item, item_to_update);
 500                         elm_genlist_item_update(item_to_update->item);
 501                 }
 502         }
 503 }
 504
 505 /**
 506 * the event process when int VCONFS changes
 507 * @todo code clean - it has big if-else structure
 508 */
 509 static void setting_int_vconf_change_cb(keynode_t *key, void *data)
 510 {
 511         setting_main_appdata *ad = data;
 512         retm_if(!data, "Invalid argument: data is NULL");
 513
 514         int status = vconf_keynode_get_int(key);
 515         char *vconf_name = vconf_keynode_get_name(key);
 516         SETTING_TRACE("Enter %s(%s=%d)", __FUNCTION__, vconf_name, status);
 517
 518         char *pa_wifi_device = NULL;
 519         Setting_GenGroupItem_Data* item_to_update = NULL;
 520
 521
 522         if (!safeStrCmp(vconf_name, VCONFKEY_WIFI_STATE)) {
 523         // do handling in case of VCONFKEY_WIFI_STATE
 524                 item_to_update = ad->data_wifi;
 525                 retm_if(!item_to_update, "ad->data_wifi is NULL");
 526
 527                 switch (status) {
 528                 case VCONFKEY_WIFI_OFF:
 529                         item_to_update->sub_desc = (char *)g_strdup(_("IDS_COM_BODY_OFF_M_STATUS"));
 530
 531                         item_to_update->chk_status = EINA_FALSE;
 532                         break;
 533
 534                 case VCONFKEY_WIFI_UNCONNECTED:
 535                 case VCONFKEY_WIFI_CONNECTED:
 536                 case VCONFKEY_WIFI_TRANSFER:
 537                         pa_wifi_device = vconf_get_str(VCONFKEY_WIFI_CONNECTED_AP_NAME);
 538                         if (NULL != pa_wifi_device && '\0' != pa_wifi_device[0]) {
 539                                 item_to_update->sub_desc = (char *)g_strdup(pa_wifi_device);
 540                         } else {
 541                                 item_to_update->sub_desc = (char *)g_strdup(_("IDS_COM_BODY_ON_M_STATUS"));
 542                         }
 543                         FREE(pa_wifi_device);
 544
 545                         item_to_update->chk_status = EINA_TRUE;
 546                         break;
 547                 default:
 548                         SETTING_TRACE_ERROR("Invalid wifi status!");
 549                         return;
 550                 }
 551
 552                 elm_check_state_set(item_to_update->eo_check, item_to_update->chk_status);
 553
 554                 if (ad->bAppPause || ad->ug) {
 555                         ad->updateItems[GL_ITEM_WIFI] = EINA_TRUE;
 556                 } else { // app is not in pause without ug
 557                         elm_object_item_data_set(item_to_update->item, item_to_update);
 558                         elm_genlist_item_update(item_to_update->item);
 559                 }
 560         }
 561         else if (!safeStrCmp(vconf_name, VCONFKEY_CALL_STATE)) {
 562         // do handling in case of VCONFKEY_CALL_STATE
 563                 //In call situation : Wi-fi / Tethering / Network menu dimmed
 564                 if (VCONFKEY_CALL_OFF != status)
 565                 {
 566                         if (ad->data_network)
 567                                 setting_disable_genlist_item(ad->data_network->item);
 568                         if (ad->data_wifi)
 569                                 setting_disable_genlist_item(ad->data_wifi->item);
 570                 }
 571                 else
 572                 {
 573                         if (ad->data_network)
 574                                 setting_enable_genlist_item(ad->data_network->item);
 575                         if (ad->data_wifi)
 576                                 setting_enable_genlist_item(ad->data_wifi->item);
 577                 }
 578
 579         } else if (!safeStrCmp(vconf_name, VCONFKEY_BT_STATUS)) {
 580                 item_to_update = ad->data_bt;
 581                 retm_if(!item_to_update, "ad->data_bt is NULL");
 582
 583                 if (FALSE == status) {
 584                         item_to_update->sub_desc = (char *)g_strdup(_("IDS_COM_BODY_OFF_M_STATUS"));
 585
 586                         item_to_update->chk_status = EINA_FALSE;
 587                 } else {
 588                         item_to_update->sub_desc = (char *)g_strdup(_("IDS_COM_BODY_ON_M_STATUS"));
 589
 590                         item_to_update->chk_status = EINA_TRUE;
 591                 }
 592
 593                 item_to_update->chk_status = status;
 594                 elm_check_state_set(item_to_update->eo_check, item_to_update->chk_status);
 595
 596                 if (ad->bAppPause || ad->ug) {
 597                         ad->updateItems[GL_ITEM_BT] = EINA_TRUE;
 598                 } else { // app is not in pause without ug
 599                         elm_object_item_data_set(item_to_update->item, item_to_update);
 600                         elm_genlist_item_update(item_to_update->item);
 601                 }
 602         } else if (!safeStrCmp(vconf_name, VCONFKEY_SYSMAN_BATTERY_STATUS_LOW)) {
 603                 if (status <= VCONFKEY_SYSMAN_BAT_CRITICAL_LOW) {
 604                         if (ad->data_bright) {
 605                                 setting_disable_genlist_item(ad->data_bright->item);
 606                         }
 607                 } else {
 608                         if (ad->data_bright) {
 609                                 setting_enable_genlist_item(ad->data_bright->item);
 610                         }
 611
 612                 }
 613         }else if (!safeStrCmp(vconf_name, VCONFKEY_SETAPPL_BRIGHTNESS_AUTOMATIC_INT)) {
 614                 //update directly
 615                 if (ad->data_bright)
 616                 {
 617                         ad->data_bright->sub_desc = (char *)g_strdup(get_brightness_mode_str());
 618                         elm_object_item_data_set(ad->data_bright->item, ad->data_bright);
 619                         elm_genlist_item_update(ad->data_bright->item);
 620                 }
 621         } else {
 622                 SETTING_TRACE_ERROR("vconf_name is bad[%s]", vconf_name);
 623         }
 624
 625         return;
 626 }
 627
 628 /**
 629 * the event process when string VCONFS changes
 630 */
 631 static void setting_string_vconf_change_cb(keynode_t *key, void *data)
 632 {
 633         SETTING_TRACE_BEGIN;
 634         setting_main_appdata *ad = data;
 635         retm_if(!data, "Invalid argument: data is NULL");
 636
 637         char *value = vconf_keynode_get_str(key);
 638         char *vconf_name = vconf_keynode_get_name(key);
 639         Setting_GenGroupItem_Data* item_to_update = NULL;
 640
 641         if (!safeStrCmp(vconf_name, VCONFKEY_WIFI_CONNECTED_AP_NAME)) {
 642                 int status;
 643                 item_to_update = ad->data_wifi;
 644                 retm_if(!item_to_update, "ad->data_wifi is NULL");
 645
 646                 if (0 != vconf_get_int(VCONFKEY_WIFI_STATE, &status)) {
 647                         SETTING_TRACE_ERROR("vconf_get err: %s", VCONFKEY_WIFI_STATE);
 648                         return;
 649                 }
 650                 SETTING_TRACE("status:%d", status);
 651                 switch (status) {
 652                 case VCONFKEY_WIFI_OFF:
 653                         item_to_update->sub_desc =
 654                                 (char *)g_strdup(setting_gettext ("IDS_COM_BODY_OFF_M_STATUS"));
 655
 656                         item_to_update->chk_status = EINA_FALSE;
 657                         elm_check_state_set(item_to_update->eo_check, item_to_update->chk_status);
 658                         break;
 659
 660                 case VCONFKEY_WIFI_UNCONNECTED:
 661                 case VCONFKEY_WIFI_CONNECTED:
 662                 case VCONFKEY_WIFI_TRANSFER:
 663                         if (NULL != value && '\0' != value[0]) {
 664                                 SETTING_TRACE("wifi_device:%s", value);
 665                                 item_to_update->sub_desc = (char *)g_strdup(value);
 666                         } else {
 667                                 item_to_update->sub_desc =
 668                                         (char *) g_strdup(setting_gettext ("IDS_COM_BODY_ON_M_STATUS"));
 669                         }
 670
 671                         item_to_update->chk_status = EINA_TRUE;
 672                         elm_check_state_set(item_to_update->eo_check, item_to_update->chk_status);
 673                         break;
 674                 default:
 675                         SETTING_TRACE_ERROR("Invalid wifi status!");
 676                         return;
 677                 }
 678                 if (ad->bAppPause || ad->ug) {
 679                         ad->updateItems[GL_ITEM_WIFI] = EINA_TRUE;
 680                 } else { // app is not in pause without ug
 681                         elm_object_item_data_set(item_to_update->item, item_to_update);
 682                         elm_genlist_item_update(item_to_update->item);
 683                 }
 684         } // vconf_name == VCONFKEY_WIFI_CONNECTED_AP_NAME
 685 }
 686
 687
 688 /**
 689 * Do the process which cost much time
 690 */
 691 static Eina_Bool setting_on_idle_lazy(void *data)
 692 {
 693         SETTING_TRACE_BEGIN;
 694         setting_main_appdata *ad = data;
 695
 696         /* A. add system event callback */
 697         if (sensor_create(&ad->sf_handle) != SENSOR_ERROR_NONE) {
 698                 SETTING_TRACE_ERROR("sensor attach fail");
 699         }
 700
 701         if (sensor_motion_doubletap_set_cb(ad->sf_handle, __main_motion_sensor_cb, ad) != SENSOR_ERROR_NONE) {
 702                 SETTING_TRACE("sensor_motion_doubletap_set_cb fail to gather data");
 703         }
 704
 705         if (sensor_start(ad->sf_handle, SENSOR_MOTION_DOUBLETAP) != SENSOR_ERROR_NONE) {
 706                 SETTING_TRACE_ERROR("sensor_start fail");
 707         }
 708
 709 #if SUPPORT_APP_ROATION
 710         evas_object_geometry_get(ad->win_main, &g_geometry_x, &g_geometry_y, &g_geometry_w, &g_geometry_h);
 711 #endif
 712
 713         return FALSE;
 714 }
 715
 716 /**
 717 * The function is called to create Setting view widgets
 718 */
 719 static bool setting_main_app_create(void *data)
 720 {
 721         SETTING_TRACE_BEGIN;
 722         //fprintf(stderr, "[TIME] 3. it taked %d msec from main to setting_main_app_create \n", appcore_measure_time());
 723         //SETTING_TRACE("[TIME] 3. it taked %d msec from main to setting_main_app_create ", appcore_measure_time());
 724         //appcore_measure_start();
 725         setting_main_appdata *ad = data;
 726
 727         ad->data_roaming_popup = NULL;
 728
 729         /* create window */
 730         ad->win_main = setting_main_create_win(SETTING_PACKAGE);
 731         setting_retvm_if(ad->win_main == NULL, SETTING_RETURN_FAIL, "window is null");
 732         evas_object_show(ad->win_main);
 733         UG_INIT_EFL(ad->win_main, UG_OPT_INDICATOR_ENABLE);
 734         ad->evas = evas_object_evas_get(ad->win_main);
 735
 736         /* load config file */
 737         int cfg_operation_ret = setting_cfg_init();
 738         PLUGIN_INIT(ad);
 739
 740         elm_theme_extension_add(NULL, SETTING_THEME_EDJ_NAME);
 741 #if SUPPORT_LCD_TIMEOUT_KEEPING
 742         /* to keep according with each other */
 743         int origin_backlight_value;
 744         if (0 !=
 745             vconf_get_int(VCONFKEY_SETAPPL_LCD_TIMEOUT_NORMAL,
 746                           &origin_backlight_value)) {
 747                 /* error handle.. */
 748                 vconf_set_int(VCONFKEY_SETAPPL_LCD_TIMEOUT_NORMAL, 30);
 749                 origin_backlight_value = 30;
 750         }
 751         /* to set intial value */
 752         vconf_set_int(VCONFKEY_LCD_TIMEOUT_NORMAL_BACKUP,
 753                       origin_backlight_value);
 754
 755         /* Firstly, Setting is running in foreground, LCD_TIMEOUT must be 600s(/10m) */
 756         vconf_set_int(VCONFKEY_SETAPPL_LCD_TIMEOUT_NORMAL, 600);
 757 #endif
 758
 759         elm_win_indicator_mode_set(ad->win_main, ELM_WIN_INDICATOR_SHOW);
 760
 761         setting_view_create(&setting_view_main, ad);
 762         setting_view_node_table_register(&setting_view_main, NULL);
 763         setting_view_node_table_register(&setting_view_more_menu, &setting_view_main);
 764
 765         /* error handling */
 766         if (Cfg_Error_Type_Sucess != cfg_operation_ret) {
 767                 SETTING_TRACE_ERROR("cfg_operation_ret: %d", cfg_operation_ret);
 768                 const char *notifyStr = NULL;
 769                 switch (cfg_operation_ret) {
 770
 771                 case Cfg_Error_Type_CreateCfg_Failed:
 772                         {
 773                                 notifyStr = _("failed to create config file, <br>re-install org.tizen.setting please");
 774                                 break;
 775                         }
 776                 case Cfg_Error_Type_Mkdir_Failed:
 777                         {
 778                                 notifyStr = _("file system missed<br>/opt/data/setting, <br>re-install org.tizen.setting please");
 779                                 break;
 780                         }
 781                 case Cfg_Error_Type_RemoveCfg_Failed:
 782                         {
 783                                 notifyStr = _("config file size 0 byte<br>and failed to re-create it.<br>try to startup the app again");
 784                                 break;
 785                         }
 786                 case Cfg_Error_Type_ReadCfg_Failed:
 787                         {
 788                                 notifyStr = _("failed to read config file, <br>try to startup the app again");
 789                                 break;
 790                         }
 791                 case Cfg_Error_Type_DirPermissionDenied:
 792                         {
 793                                 notifyStr =
 794                                     _("the dir of config file permission denied");
 795                                 break;
 796                         }
 797                 case Cfg_Error_Type_FilePermissionDenied:
 798                         {
 799                                 notifyStr = _("config file permission denied");
 800                                 break;
 801                         }
 802                 default:
 803                         {
 804                                 notifyStr = _("Invalid Result, try to startup the app again");
 805                                 break;
 806                         }
 807                 }
 808                 setting_create_popup_without_btn(ad, ad->win_main, NULL, (char *)notifyStr, NULL, 10, FALSE, FALSE);
 809                 return SETTING_RETURN_FAIL;
 810         }
 811         //fprintf(stderr, "[TIME] 4. setting_main_app_create taked %d msec \n", appcore_measure_time());
 812         //SETTING_TRACE("[TIME] 4. setting_main_app_create taked %d msec ", appcore_measure_time());
 813         //appcore_measure_start();
 814
 815         // set default local automatically
 816         set_defaultLangICU();
 817         return true;
 818 }
 819
 820 /**
 821 * The function is called when Setting is terminated
 822 */
 823 static int setting_main_app_terminate(void *data)
 824 {
 825         SETTING_TRACE_BEGIN;
 826         setting_main_appdata *ad = data;
 827         //vconf_set_bool (VCONFKEY_SETAPPL_ROTATE_HOLD_BOOL, FALSE);
 828         PLUGIN_FINI;
 829         setting_cfg_exit();
 830         clear_system_service_data();
 831
 832         ug_destroy_all();
 833         ad->ug = NULL;
 834
 835         SETTING_TRACE("%s*** SETTING APPLICATION CLOSED ***%s",
 836                       SETTING_FONT_BGREEN, SETTING_FONT_BLACK);
 837
 838         DEREGISTER_VCONFS(ad->listened_list);
 839
 840         if (sensor_motion_doubletap_unset_cb(ad->sf_handle) != SENSOR_ERROR_NONE) {
 841                 SETTING_TRACE("sensor_motion_doubletap_unset_cb fail to gather data");
 842         }
 843         sensor_stop(ad->sf_handle, SENSOR_MOTION_DOUBLETAP);
 844         sensor_destroy(ad->sf_handle);
 845
 846 #if SUPPORT_LCD_TIMEOUT_KEEPING
 847         /* once Setting is not running, LCD_TIMEOUT must be backuped */
 848         int back_value = 0;
 849         vconf_get_int(VCONFKEY_LCD_TIMEOUT_NORMAL_BACKUP, &back_value);
 850         vconf_set_int(VCONFKEY_SETAPPL_LCD_TIMEOUT_NORMAL, back_value);
 851 #endif
 852         setting_view_destroy(&setting_view_more_menu, ad);
 853         setting_view_destroy(&setting_view_main, ad);
 854         SETTING_TRACE("!!! After setting_view_destroy");
 855         if (ad->win_main) {
 856                 evas_object_del(ad->win_main);
 857                 ad->win_main = NULL;
 858         }
 859
 860         SETTING_TRACE_END;
 861         return 0;
 862 }
 863
 864 /**
 865 * The function is called when Setting begins run in background from forground
 866 */
 867 static void setting_main_app_pause(void *data)
 868 {
 869         SETTING_TRACE_BEGIN;
 870         setting_main_appdata *ad = data;
 871
 872         ad->bAppPause = EINA_TRUE;
 873         if (ad->ug)
 874                 ug_pause();
 875
 876 #if SUPPORT_LCD_TIMEOUT_KEEPING
 877         /* once Setting is running in background, LCD_TIMEOUT must be backuped */
 878         int back_value = 0;
 879         vconf_get_int(VCONFKEY_LCD_TIMEOUT_NORMAL_BACKUP, &back_value);
 880         vconf_set_int(VCONFKEY_SETAPPL_LCD_TIMEOUT_NORMAL, back_value);
 881 #endif
 882
 883         sensor_stop(ad->sf_handle, SENSOR_MOTION_DOUBLETAP);
 884
 885 }
 886
 887 /**
 888 * The function is called when Setting begins run in forground from background
 889 */
 890 static void setting_main_app_resume(void *data)
 891 {
 892         SETTING_TRACE_BEGIN;
 893         setting_main_appdata *ad = data;
 894
 895         if (sensor_start(ad->sf_handle, SENSOR_MOTION_DOUBLETAP) != SENSOR_ERROR_NONE) {
 896                 SETTING_TRACE_ERROR("sf_start fail");
 897         }
 898
 899         if (ad->ug)
 900                 ug_resume();
 901
 902 #if SUPPORT_LCD_TIMEOUT_KEEPING
 903         /* once Setting is running in foreground, LCD_TIMEOUT must be reset to 600 */
 904         vconf_set_int(VCONFKEY_SETAPPL_LCD_TIMEOUT_NORMAL, 600);
 905 #endif
 906
 907         // update main genlist in resuming app.
 908         ad->bAppPause = EINA_FALSE;
 909         if(!ad->ug) {   // top-level view is not on UG
 910                 SETTING_TRACE("update main genlist in resuming app without UG");
 911                 setting_update_gl_item(ad);     // update genlist sub-texts
 912         }
 913 }
 914
 915 /**
 916  * The function is called by app-fwk after app_create. It always do the process which cost much time.
 917  */
 918 static void setting_main_app_reset(service_h service, void *data)
 919 {
 920         SETTING_TRACE_BEGIN;
 921         setting_main_appdata *ad = data;
 922
 923         int value = 0;
 924         vconf_get_bool (VCONFKEY_SETAPPL_ROTATE_LOCK_BOOL, &value);
 925         SETTING_TRACE("value:%d", value);
 926         if (!value) //rotation function is not blocked
 927         {
 928                 SETTING_TRACE("Rotation function is on, it is necessary to adjust the device orientation");
 929                 int mode = APP_DEVICE_ORIENTATION_0;
 930                 mode = app_get_device_orientation();
 931                 elm_win_rotation_with_resize_set(ad->win_main, mode);
 932         }
 933
 934         vconf_callback_fn cb = NULL;
 935
 936         cb = setting_int_vconf_change_cb;
 937         REGISTER_VCONF_NODE(ad->listened_list, VCONFKEY_BT_STATUS, cb, data);
 938         REGISTER_VCONF_NODE(ad->listened_list, VCONFKEY_WIFI_STATE, cb, ad);
 939         REGISTER_VCONF_NODE(ad->listened_list, VCONFKEY_CALL_STATE, cb, ad);
 940
 941         //do need to disable 'Brightness' menu,just disable sub-items in 'Brightness' menu
 942         //REGISTER_VCONF_NODE(ad->listened_list, VCONFKEY_SYSMAN_BATTERY_STATUS_LOW, cb, ad);
 943         REGISTER_VCONF_NODE(ad->listened_list, VCONFKEY_SETAPPL_BRIGHTNESS_AUTOMATIC_INT, cb, data);
 944
 945         cb = setting_string_vconf_change_cb;
 946         REGISTER_VCONF_NODE(ad->listened_list, VCONFKEY_WIFI_CONNECTED_AP_NAME, cb, ad);
 947
 948         cb = setting_other_vconf_change_cb;
 949         REGISTER_VCONF_NODE(ad->listened_list, VCONFKEY_SETAPPL_USB_MODE_INT, cb, ad);
 950         REGISTER_VCONF_NODE(ad->listened_list, VCONFKEY_SETAPPL_WIDGET_THEME_STR, cb, ad);
 951
 952         REGISTER_VCONF_NODE(ad->listened_list, VCONFKEY_TELEPHONY_FLIGHT_MODE, cb, ad);
 953         REGISTER_VCONF_NODE(ad->listened_list, VCONFKEY_SETAPPL_ROTATE_LOCK_BOOL, cb, ad);
 954         REGISTER_VCONF_NODE(ad->listened_list, VCONFKEY_NFC_STATE, cb, ad);
 955
 956         if (ad->win_main)
 957                 elm_win_activate(ad->win_main);
 958
 959         ecore_idler_add(setting_on_idle_lazy, ad);
 960
 961         int flight_mode = 0;
 962         vconf_get_bool(VCONFKEY_TELEPHONY_FLIGHT_MODE, &flight_mode);
 963         if (flight_mode)
 964         {
 965                 if (ad->data_network) setting_disable_genlist_item(ad->data_network->item);
 966         }
 967
 968         int call_status = VCONFKEY_CALL_OFF;
 969         vconf_get_int(VCONFKEY_CALL_STATE, &call_status);
 970         if (VCONFKEY_CALL_OFF != call_status)
 971         {
 972                 if (ad->data_network) setting_disable_genlist_item(ad->data_network->item);
 973                 if (ad->data_wifi) setting_disable_genlist_item(ad->data_wifi->item);
 974                 //if (ad->data_mobileApp) setting_disable_genlist_item(ad->data_mobileApp->item);
 975         }
 976
 977         /* for jumping view */
 978         service_get_extra_data(service, "view_to_jump", &(ad->view_to_jump));
 979         if(ad->view_to_jump)
 980         {
 981                 SETTING_TRACE_DEBUG("view to jump is %s", ad->view_to_jump);
 982                 /* Jumping */
 983                 if(!safeStrCmp(ad->view_to_jump, KeyStr_Sounds))
 984                 {
 985
 986                         SETTING_TRACE_DEBUG("Kill launched ug.");
 987                         if(ad->isInUGMode == TRUE && (safeStrCmp(ad->cur_loaded_ug, "setting-profile-efl") != 0))
 988                         {
 989                                 ug_destroy_all();
 990                                 ad->ug = NULL;
 991                         }
 992                         if(ad->isInUGMode == TRUE && (safeStrCmp(ad->cur_loaded_ug, "setting-profile-efl") == 0))
 993                         {
 994                                 return;
 995                         }
 996
 997                         struct ug_cbs *cbs = (struct ug_cbs *)calloc(1, sizeof(struct ug_cbs));
 998                         setting_retm_if(!cbs, "calloc failed");
 999                         cbs->layout_cb = setting_main_layout_ug_cb;
1000                         cbs->result_cb = setting_main_result_ug_cb;
1001                         cbs->destroy_cb = setting_main_destroy_ug_cb;
1002                         cbs->priv = (void *)ad;
1003
1004                         SETTING_TRACE_DEBUG("call setting-profile-efl ug");
1005                         ad->ug = ug_create(NULL, "setting-profile-efl", UG_MODE_FULLVIEW, 0, cbs);
1006                         if (ad->ug) {
1007                                 ad->isInUGMode = TRUE;
1008                                 memset(ad->cur_loaded_ug, 0x00, MAX_DISPLAY_NAME_LEN_ON_UI);
1009                                 safeCopyStr(ad->cur_loaded_ug, "setting-profile-efl", MAX_DISPLAY_NAME_LEN_ON_UI);
1010                         } else {
1011                                 evas_object_show(ad->ly_main);
1012
1013                                 SETTING_TRACE_ERROR("errno:%d", errno);
1014                                 setting_create_simple_popup(ad, ad->win_main, NULL, NO_UG_FOUND_MSG);
1015                         }
1016                         if (cbs)
1017                                 FREE(cbs);
1018                         cbs = NULL;
1019                         ad->view_to_jump = NULL;
1020                 }
1021         }
1022         else
1023         {
1024                 SETTING_TRACE_DEBUG("No need to jump view. Draw main.");
1025         }
1026 }
1027
1028 int main(int argc, char *argv[])
1029 {
1030         int r = 0;
1031         setting_main_appdata ad;
1032
1033         elm_init(argc, argv);
1034 #if SUPPORT_GL_ENGINE
1035         // opengl_x11 or software_x11
1036         elm_config_preferred_engine_set("software_x11");
1037 #endif
1038
1039         //fprintf(stderr, "[TIME] 1. aul_launch -> main :: Setting main : %d msec \n", appcore_measure_time_from("APP_START_TIME"));
1040         //SETTING_TRACE("[TIME] 1. aul_launch -> main :: Setting main : %d msec ", appcore_measure_time_from("APP_START_TIME"));
1041         //appcore_measure_start();
1042
1043         app_event_callback_s ops = {
1044                 .create = setting_main_app_create,
1045                 .terminate = setting_main_app_terminate,
1046                 .pause = setting_main_app_pause,
1047                 .resume = setting_main_app_resume,
1048                 .service = setting_main_app_reset,
1049                 .low_battery = setting_main_low_battery_cb,
1050                 .language_changed = setting_main_lang_changed_cb,
1051                 .region_format_changed = setting_main_region_changed_cb,
1052                 .device_orientation = setting_main_rotate,
1053         };
1054
1055
1056         memset(&ad, 0x00, sizeof(setting_main_appdata));
1057
1058         //fprintf(stderr, "[TIME] 2. main : %d msec \n", appcore_measure_time());
1059         //SETTING_TRACE("[TIME] 2. main : %d msec ", appcore_measure_time());
1060         //appcore_measure_start();
1061         r = app_efl_main(&argc, &argv, &ops, &ad);
1062         retv_if(r == -1, -1);
1063
1064         return 0;
1065 }