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