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