src/setting.c

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