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