setting-time/src/setting-time-main.c

   1 /*
   2  * setting
   3  * Copyright (c) 2012 Samsung Electronics Co., Ltd.
   4  *
   5  * Licensed under the Flora License, Version 1.1 (the License);
   6  * you may not use this file except in compliance with the License.
   7  * You may obtain a copy of the License at
   8  *
   9  *     http://floralicense.org/license/
  10  *
  11  * Unless required by applicable law or agreed to in writing, software
  12  * distributed under the License is distributed on an AS IS BASIS,
  13  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14  * See the License for the specific language governing permissions and
  15  * limitations under the License.
  16  */
  17
  18 #include <setting-time-main.h>
  19 #include <sysman_managed.h>
  20
  21 #include <stdio.h>
  22 #include <malloc.h>
  23 #include <time.h>
  24 #include <stdlib.h>
  25 #include <string.h>
  26 #include <sqlite3.h>
  27
  28 #include <vconf.h>
  29 #include <vconf-keys.h>
  30
  31 #include <unicode/udat.h>
  32 #include <unicode/ustring.h>
  33 #include <unicode/uloc.h>
  34 #include <unicode/ucal.h>
  35 #include <unicode/utmscale.h>
  36
  37 #define ONE_MINUTE 60
  38 #define PROGRESS_POPUP_SHOW 0
  39
  40 /*  ICU utilities*/
  41 static UChar *uastrcpy(const char *chars);
  42 static void ICU_set_timezone(const char *timezone);
  43 static int get_timezone_isdst(int* isdst);
  44 static void get_gmt_offset(char *str_buf, int size);
  45
  46 static char* get_timezone_str();
  47 static char* get_city_name_result();
  48 static bool get_city_name(char* tzname);
  49
  50 static char* s_result;
  51 static int query_callback(void *NotUsed, int argc, char **argv, char **azColName);
  52 static bool setting_update_timezone(SettingTimeUG *ad);
  53
  54 static int setting_time_main_create(void *cb);
  55 static int setting_time_main_destroy(void *cb);
  56 static int setting_time_main_update(void *cb);
  57 static int setting_time_main_cleanup(void *cb);
  58
  59 setting_view setting_view_time_main = {
  60         .create = setting_time_main_create,
  61         .destroy = setting_time_main_destroy,
  62         .update = setting_time_main_update,
  63         .cleanup = setting_time_main_cleanup,
  64 };
  65
  66 #if UN_SUPPORT_TIME_DYNAMIC_UPDATE
  67 static void setting_time_reboot_resp_cb(void *data, Evas_Object *obj,
  68                                         void *event_info);
  69 #endif
  70
  71 bool __update_timezone_idler(SettingTimeUG *ad)
  72 {
  73         setting_update_timezone(ad);
  74         ad->update_timezone_idler = NULL;
  75         return 0;
  76 }
  77
  78 void time_changed_callback(keynode_t *key, void *data) {
  79
  80         SETTING_TRACE_DEBUG("time and timezone have been changed: TIME_CHANGED_HEYNOTY_CALLBACK");
  81         SettingTimeUG *ad = (SettingTimeUG *)data;
  82
  83         int ret = setting_time_update_cb(ad);
  84         if (ret != 0) {
  85                 SETTING_TRACE("FAIL: setting_time_update_db(ad)\n");
  86         }
  87
  88         SETTING_TRACE("ad->is_datefield_selected:%d", ad->is_datefield_selected)
  89         if(EINA_TRUE == ad->is_datefield_selected) {
  90                 /* Timezone is not changed and a selected value of the datefield is already changed */
  91                 SETTING_TRACE("Datefield is selected\n");
  92                 return ;
  93         }
  94
  95         tzset();
  96         // vconfset to update timezone
  97         char pTZPath[__MAX_PATH_SIZE];
  98         ssize_t nLen = readlink(SETTING_TZONE_SYMLINK_PATH, pTZPath, sizeof(pTZPath)-1);
  99         if (nLen != -1) {
 100                 pTZPath[nLen] = '\0';
 101         } else {
 102                 SETTING_TRACE("parse error for SETTING_TZONE_SYMLINK_PATH");
 103                 return;
 104         }
 105
 106         if (!__setting_set_city_tzone(&pTZPath[20])) {
 107                 SETTING_TRACE("__setting_set_city_tzone ERROR");
 108                 return;
 109         }
 110         char *timezone = vconf_get_str(VCONFKEY_SETAPPL_TIMEZONE_ID);
 111         setting_retm_if(timezone == NULL, "get vonf failed");
 112         ICU_set_timezone(timezone);
 113         FREE(timezone);
 114
 115         // update timezone
 116         if (ad->update_timezone_idler) {
 117                 ecore_idler_del(ad->update_timezone_idler);
 118                 ad->update_timezone_idler = NULL;
 119         }
 120         ad->update_timezone_idler =
 121             ecore_idler_add((Ecore_Task_Cb) __update_timezone_idler, ad);
 122         // update time
 123         if (ad->refresh_time_idler) {
 124                 ecore_idler_del(ad->refresh_time_idler);
 125                 ad->refresh_time_idler = NULL;
 126         }
 127         ad->refresh_time_idler = ecore_idler_add(setting_update_datefield, ad);
 128 }
 129
 130 void setting_time_update_time_date_format_string(SettingTimeUG *ad)
 131 {
 132         SETTING_TRACE_BEGIN;
 133
 134         struct tm *ts;
 135         struct tm ts_ret;
 136         time_t ctime;
 137
 138         int ret, value, err;
 139
 140         char time_str[MAX_ARGS];
 141
 142         ctime = time(NULL);
 143         ts = localtime_r(&ctime, &ts_ret);
 144         ret_if(!ts);
 145
 146         /* set time in particular format */
 147         ret = setting_get_int_slp_key(INT_SLP_SETTING_REGIONFORMAT_TIME1224, &value, &err);
 148         if (ret == SETTING_RETURN_FAIL)
 149                 value = VCONFKEY_TIME_FORMAT_12;
 150
 151         switch (value) {
 152         case VCONFKEY_TIME_FORMAT_12:
 153                 {
 154                         /* Get Time */
 155                         strftime(time_str, MAX_ARGS, "%l:%M %p ", &ts_ret);
 156                 }
 157                 break;
 158
 159         case VCONFKEY_TIME_FORMAT_24:
 160                 {
 161                         strftime(time_str, MAX_ARGS, "%H:%M", &ts_ret);
 162                 }
 163                 break;
 164         default:
 165                 /* do nothing */
 166                 break;
 167         }
 168
 169         if (ad->data_time) {
 170                 elm_object_item_data_set(ad->data_time->item, ad->data_time);
 171                 elm_genlist_item_update(ad->data_time->item);
 172         }
 173 }
 174
 175 bool setting_update_timezone(SettingTimeUG *ad)
 176 {
 177         /* SETTING_TRACE_BEGIN; */
 178         char time_zone_sub_str[CITY_BUF_SIZE + GMT_BUF_SIZE + 3] = { 0, };
 179         char *pa_timezone = NULL;
 180         char *pa_city = NULL;
 181         int ret = 0;
 182
 183         /*  get time zone */
 184         pa_city = vconf_get_str(VCONFKEY_SETAPPL_CITYNAME_INDEX_INT);
 185         pa_timezone = vconf_get_str(VCONFKEY_SETAPPL_TIMEZONE_INT);
 186
 187         //if ((pa_timezone != NULL) && (_(pa_city) != NULL && safeStrCmp(_(pa_city), "NULL"))) {
 188         if ((pa_timezone != NULL) && (_(pa_city) != NULL )) {
 189                 /* SETTING_TRACE_DEBUG("*** timezone: %s *** ", timezone); */
 190                 /* SETTING_TRACE_DEBUG("*** city: %s *** ", _(city)); */
 191                 /* SETTING_TRACE_DEBUG("*** ret: %d, dst: %d *** ", ret, dst); */
 192
 193                 ret = snprintf(time_zone_sub_str, CITY_BUF_SIZE + GMT_BUF_SIZE + 2, "%s, GMT %s", _(pa_city), pa_timezone);
 194                 //ret = snprintf(time_zone_sub_str, CITY_BUF_SIZE + GMT_BUF_SIZE + 2, "%s, GMT %s", pa_timezone, _(pa_city));
 195                 FREE(pa_city);
 196                 retv_if(ret < 0, 0);
 197         } else {
 198                 ret = snprintf(time_zone_sub_str, CITY_BUF_SIZE + GMT_BUF_SIZE + 2, "%s, GMT +09", _("IDS_WCL_BODY_CITYNAME_SEOUL"));
 199                 retv_if(ret < 0, 0);
 200         }
 201         SETTING_TRACE("ad->data_tz:%p", ad->data_tz);
 202
 203         if (ad->data_tz) {
 204                 ad->data_tz->sub_desc = (char *)g_strdup(time_zone_sub_str);
 205                 elm_object_item_data_set(ad->data_tz->item, ad->data_tz);
 206                 elm_genlist_item_update(ad->data_tz->item);
 207         }
 208         return 0;
 209 }
 210
 211
 212 static void setting_time_main_int_vconf_change_cb(keynode_t *key, void *data)
 213 {
 214         /* SETTING_TRACE_BEGIN; */
 215         ret_if(NULL == data);
 216         SettingTimeUG *ad = data;
 217         int status = vconf_keynode_get_int(key);
 218         char *vconf_name = vconf_keynode_get_name(key);
 219         /* SETTING_TRACE("vconf_name:%s", vconf_name); */
 220
 221         if (!safeStrCmp(vconf_name, VCONFKEY_REGIONFORMAT_TIME1224)) {
 222
 223                 if (ad->data_time) {
 224                         /* VCONFKEY_REGIONFORMAT_TIME1224 1:12H 2:24H */
 225                         if (status <= 2 && status > 0)  /*  1, 2 */
 226                                 --status;       /*  set to 0 or 1 */
 227                         else
 228                                 status = 0;     /*  set 12H       */
 229
 230                         /*  TODO assert 1 or 0 */
 231                         ad->data_time->chk_status = !status;
 232
 233                         char datefield_format[MAX_DATETIME_FORMAT_LEN + 1] = {0, };
 234
 235                         const char *time_format = NULL;
 236                         if (ad->data_time->chk_status)//12 hours
 237                         {
 238                                 time_format = "%I : %M %p";
 239                         } else { //24 hours
 240                                 time_format = "%H : %M";
 241                         }
 242
 243 //get date format from datefiled itself, if elm_datetime_add() supports set date-format via ICU.
 244 #ifdef SUPPORT_DATEFIELD_DATE_FORMAT_AUTOSET
 245                         const char *old_format = elm_datetime_format_get(ad->data_time->eo_check);
 246                         snprintf(datefield_format, MAX_DATE_FORMAT_LEN + 1, //add one space " "
 247                                  "%s", old_format);
 248                         safeStrNCat(datefield_format, time_format, MAX_DATETIME_FORMAT_LEN);
 249                         SETTING_TRACE("datefield_format:%s", datefield_format);
 250 #else
 251                         int value = SETTING_DATE_FORMAT_DD_MM_YYYY;
 252                         int err = -1;
 253
 254                         char *date_format_str[] = { "%d %b %Y", "%b %d %Y", "%Y %b %d", "%Y %d %b" };
 255                         int ret = setting_get_int_slp_key(INT_SLP_SETTING_DATE_FORMAT, &value, &err);
 256                         if (ret == SETTING_RETURN_FAIL)
 257                                 value = SETTING_DATE_FORMAT_DD_MM_YYYY;
 258
 259                         snprintf(datefield_format, MAX_DATETIME_FORMAT_LEN,
 260                                  "%s %s", date_format_str[value], time_format);
 261 #endif
 262
 263                         elm_datetime_format_set(ad->data_time->eo_check, datefield_format);
 264                 }
 265         }
 266 }
 267
 268 static void __update_time_via_sim_card(void *data)
 269 {
 270         setting_retm_if(data == NULL, "Data parameter is NULL");
 271         SettingTimeUG *ad = (SettingTimeUG *) data;
 272         int ret = 0;
 273         int t_nitz = 0;
 274         int t_offset = 0;
 275         ret += vconf_get_int(VCONFKEY_TELEPHONY_NITZ_GMT, &t_nitz);
 276         ret += vconf_get_int(VCONFKEY_TELEPHONY_NITZ_EVENT_GMT, &t_offset);
 277         char *tzpath = vconf_get_str(VCONFKEY_TELEPHONY_NITZ_ZONE);
 278         if (ret != 0 || isEmptyStr(tzpath))
 279         {
 280                 setting_create_simple_popup(ad, ad->ly_main,
 281                                             NULL, _(NOT_SUPPORT_AUTO_UPDATE_DESC));
 282                 return;
 283         }
 284         ret = 0;//reset..
 285
 286         // a.time zone
 287         SETTING_TRACE("tz_path:%s", tzpath);
 288
 289         char tz_path[MAX_COMMON_BUFFER_LEN / 4 + 1];
 290         safeCopyStr(tz_path, SETTING_TIME_ZONEINFO_PATH, MAX_COMMON_BUFFER_LEN / 4);
 291         g_strlcat(tz_path, tzpath, sizeof(tz_path));
 292         SETTING_TRACE("full tz_path:%s", tz_path);
 293         ret = sysman_set_timezone(tz_path);
 294         if (ret < 0) {
 295                 SETTING_TRACE("tzpath is not valid.");
 296                 return;
 297         } else
 298                 SETTING_TRACE("sysman_set_timezone - successful : %s \n", tz_path);
 299         if (!__setting_set_city_tzone(tzpath)) {
 300                 SETTING_TRACE("__setting_set_city_tzone ERROR")
 301                 return;
 302         }
 303         if (get_city_name(tzpath)) {
 304                 SETTING_TRACE(">>>>>> RESULT : %s", get_city_name_result());
 305         }
 306         char* city = get_city_name_result();
 307         SETTING_TRACE("city:%s", city);
 308         if (city)
 309         {
 310                 ret = vconf_set_str(VCONFKEY_SETAPPL_CITYNAME_INDEX_INT, city);
 311                 setting_retm_if(ret != 0, "set vconf[%s] failed", VCONFKEY_SETAPPL_CITYNAME_INDEX_INT);
 312         }
 313         setting_update_timezone(ad);
 314
 315         // b.TIME AND DATE
 316         int t_uptime = 0;
 317         FILE *fp = fopen("/proc/uptime", "r");
 318         if (fp) {
 319                 if (!fscanf(fp, "%d", &t_uptime)) {
 320                         SETTING_TRACE_ERROR("fscanf error");
 321                 }
 322                 fclose(fp);
 323                 fp = NULL;
 324         } else {
 325                 SETTING_TRACE_ERROR("fopen error");
 326         }
 327
 328         SETTING_TRACE("t_nitz:%d, t_offset:%d, t_uptime:%d", t_nitz, t_offset, t_uptime);
 329         time_t t_current = t_nitz + t_uptime - t_offset;
 330         SETTING_TRACE("t_current:%d", t_current);
 331         ret = sysman_set_datetime(t_current);
 332         setting_retm_if(ret == -1, "sysman_set_datetime call failed");
 333         if (ad->data_time) {
 334                 struct tm ts_ret;
 335                 struct tm *ts = localtime_r(&t_current, &ts_ret);
 336                 ret_if(!ts);
 337                 elm_datetime_value_set(ad->data_time->eo_check, &ts_ret);
 338         }
 339
 340         // time change - event
 341         static int t_event_val = -1;
 342         vconf_set_int (VCONFKEY_SYSTEM_TIME_CHANGED, t_event_val);
 343 }
 344
 345 static void __sim_time_info_chg_cb(keynode_t *key, void *data)
 346 {
 347         SETTING_TRACE_BEGIN;
 348         ret_if(NULL == data);
 349         SettingTimeUG *ad = data;
 350         char *vconf_name = vconf_keynode_get_name(key);
 351         SETTING_TRACE("vconf_name:%s", vconf_name);
 352         if (!safeStrCmp(vconf_name, VCONFKEY_TELEPHONY_NITZ_GMT)
 353             || !safeStrCmp(vconf_name, VCONFKEY_TELEPHONY_NITZ_EVENT_GMT)
 354             || !safeStrCmp(vconf_name, VCONFKEY_TELEPHONY_NITZ_ZONE)) {
 355                 int value = 0;
 356                 int err = 0;
 357                 setting_get_bool_slp_key(BOOL_SLP_SETTING_AUTOMATIC_TIME_UPDATE, &value,
 358                                      &err);
 359                 if (value)
 360                 {
 361                         int ret = 0;
 362                         int t_nitz = 0;
 363                         int t_offset = 0;
 364                         ret += vconf_get_int(VCONFKEY_TELEPHONY_NITZ_GMT, &t_nitz);
 365                         ret += vconf_get_int(VCONFKEY_TELEPHONY_NITZ_EVENT_GMT, &t_offset);
 366                         char *tzpath = vconf_get_str(VCONFKEY_TELEPHONY_NITZ_ZONE);
 367                         if (ret != 0 || isEmptyStr(tzpath))
 368                         {
 369                                 return;
 370                         }
 371                         __update_time_via_sim_card(ad);
 372                 }
 373         }
 374 }
 375
 376 /* ***************************************************
 377  *
 378  *basic func
 379  *
 380  ***************************************************/
 381 static void setting_time_main_datefield_change_cb(void *data, Evas_Object *obj,
 382                                       void *event_info)
 383 {
 384         SETTING_TRACE_BEGIN;
 385         /* error check */
 386         ret_if(data == NULL);
 387         Setting_GenGroupItem_Data *list_item = (Setting_GenGroupItem_Data *) data;
 388         SettingTimeUG *ad = list_item->userdata;
 389
 390         ad->is_datefield_selected = EINA_TRUE;
 391
 392         if (ad->update_timer) {
 393                 ecore_timer_reset(ad->update_timer);
 394                 ecore_timer_freeze(ad->update_timer);
 395         }
 396
 397         // If auto update is on, don't anything while the datefield has been updated (i.e., time runs)
 398         if (1 == setting_time_check_automatic_time_update_state()) {
 399                 SETTING_TRACE("AUTO_TIME ON: no action");
 400                 if (ad->update_timer) {
 401                         ecore_timer_thaw(ad->update_timer);
 402                 }
 403                 SETTING_TRACE_END;
 404                 return;
 405         } else {
 406                 // otherwise, we apply a new date which has been changed by a user
 407         }
 408
 409         struct tm _tm;
 410         elm_datetime_value_get(obj, &_tm);
 411
 412         SETTING_TRACE("year : %d, month : %d, day : %d, hour : %d, min : %d",
 413                       _tm.tm_year, _tm.tm_mon, _tm.tm_mday, _tm.tm_hour, _tm.tm_min);
 414         if (2037 < _tm.tm_year) {
 415                 setting_create_simple_popup(ad, ad->win_get,
 416                                             NULL, _(ERR_BIGGER_THAN_2037));
 417                 if (ad->update_timer) {
 418                         ecore_timer_thaw(ad->update_timer);
 419                 }
 420                 return;
 421         }
 422 #if SUPPORT_SCREEN_PROTECTED    /* if not lock the current state, after set the time, the screen will become dimmed */
 423         pm_lock_state(LCD_NORMAL, STAY_CUR_STATE, 0);
 424 #endif
 425         _tm.tm_sec = 0;
 426
 427         int isdst;
 428         if (get_timezone_isdst(&isdst) == SETTING_RETURN_SUCCESS) {
 429                 _tm.tm_isdst = isdst;
 430         } else {
 431                 // error
 432                 SETTING_TRACE_ERROR("get_timezone_isdst() failed");
 433                 if (ad->update_timer) {
 434                         ecore_timer_thaw(ad->update_timer);
 435                 }
 436                 return;
 437         }
 438
 439         /*  local time  -> gmtime */
 440         time_t the_time = mktime(&_tm); /* represent local time */
 441
 442         if ( (time(NULL)/ONE_MINUTE) == (the_time/ONE_MINUTE) )
 443         {
 444                 SETTING_TRACE("Time is not changed\n");
 445                 //current time didn't change
 446                 if (ad->update_timer) {
 447                         ecore_timer_thaw(ad->update_timer);
 448                 }
 449                 return;
 450         }
 451
 452 #if PROGRESS_POPUP_SHOW
 453         // remove popup if created
 454         if (ad->pop_progress) {
 455                 evas_object_del(ad->pop_progress);
 456                 ad->pop_progress = NULL;
 457         }
 458
 459         // create new popup
 460         ad->pop_progress =
 461                 setting_create_popup_with_progressbar(ad, ad->win_get, "pending_list",
 462                                                       NULL, NULL, NULL, 0, TRUE, TRUE);
 463 #endif
 464
 465         // invoke API to change time
 466         int ret = sysman_set_datetime(the_time);
 467
 468         if (ad->update_timer) {
 469                 ecore_timer_thaw(ad->update_timer);
 470         }
 471
 472         setting_retm_if(ret == -1, "sysman_set_datetime call failed");
 473
 474         SETTING_TRACE_END;
 475 }
 476
 477 Eina_Bool __refresh_date_timer(void *data)
 478 {
 479         //SETTING_TRACE_BEGIN;
 480         SettingTimeUG *ad = data;
 481         if (ad->data_time) {
 482                 time_t ctime = time(NULL);
 483                 struct tm ts_ret;
 484                 struct tm *ts = localtime_r(&ctime, &ts_ret);
 485                 retv_if(!ts, 1);
 486
 487                 struct tm ui_time;
 488                 elm_datetime_value_get(ad->data_time->eo_check, &ui_time);
 489                 if ( (ctime/ONE_MINUTE) != (mktime(&ui_time)/ONE_MINUTE) )
 490                 {
 491                         SETTING_TRACE("To refresh the UI element after 1 minute passed.\t in %s", __FUNCTION__);
 492                         elm_datetime_value_set(ad->data_time->eo_check, &ts_ret);
 493                 }
 494         }
 495         return 1;
 496 }
 497
 498 static void __setting_time_main_exp_cb(void *data, Evas_Object *obj,
 499                                        void *event_info)
 500 {
 501         ret_if(NULL == data || NULL == event_info);
 502         SETTING_TRACE_BEGIN;
 503         SettingTimeUG *ad = (SettingTimeUG *) data;
 504         Elm_Object_Item *parentItem = event_info;       /* parent item */
 505         Setting_GenGroupItem_Data *data_parentItem = elm_object_item_data_get(parentItem);      /* parent data */
 506         Evas_Object *scroller = elm_object_item_widget_get(parentItem);
 507
 508         Evas_Object *rgd;
 509         if (data_parentItem == ad->data_time_fmt) {
 510
 511                 rgd = elm_radio_add(scroller);
 512                 elm_radio_value_set(rgd, -1);
 513                 setting_create_Gendial_exp_sub_field(scroller,
 514                                                      &(ad->itc_1icon_1text_sub),
 515                                                      NULL, NULL, parentItem,
 516                                                      SWALLOW_Type_1RADIO, rgd,
 517                                                      VCONFKEY_TIME_FORMAT_12,
 518                                                      "IDS_COM_BODY_12_HOURS",
 519                                                      NULL);
 520
 521                 setting_create_Gendial_exp_sub_field(scroller,
 522                                                      &(ad->itc_1icon_1text_sub),
 523                                                      NULL, NULL, parentItem,
 524                                                      SWALLOW_Type_1RADIO, rgd,
 525                                                      VCONFKEY_TIME_FORMAT_24,
 526                                                      "IDS_ST_BODY_24_HOURS",
 527                                                      NULL);
 528
 529                 setting_update_chk_status(rgd,
 530                                           data_parentItem->int_slp_setting_binded);
 531
 532         } else if (data_parentItem == ad->data_date_fmt) {
 533                 rgd = elm_radio_add(scroller);
 534                 elm_radio_value_set(rgd, -1);
 535                 setting_create_Gendial_exp_sub_field(scroller,
 536                                                      &(ad->itc_1icon_1text_sub),
 537                                                      NULL, NULL, parentItem,
 538                                                      SWALLOW_Type_1RADIO, rgd,
 539                                                      SETTING_DATE_FORMAT_DD_MM_YYYY,
 540                                                      "IDS_ST_BODY_DDMMYYYY_DOT",
 541                                                      NULL);
 542
 543                 setting_create_Gendial_exp_sub_field(scroller,
 544                                                      &(ad->itc_1icon_1text_sub),
 545                                                      NULL, NULL, parentItem,
 546                                                      SWALLOW_Type_1RADIO, rgd,
 547                                                      SETTING_DATE_FORMAT_MM_DD_YYYY,
 548                                                      "IDS_ST_BODY_MM_DD_YYYY_DOT",
 549                                                      NULL);
 550
 551                 setting_create_Gendial_exp_sub_field(scroller,
 552                                                      &(ad->itc_1icon_1text_sub),
 553                                                      NULL, NULL, parentItem,
 554                                                      SWALLOW_Type_1RADIO, rgd,
 555                                                      SETTING_DATE_FORMAT_YYYY_MM_DD,
 556                                                      "IDS_COM_BODY_YYYYMMDD",
 557                                                      NULL);
 558
 559                 setting_create_Gendial_exp_sub_field(scroller,
 560                                                      &(ad->itc_1icon_1text_sub),
 561                                                      NULL, NULL, parentItem,
 562                                                      SWALLOW_Type_1RADIO, rgd,
 563                                                      SETTING_DATE_FORMAT_YYYY_DD_MM,
 564                                                      "IDS_ST_BODY_YYYY_DD_MM_DOT",
 565                                                      NULL);
 566
 567                 setting_update_chk_status(rgd,
 568                                           data_parentItem->int_slp_setting_binded);
 569
 570         } else if (data_parentItem == ad->data_firstday_week_fmt) {
 571                 rgd = elm_radio_add(scroller);
 572                 elm_radio_value_set(rgd, -1);
 573                 setting_create_Gendial_exp_sub_field(scroller,
 574                                                      &(ad->itc_1icon_1text_sub),
 575                                                      NULL, rgd, parentItem,
 576                                                      SWALLOW_Type_1RADIO, rgd,
 577                                                      SETTING_WEEKOFDAY_FORMAT_SUNDAY,
 578                                                      "IDS_ST_BODY_SUNDAY", NULL);
 579
 580                 setting_create_Gendial_exp_sub_field(scroller,
 581                                                      &(ad->itc_1icon_1text_sub),
 582                                                      NULL, rgd, parentItem,
 583                                                      SWALLOW_Type_1RADIO, rgd,
 584                                                      SETTING_WEEKOFDAY_FORMAT_MONDAY,
 585                                                      "IDS_ST_BODY_MONDAY", NULL);
 586
 587                 setting_update_chk_status(rgd,
 588                                           data_parentItem->int_slp_setting_binded);
 589         }
 590 }
 591
 592 /**
 593  * layyout create - remove a conformant
 594  */
 595 Evas_Object *setting_create_win_layout2(Evas_Object *win_layout,
 596                                        Evas_Object *win_obj)
 597 {
 598         Evas_Object *layout = NULL;
 599         //Evas_Object *conform = elm_conformant_add(win_obj);
 600         /*  Base Layout */
 601         layout = elm_layout_add(win_obj);
 602         setting_retvm_if(layout == NULL, FALSE, "layout == NULL");
 603
 604         elm_layout_theme_set(layout, "layout", "application", "default");
 605         evas_object_size_hint_weight_set(layout, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
 606         evas_object_size_hint_align_set(layout, EVAS_HINT_FILL, EVAS_HINT_FILL);
 607         //elm_win_resize_object_add(win_obj, layout);
 608         //elm_win_resize_object_add(win_obj, conform);
 609         //elm_object_content_set(conform, layout);
 610
 611         Evas_Object *bg = setting_create_bg(layout, win_obj, "group_list");
 612         elm_object_part_content_set(layout, "elm.swallow.bg", bg);
 613         evas_object_show(layout);
 614         //evas_object_show(conform);
 615         return layout;
 616 }
 617
 618
 619
 620 Evas_Object *setting_create_layout_navi_bar2(Evas_Object *win_layout,
 621                                                 Evas_Object *win_obj,
 622                                                 char *title_str,
 623                                                 char *lbutton_str, char *rbutton_str, char *mbutton_str,
 624                                                 setting_call_back_func lbutton_click_cb, setting_call_back_func rbutton_click_cb,
 625                                                 setting_call_back_func mbutton_click_cb,
 626                                                 void *cb_data, Evas_Object *eo_view,    /*any container obj constructed on any evas obj */
 627                                             Evas_Object **navi_bar,
 628                                             Evas_Object **titleobj)
 629 {
 630
 631         Evas_Object *layout = setting_create_win_layout2(win_layout, win_obj);
 632         *navi_bar = setting_create_navi_bar(layout);
 633
 634         setting_create_navi_bar_buttons(title_str,
 635                                         lbutton_str, rbutton_str, mbutton_str,
 636                                         lbutton_click_cb, rbutton_click_cb,
 637                                         mbutton_click_cb, cb_data, eo_view /*content */ ,
 638                                         *navi_bar, NULL);
 639         return layout;
 640 }
 641
 642 static int setting_time_main_create(void *cb)
 643 {
 644         SETTING_TRACE_BEGIN;
 645         retv_if(cb == NULL, SETTING_GENERAL_ERR_NULL_DATA_PARAMETER);
 646
 647         SettingTimeUG *ad = (SettingTimeUG *) cb;
 648
 649         char *l_btn = NULL;
 650         char *r_btn = NULL;
 651         char *title = _("IDS_ST_BODY_DATE_AND_TIME");
 652         char *caller = NULL;
 653         ad->is_datefield_selected = EINA_FALSE;
 654
 655         setting_call_back_func l_button_cb = NULL;
 656         setting_call_back_func r_button_cb = NULL;
 657
 658         service_h service = ad->bundle_data;
 659
 660         service_get_extra_data(service, "caller", &caller);
 661         service_get_extra_data(service, "lbutton", &l_btn);
 662         if(l_btn)
 663                 l_button_cb = setting_time_main_click_softkey_caller_exist_left_cb;
 664         service_get_extra_data(service, "title", &title);
 665         service_get_extra_data(service, "rbutton", &r_btn);
 666         if(r_btn)
 667                 r_button_cb = setting_time_main_click_softkey_caller_exist_right_cb;
 668
 669         Evas_Object *scroller;  /*  scroller is a genlist */
 670
 671         ad->caller = caller;
 672         if (ad->caller) {
 673                 /* for setup wizard */
 674                 char *lbtn_str = (char *)g_strdup(l_btn);
 675                 bool same_flag = FALSE;
 676                 if (0 == safeStrCmp(l_btn, _("IDS_COM_BODY_BACK"))) {
 677                         l_btn = (char *)dgettext("sys_string", "IDS_COM_BODY_BACK");
 678                         same_flag = TRUE;
 679                 }
 680
 681                 //Evas_Object *controllbar = NULL;
 682
 683                 scroller = elm_genlist_add(ad->win_main_layout);
 684                 elm_object_style_set(scroller, "dialogue");
 685                 if(scroller == NULL) {
 686                         SETTING_TRACE_ERROR("Cannot set scroller object  as contento of layout");
 687                         // free allocated data before return.
 688                         FREE(lbtn_str);
 689                         return SETTING_DRAW_ERR_FAIL_SCROLLER;
 690                 }
 691
 692                 elm_genlist_clear(scroller);
 693                 ad->ly_main =
 694                             setting_create_layout_navi_bar2(ad->win_main_layout,
 695                                                            ad->win_get,
 696                                                            title,
 697                                                            NULL, NULL, NULL,
 698                                                            NULL, NULL, NULL,
 699                                                            ad, scroller,
 700                                                            &ad->navi_bar,
 701                                                            NULL);
 702                 /* left button */
 703                 Evas_Object *lbtn_obj = elm_button_add(ad->win_main_layout);
 704                 if(lbtn_obj == NULL)
 705                         return SETTING_DRAW_ERR_FAIL_SCROLLER;
 706
 707                 Evas_Object *licon_obj = elm_icon_add(ad->win_main_layout);
 708                 if(licon_obj == NULL)
 709                         return SETTING_DRAW_ERR_FAIL_SCROLLER;
 710                 elm_icon_file_set(licon_obj, IMG_PREVIOUS, NULL);
 711
 712                 elm_object_style_set(lbtn_obj, "naviframe/toolbar/default");
 713                 elm_object_text_set(lbtn_obj, l_btn);
 714                 elm_object_part_content_set(lbtn_obj, "elm.swallow.content", licon_obj);
 715                 evas_object_smart_callback_add(lbtn_obj, "clicked", l_button_cb, ad);
 716
 717                 /* right button */
 718                 Evas_Object *rbtn_obj = elm_button_add(ad->win_main_layout);
 719                 if(rbtn_obj == NULL)
 720                         return SETTING_DRAW_ERR_FAIL_SCROLLER;
 721
 722                 Evas_Object *ricon_obj = elm_icon_add(ad->win_main_layout);
 723                 if(ricon_obj == NULL)
 724                         return SETTING_DRAW_ERR_FAIL_SCROLLER;
 725                 elm_icon_file_set(ricon_obj, IMG_NEXT, NULL);
 726
 727                 elm_object_style_set(rbtn_obj, "naviframe/toolbar/default");
 728                 elm_object_text_set(rbtn_obj, r_btn);
 729                 elm_object_part_content_set(rbtn_obj, "elm.swallow.content", ricon_obj);
 730                 evas_object_smart_callback_add(rbtn_obj, "clicked", r_button_cb, ad);
 731
 732                 Elm_Object_Item *navi_it = elm_naviframe_top_item_get(ad->navi_bar);
 733                 if(navi_it)
 734                 {
 735                         elm_object_item_part_content_set(navi_it, "toolbar_button1", lbtn_obj);
 736                         elm_object_item_part_content_set(navi_it, "toolbar_button2", rbtn_obj);
 737                 }
 738         } else {
 739                 l_btn = _("IDS_COM_BODY_BACK");
 740                 title = _("IDS_ST_BODY_DATE_AND_TIME");
 741                 ad->ly_main =
 742                     setting_create_layout_navi_bar_genlist(ad->win_main_layout,
 743                                                            ad->win_get, title,
 744                                                            l_btn, NULL,
 745                                                            setting_time_main_click_softkey_left_cb,
 746                                                            NULL, ad, &scroller,
 747                                                            &ad->navi_bar);
 748         }
 749         ad->scrl_main = scroller;
 750
 751         int value;
 752         int err;
 753         int ret = 0;
 754         Elm_Object_Item *item;
 755
 756         item = elm_genlist_item_append(scroller, &(ad->itc_seperator), NULL, NULL,
 757                                     ELM_GENLIST_ITEM_NONE, NULL, NULL);
 758         elm_genlist_item_select_mode_set(item, ELM_OBJECT_SELECT_MODE_DISPLAY_ONLY);
 759         setting_get_bool_slp_key(BOOL_SLP_SETTING_AUTOMATIC_TIME_UPDATE, &value,
 760                                  &err);
 761         bool auto_flag = value;
 762
 763         if(auto_flag) //do special process only when auto mode
 764         {
 765                 //to read TAPI vconfs
 766                 int ret = 0;
 767                 int t_nitz = 0;
 768                 int t_offset = 0;
 769                 ret += vconf_get_int(VCONFKEY_TELEPHONY_NITZ_GMT, &t_nitz);
 770                 ret += vconf_get_int(VCONFKEY_TELEPHONY_NITZ_EVENT_GMT, &t_offset);
 771                 char *tzpath = vconf_get_str(VCONFKEY_TELEPHONY_NITZ_ZONE);
 772                 if (ret == 0 && !isEmptyStr(tzpath))
 773                 {
 774                         //1.to update timezone
 775                         char tz_path[MAX_COMMON_BUFFER_LEN / 4 + 1];
 776                         safeCopyStr(tz_path, SETTING_TIME_ZONEINFO_PATH, MAX_COMMON_BUFFER_LEN / 4);
 777                         g_strlcat(tz_path, tzpath, sizeof(tz_path));
 778                         SETTING_TRACE("full tz_path:%s", tz_path);
 779                         ret = sysman_set_timezone(tz_path);
 780                         if (ret < 0) {
 781                                 SETTING_TRACE("tzpath is not valid.");
 782                         } else
 783                                 SETTING_TRACE("sysman_set_timezone - successful : %s \n", tz_path);
 784                         if (!__setting_set_city_tzone(tzpath)) {
 785                                 SETTING_TRACE("__setting_set_city_tzone ERROR")
 786                         }
 787                         if (get_city_name(tzpath)) {
 788                                 SETTING_TRACE(">>>>>> RESULT : %s", get_city_name_result());
 789                         }
 790                         char* city = get_city_name_result();
 791                         SETTING_TRACE("city:%s", city);
 792                         ret = vconf_set_str(VCONFKEY_SETAPPL_CITYNAME_INDEX_INT, city);
 793
 794                         // 2.to set current time
 795                         int t_uptime = 0;
 796                         FILE *fp = fopen("/proc/uptime", "r");
 797                         if (fp) {
 798                                 if (!fscanf(fp, "%d", &t_uptime)) {
 799                                         SETTING_TRACE_ERROR("fscanf error");
 800                                 }
 801                                 fclose(fp);
 802                                 fp = NULL;
 803                         } else {
 804                                 SETTING_TRACE_ERROR("fopen error");
 805                         }
 806
 807                         SETTING_TRACE("t_nitz:%d, t_offset:%d, t_uptime:%d", t_nitz, t_offset, t_uptime);
 808                         time_t t_current = t_nitz + t_uptime - t_offset;
 809                         SETTING_TRACE("t_current:%d", t_current);
 810                         ret = sysman_set_datetime(t_current);
 811                 }
 812         }
 813
 814         /*  UI automatic */
 815         if (!isEmulBin()) {
 816                 ad->data_auto =
 817                     setting_create_Gendial_field_def(scroller, &(ad->itc_1text_1icon),
 818                                                      setting_time_main_mouse_up_Gendial_list_cb,
 819                                                      ad, SWALLOW_Type_1TOGGLE, NULL,
 820                                                      NULL, value,
 821                                                      "IDS_ST_BODY_AUTOMATIC_UPDATE", NULL,
 822                                                      setting_time_main_chk_btn_cb);
 823                 if (ad->data_auto) {
 824                         ad->data_auto->userdata = ad;
 825                 } else {
 826                         SETTING_TRACE_ERROR("ad->data_auto is NULL");
 827                 }
 828
 829                 setting_create_Gendial_field_def(scroller, &itc_multiline_text, NULL,
 830                                                  ad, SWALLOW_Type_LAYOUT_SPECIALIZTION_X,
 831                                                  NULL, NULL, 0, SETTING_TIME_AUTO_UPDATE_DESC, NULL,
 832                                                  NULL);
 833                 elm_genlist_item_select_mode_set(elm_genlist_item_append(scroller, &(itc_seperator), NULL, NULL,ELM_GENLIST_ITEM_NONE, NULL, NULL),
 834                                                  ELM_OBJECT_SELECT_MODE_DISPLAY_ONLY);
 835         }
 836
 837         setting_set_i18n("worldclock", SETTING_TIME_SHARE_LOCAL_PATH);
 838
 839         char time_zone_sub_str[CITY_BUF_SIZE + GMT_BUF_SIZE + 3] = { 0, };
 840         char *pa_timezone = NULL;
 841         char *pa_city = NULL;
 842
 843         pa_city = vconf_get_str(VCONFKEY_SETAPPL_CITYNAME_INDEX_INT);   // IDS_WCL_BODY_CITYNAME_SEOUL
 844         pa_timezone = vconf_get_str(VCONFKEY_SETAPPL_TIMEZONE_INT);             // "Asia/Seoul"
 845
 846         if ((pa_timezone != NULL) && (_(pa_city) != NULL)) {
 847
 848                 // don't use hard coded value
 849                 // get value from current timezone
 850
 851                 char str_buf[GMT_BUF_SIZE] = {0, };
 852                 get_gmt_offset(str_buf, GMT_BUF_SIZE);
 853
 854                 char* timezone_str = get_timezone_str();
 855
 856                 //ret = get_city_name(timezone_str);
 857                 //if (ret) {
 858                 //      SETTING_TRACE(">>>>>> RESULT : %s", get_city_name_result());
 859                 //}
 860                 //char* cityname_id = _(get_city_name_result());
 861                 SETTING_TRACE("timezone : %s, cityname_id :%s", timezone_str, pa_city);
 862                 if (pa_city && 0 != safeStrCmp(_(pa_city), "NULL"))
 863                         ret = snprintf(time_zone_sub_str, CITY_BUF_SIZE + GMT_BUF_SIZE + 2, "%s, GMT %s", _(pa_city), _(str_buf));
 864                 else
 865                         ret = snprintf(time_zone_sub_str, CITY_BUF_SIZE + GMT_BUF_SIZE + 2, "%s, GMT +09", _("IDS_WCL_BODY_CITYNAME_SEOUL"));
 866
 867                 FREE(pa_city);
 868                 FREE(pa_timezone);
 869                 retv_if(ret < 0, 0);
 870         } else {
 871                 // default code
 872                 ret = snprintf(time_zone_sub_str, CITY_BUF_SIZE + GMT_BUF_SIZE + 2, "%s, GMT +09", _("IDS_WCL_BODY_CITYNAME_SEOUL"));
 873                 retv_if(ret < 0, 0);
 874         }
 875
 876         /*  UI create time zone */
 877         ad->data_tz =
 878             setting_create_Gendial_field_def(scroller, &(ad->itc_2text_2),
 879                                              setting_time_main_mouse_up_Gendial_list_cb,
 880                                              ad, SWALLOW_Type_INVALID, NULL,
 881                                              NULL, 0, "IDS_ST_BODY_TIME_ZONE",
 882                                              time_zone_sub_str, NULL);
 883         if (ad->data_tz) {
 884                 ad->data_tz->userdata = ad;
 885         } else {
 886                 SETTING_TRACE_ERROR("ad->data_tz is NULL");
 887         }
 888
 889         /* create DATE_AND_TIME */
 890         /* DATE_AND_TIME */
 891         ret =
 892             setting_get_int_slp_key(INT_SLP_SETTING_REGIONFORMAT_TIME1224,
 893                                     &value, &err);
 894         if (ret == SETTING_RETURN_FAIL) {
 895                 value = VCONFKEY_TIME_FORMAT_12;
 896         }
 897         bool is_12hours = (value == VCONFKEY_TIME_FORMAT_12 ? TRUE : FALSE);
 898         char *date_format_str[] = { "%d %b %Y", "%b %d %Y", "%Y %b %d", "%Y %d %b" };
 899         ret =
 900             setting_get_int_slp_key(INT_SLP_SETTING_DATE_FORMAT, &value, &err);
 901         if (ret == SETTING_RETURN_FAIL)
 902                 value = SETTING_DATE_FORMAT_DD_MM_YYYY;
 903
 904         /*  UI format string */
 905         (void)setting_create_Gendial_field_titleItem(scroller,
 906                                                      &(itc_group_item),
 907                                                      "IDS_ST_BODY_DATE_AND_TIME", NULL);
 908         ad->data_time =
 909             setting_create_Gendial_field_def(scroller, &(ad->itc_layout),
 910                                              setting_time_main_mouse_up_Gendial_list_cb,
 911                                              ad, SWALLOW_Type_LAYOUT_DATEFIELD,
 912                                              NULL, NULL, is_12hours,
 913                                              NULL,//"IDS_ST_BODY_DATE_AND_TIME",
 914                                              date_format_str[value],
 915                                              setting_time_main_datefield_change_cb);
 916         if (ad->data_time) {
 917                 ad->data_time->userdata = ad;
 918                 ad->data_time->isItemDisableFlag = auto_flag;
 919                 elm_genlist_item_select_mode_set(ad->data_time->item, ELM_OBJECT_SELECT_MODE_DISPLAY_ONLY);
 920         } else {
 921                 SETTING_TRACE_ERROR("ad->data_time is NULL");
 922         }
 923         item = elm_genlist_item_append(scroller, &(ad->itc_seperator), NULL, NULL,
 924                                     ELM_GENLIST_ITEM_NONE, NULL, NULL);
 925         elm_genlist_item_select_mode_set(item, ELM_OBJECT_SELECT_MODE_DISPLAY_ONLY);
 926
 927         /*  UI create "Time format" */
 928         setting_enable_expandable_genlist(scroller, ad,
 929                                           __setting_time_main_exp_cb, NULL);
 930
 931         char* pa_time_format = get_pa_time_format_str();
 932         ad->data_time_fmt = setting_create_Gendial_exp_parent_field(scroller,
 933                                                     &(ad->itc_2text_3_parent),
 934                                                     setting_time_main_mouse_up_Gendial_list_cb,
 935                                                     ad, SWALLOW_Type_INVALID,
 936                                                     "IDS_ST_BODY_TIME_FORMAT",
 937                                                     pa_time_format);
 938         if (ad->data_time_fmt) {
 939                 ad->data_time_fmt->int_slp_setting_binded =
 940                         INT_SLP_SETTING_REGIONFORMAT_TIME1224;
 941         } else {
 942                 SETTING_TRACE_ERROR("ad->data_time_fmt is NULL");
 943         }
 944         G_FREE(pa_time_format);
 945
 946 #if APPLIED_DATATIME_DATA_FORMAT
 947         char* pa_date_format = get_pa_date_format_str();
 948         ad->data_date_fmt = setting_create_Gendial_exp_parent_field(scroller,
 949                                                     &(ad->itc_2text_3_parent),
 950                                                     setting_time_main_mouse_up_Gendial_list_cb,
 951                                                     ad, SWALLOW_Type_INVALID,
 952                                                     "IDS_ST_BODY_DATE_FORMAT",
 953                                                     pa_time_format);
 954         if (ad->data_date_fmt) {
 955                 ad->data_date_fmt->int_slp_setting_binded =
 956                         INT_SLP_SETTING_DATE_FORMAT;
 957         } else {
 958                 SETTING_TRACE_ERROR("ad->data_date_fmt is NULL");
 959         }
 960         G_FREE(pa_date_format);
 961 #endif
 962
 963 #if APPLIED_DATATIME_FIRSTDAY_WEEK
 964     char* pa_week = get_pa_week_format_str();
 965         ad->data_firstday_week_fmt =
 966             setting_create_Gendial_exp_parent_field(scroller,
 967                                                     &(ad->itc_2text_3_parent),
 968                                                     setting_time_main_mouse_up_Gendial_list_cb,
 969                                                     ad, SWALLOW_Type_INVALID,
 970                                                     "IDS_CLD_BODY_FIRST_DAY_OF_WEEK",
 971                                                     pa_week);
 972         if (ad->data_firstday_week_fmt) {
 973                 ad->data_firstday_week_fmt->int_slp_setting_binded =
 974                         INT_SLP_SETTING_WEEK_FORMAT;
 975         } else {
 976                 SETTING_TRACE_ERROR("ad->data_firstday_week_fmt is NULL");
 977         }
 978     G_FREE(pa_week);
 979 #endif
 980
 981         item = elm_genlist_item_append(scroller, &itc_bottom_seperator, NULL, NULL,
 982                                     ELM_GENLIST_ITEM_NONE, NULL, NULL);
 983         elm_genlist_item_select_mode_set(item, ELM_OBJECT_SELECT_MODE_DISPLAY_ONLY);
 984
 985         if (auto_flag)
 986         {
 987                 if (ad->data_tz) {
 988                         setting_disable_genlist_item(ad->data_tz->item);
 989                 }
 990                 if (ad->data_time) {
 991                         setting_disable_genlist_item(ad->data_time->item);
 992                 }
 993         }
 994
 995         setting_view_time_main.is_create = 1;
 996         vconf_notify_key_changed(VCONFKEY_SYSTEM_TIME_CHANGED, time_changed_callback, (void *)ad);
 997
 998         /*  register vconf key to get event callback for converting 12/24H */
 999         vconf_notify_key_changed(VCONFKEY_REGIONFORMAT_TIME1224, setting_time_main_int_vconf_change_cb, ad);
1000         /*  register vconf key to get event callback for date format */
1001         vconf_notify_key_changed(VCONFKEY_SETAPPL_DATE_FORMAT_INT, setting_time_main_int_vconf_change_cb, ad);
1002
1003         vconf_notify_key_changed(VCONFKEY_TELEPHONY_NITZ_GMT, __sim_time_info_chg_cb, ad);
1004         vconf_notify_key_changed(VCONFKEY_TELEPHONY_NITZ_EVENT_GMT, __sim_time_info_chg_cb, ad);
1005         vconf_notify_key_changed(VCONFKEY_TELEPHONY_NITZ_ZONE, __sim_time_info_chg_cb, ad);
1006
1007         /* to avoid update time-diff, every per 3s to update. */
1008         ad->update_timer = ecore_timer_add(3, (Ecore_Task_Cb) __refresh_date_timer, ad);
1009
1010         return SETTING_RETURN_SUCCESS;
1011 }
1012
1013 static int setting_time_main_destroy(void *cb)
1014 {
1015         SETTING_TRACE_BEGIN;
1016         /* error check */
1017         retv_if(cb == NULL, SETTING_GENERAL_ERR_NULL_DATA_PARAMETER);
1018
1019         SettingTimeUG *ad = (SettingTimeUG *) cb;
1020
1021         if (ad->update_timer) {
1022                 ecore_timer_del(ad->update_timer);
1023                 ad->update_timer = NULL;
1024         }
1025
1026 #if PROGRESS_POPUP_SHOW
1027         if (ad->pop_progress) {
1028                 evas_object_del(ad->pop_progress);
1029                 ad->pop_progress = NULL;
1030         }
1031 #endif
1032
1033         if (ad->update_timezone_idler) {
1034                 ecore_idler_del(ad->update_timezone_idler);
1035                 ad->update_timezone_idler = NULL;
1036         }
1037         if (ad->refresh_time_idler) {
1038                 ecore_idler_del(ad->refresh_time_idler);
1039                 ad->refresh_time_idler = NULL;
1040         }
1041
1042         vconf_ignore_key_changed(VCONFKEY_SYSTEM_TIME_CHANGED,
1043                                  time_changed_callback);
1044
1045         vconf_ignore_key_changed(VCONFKEY_REGIONFORMAT_TIME1224,
1046                                  setting_time_main_int_vconf_change_cb);
1047         vconf_ignore_key_changed(VCONFKEY_SETAPPL_DATE_FORMAT_INT,
1048                                  setting_time_main_int_vconf_change_cb);
1049
1050         vconf_ignore_key_changed(VCONFKEY_TELEPHONY_NITZ_GMT, __sim_time_info_chg_cb);
1051         vconf_ignore_key_changed(VCONFKEY_TELEPHONY_NITZ_EVENT_GMT, __sim_time_info_chg_cb);
1052         vconf_ignore_key_changed(VCONFKEY_TELEPHONY_NITZ_ZONE, __sim_time_info_chg_cb);
1053
1054         if (ad->ly_main != NULL) {
1055                 evas_object_del(ad->ly_main);
1056                 setting_view_time_main.is_create = 0;
1057         }
1058
1059         return SETTING_RETURN_SUCCESS;
1060 }
1061
1062 static int setting_time_main_update(void *cb)
1063 {
1064         SETTING_TRACE_BEGIN;
1065         retv_if(cb == NULL, SETTING_GENERAL_ERR_NULL_DATA_PARAMETER);
1066
1067         SettingTimeUG *ad = (SettingTimeUG *) cb;
1068
1069         if (ad->ly_main != NULL) {
1070                 evas_object_show(ad->ly_main);
1071                 // update timezone
1072                 if (ad->update_timezone_idler) {
1073                         ecore_idler_del(ad->update_timezone_idler);
1074                         ad->update_timezone_idler = NULL;
1075                 }
1076                 ad->update_timezone_idler =
1077                     ecore_idler_add((Ecore_Task_Cb) __update_timezone_idler, ad);
1078                 // update time
1079                 if (ad->refresh_time_idler) {
1080                         ecore_idler_del(ad->refresh_time_idler);
1081                         ad->refresh_time_idler = NULL;
1082                 }
1083                 ad->refresh_time_idler = ecore_idler_add(setting_update_datefield, ad);
1084         }
1085         return SETTING_RETURN_SUCCESS;
1086 }
1087
1088 static int setting_time_main_cleanup(void *cb)
1089 {
1090         SETTING_TRACE_BEGIN;
1091         return SETTING_RETURN_SUCCESS;
1092 }
1093
1094
1095 /* ***************************************************
1096  **
1097  **general func
1098  **
1099  ****************************************************/
1100
1101 int setting_time_check_automatic_time_update_state()
1102 {
1103         SETTING_TRACE_BEGIN;
1104         int bvalue = 0;
1105         int ret = 0;
1106         int err = 0;
1107
1108         ret =
1109             setting_get_bool_slp_key(BOOL_SLP_SETTING_AUTOMATIC_TIME_UPDATE,
1110                                      &bvalue, &err);
1111
1112         return bvalue;
1113
1114 }
1115
1116 static int __setting_set_city_tzone(const char* pTZPath)
1117 {
1118         // let's get city & timezone string from pTZPath
1119         // 1. city name
1120         char szTimezone[GMT_BUF_SIZE] = {0,};
1121         char* pStr = strdup(pTZPath);
1122
1123         // 2. timezone string +/-<n> ex. +9, -1
1124         get_gmt_offset(szTimezone, GMT_BUF_SIZE);
1125
1126         int ret = vconf_set_str(VCONFKEY_SETAPPL_TIMEZONE_INT, szTimezone);
1127         if (ret == -1) {
1128                 FREE(pStr);
1129                 SETTING_TRACE("set vconf failed");
1130                 return FALSE;
1131         }
1132
1133         // set timezone_id
1134         /** @todo replace with vconf ID */
1135         ret = vconf_set_str(VCONFKEY_SETAPPL_TIMEZONE_ID, pStr);
1136         FREE(pStr);
1137
1138         return TRUE;
1139 }
1140
1141 static void
1142 setting_time_main_launch_worldclock_result_ug_cb(ui_gadget_h ug,
1143                                                  service_h result, void *priv)
1144 {
1145         SETTING_TRACE_BEGIN;
1146         /* error check */
1147         retm_if(priv == NULL, "Data parameter is NULL");
1148
1149         SettingTimeUG *ad = (SettingTimeUG *) priv;
1150
1151         char *city = NULL;
1152         char *tzpath = NULL;
1153         service_get_extra_data(result, "city", &city);
1154         service_get_extra_data(result, "tzpath", &tzpath);
1155
1156         if (!tzpath) {
1157                 SETTING_TRACE("tzpath from worldclock UG is null.");
1158                 return;
1159         } else {
1160                 SETTING_TRACE("tzpath : %s", tzpath );
1161         }
1162         SETTING_TRACE("city : %s", city );
1163
1164         /* --------------------------------------------------------------------- */
1165         char tz_path[MAX_COMMON_BUFFER_LEN / 4 + 1];
1166         safeCopyStr(tz_path, SETTING_TIME_ZONEINFO_PATH, MAX_COMMON_BUFFER_LEN / 4);
1167         g_strlcat(tz_path, tzpath, sizeof(tz_path));
1168         SETTING_TRACE("full tz_path:%s", tz_path);
1169
1170         int ret = sysman_set_timezone(tz_path);
1171         if (ret < 0) {
1172                 SETTING_TRACE("tzpath is not valid.");
1173                 return;
1174         } else
1175                 SETTING_TRACE("sysman_set_timezone - successful : %s \n", tz_path);
1176
1177         ret = vconf_set_str(VCONFKEY_SETAPPL_CITYNAME_INDEX_INT, city);
1178         setting_retm_if(ret != 0, "set vconf failed");
1179
1180         // parse city and GMT offset from tzpath and system time property
1181         // set the strings in vconf which will be used while updating display of timezone
1182         if (!__setting_set_city_tzone(tzpath)) {
1183                 SETTING_TRACE("__setting_set_city_tzone ERROR")
1184                 return;
1185         }
1186
1187         // update the display for timezone
1188         setting_update_timezone(ad);
1189         static int t_event_val = -1;
1190         vconf_set_int (VCONFKEY_SYSTEM_TIME_CHANGED, t_event_val);
1191         SETTING_TRACE_END;
1192 }
1193
1194 void setting_time_main_launch_worldclock_destroy_ug_cb(ui_gadget_h ug,
1195                                                        void *priv)
1196 {
1197         SETTING_TRACE_BEGIN;
1198         /* if(ug) ug_destroy(ug); */
1199         /* restore the '<-' button on the navigate bar */
1200         ret_if(!priv);
1201         SettingTimeUG *ad = (SettingTimeUG *) priv;
1202         if (ug) {
1203                 ug_destroy(ug);
1204                 ad->ug_loading = NULL;
1205         }
1206         Elm_Object_Item *navi_it = elm_naviframe_top_item_get(ad->navi_bar);
1207         ret_if(!navi_it);
1208         Evas_Object *back_btn = elm_object_item_part_content_get(navi_it, "prev_btn");
1209
1210         if (back_btn != NULL) {
1211                 elm_object_style_set(back_btn, NAVI_BACK_BUTTON_STYLE); /* take into effect */
1212         }
1213
1214 }
1215
1216 void setting_time_main_launch_worldclock_layout_ug_cb(ui_gadget_h ug,
1217                                                       enum ug_mode mode,
1218                                                       void *priv)
1219 {
1220         SETTING_TRACE_BEGIN;
1221         SettingTimeUG *ad = (SettingTimeUG *) priv;
1222         Evas_Object *base;
1223
1224         if (!priv)
1225                 return;
1226
1227         base = (Evas_Object *) ug_get_layout(ug);
1228         if (!base)
1229                 return;
1230
1231         switch (mode) {
1232         case UG_MODE_FULLVIEW:
1233                 evas_object_size_hint_weight_set(base, EVAS_HINT_EXPAND,
1234                                                  EVAS_HINT_EXPAND);
1235                 //elm_win_resize_object_add(ad->win_get, base);
1236                 evas_object_show(base);
1237                 break;
1238         default:
1239                 break;
1240         }
1241         SETTING_TRACE_END;
1242 }
1243
1244
1245 void setting_time_main_launch_worldclock_sg(void *data)
1246 {
1247         SETTING_TRACE_BEGIN;
1248         /* error check */
1249         retm_if(data == NULL, "Data parameter is NULL");
1250
1251         SettingTimeUG *ad = (SettingTimeUG *) data;
1252
1253         struct ug_cbs *cbs = (struct ug_cbs *)calloc(1, sizeof(struct ug_cbs));
1254         setting_retm_if(!cbs, "calloc failed");
1255         cbs->layout_cb = setting_time_main_launch_worldclock_layout_ug_cb;
1256         cbs->result_cb = setting_time_main_launch_worldclock_result_ug_cb;
1257         cbs->destroy_cb = setting_time_main_launch_worldclock_destroy_ug_cb;
1258         cbs->priv = (void *)ad;
1259
1260         SETTING_TRACE("to load ug[%s]", "worldclock-efl");
1261         ad->ug_loading =
1262             ug_create(ad->ug, "worldclock-efl", UG_MODE_FULLVIEW, NULL, cbs);
1263         if (NULL == ad->ug_loading) {   /* error handling */
1264         }
1265
1266         FREE(cbs);
1267         return;
1268 }
1269
1270
1271 Eina_Bool setting_update_datefield(void *cb)
1272 {
1273         SETTING_TRACE_BEGIN;
1274         retvm_if(cb == NULL, EINA_FALSE, "Data parameter is NULL");
1275         SettingTimeUG *ad = (SettingTimeUG *) cb;
1276
1277         //__refresh_date_timer(ad);
1278         if (ad->data_time) {
1279                 time_t ctime = time(NULL);
1280                 struct tm ts_ret;
1281                 struct tm *ts = localtime_r(&ctime, &ts_ret);
1282                 if (ts) elm_datetime_value_set(ad->data_time->eo_check, &ts_ret);
1283         }
1284         ad->refresh_time_idler = NULL;
1285         return 0;
1286 }
1287
1288 /* ***************************************************
1289  **
1290  **call back func
1291  **
1292  ****************************************************/
1293
1294 void
1295 setting_time_main_click_softkey_left_cb(void *data, Evas_Object *obj,
1296                                         void *event_info)
1297 {
1298         SETTING_TRACE_BEGIN;
1299         retm_if(data == NULL, "Data parameter is NULL");
1300
1301         SettingTimeUG *ad = (SettingTimeUG *) data;
1302
1303         /* Send destroy request */
1304         ug_destroy_me(ad->ug);
1305 }
1306
1307 /* ***************************************************
1308  **
1309  **call back func
1310  **
1311  ****************************************************/
1312
1313 void
1314 setting_time_main_click_softkey_caller_exist_left_cb(void *data,
1315                                                      Evas_Object *obj,
1316                                                      void *event_info)
1317 {
1318         SETTING_TRACE_BEGIN;
1319         /* error check */
1320         retm_if(data == NULL, "Data parameter is NULL");
1321
1322         SettingTimeUG *ad = (SettingTimeUG *) data;
1323
1324         /*  Create Bundle and send message */
1325         service_h svc;
1326         if (service_create(&svc))
1327                 return;
1328
1329         service_add_extra_data(svc, "result", "lbutton_click");
1330         ug_send_result(ad->ug, svc);
1331
1332         service_destroy(svc);
1333
1334         /* Send destroy request */
1335         ug_destroy_me(ad->ug);
1336 }
1337
1338 void
1339 setting_time_main_click_softkey_caller_exist_right_cb(void *data,
1340                                                       Evas_Object *obj,
1341                                                       void *event_info)
1342 {
1343         SETTING_TRACE_BEGIN;
1344         /* error check */
1345         retm_if(data == NULL, "Data parameter is NULL");
1346
1347         SettingTimeUG *ad = (SettingTimeUG *) data;
1348
1349         /*  Create Bundle and send message */
1350         service_h svc;
1351         if (service_create(&svc))
1352                 return;
1353
1354         service_add_extra_data(svc, "result", "rbutton_click");
1355         ug_send_result(ad->ug, svc);
1356
1357         service_destroy(svc);
1358
1359         /* Send destroy request */
1360         ug_destroy_me(ad->ug);
1361 }
1362
1363 #if UN_SUPPORT_TIME_DYNAMIC_UPDATE
1364 static void setting_time_reboot_resp_cb(void *data, Evas_Object *obj,
1365                                         void *event_info)
1366 {
1367         SETTING_TRACE_BEGIN;
1368         int response_type = btn_type(obj);
1369         if (POPUP_RESPONSE_OK == response_type) {
1370                 setting_time_main_btn_update_ok_cb(data);
1371         } else if (POPUP_RESPONSE_CANCEL == response_type) {
1372                 setting_time_main_btn_update_cancel_cb(data);
1373         }
1374
1375         SettingTimeUG *ad = data;
1376         if (ad->pop)
1377         {
1378                 evas_object_del(ad->pop);
1379                 ad->pop = NULL;
1380         }
1381 }
1382 #endif
1383
1384 static void __time_auto_update(void *data)
1385 {
1386         setting_retm_if(data == NULL, "Data parameter is NULL");
1387         SettingTimeUG *ad = (SettingTimeUG *) data;
1388         int err;
1389         setting_set_bool_slp_key(BOOL_SLP_SETTING_AUTOMATIC_TIME_UPDATE,
1390              SETTING_ON_OFF_BTN_ON, &err);
1391         if (ad->data_tz) {
1392                 setting_disable_genlist_item(ad->data_tz->item);
1393         }
1394
1395         if (ad->data_time) {
1396                 ad->data_time->isItemDisableFlag = FALSE;
1397                 setting_disable_evas_object(ad->data_time->eo_check);
1398                 setting_disable_genlist_item(ad->data_time->item);
1399         }
1400         __update_time_via_sim_card(ad);
1401 }
1402
1403 static void
1404 setting_time_main_chk_btn_cb(void *data, Evas_Object *obj, void *event_info)
1405 {
1406         SETTING_TRACE_BEGIN;
1407         /* error check */
1408         retm_if(data == NULL, "Data parameter is NULL");
1409         SettingTimeUG *ad = NULL;
1410         Setting_GenGroupItem_Data *list_item =
1411             (Setting_GenGroupItem_Data *) data;
1412         ad = list_item->userdata;
1413         list_item->chk_status = elm_check_state_get(obj);       /*  for genlist update status */
1414         if (ad->data_auto)
1415                 ad->chk_auto = ad->data_auto->eo_check;
1416         if (ad->data_dst)
1417                 ad->chk_dst = ad->data_dst->eo_check;
1418
1419         if (ad->data_time) {
1420                 elm_object_focus_set(ad->data_time->eo_check, EINA_FALSE);
1421         }
1422
1423         int err;
1424         if (obj == ad->chk_auto) {
1425                 int bvalue;
1426                 setting_get_bool_slp_key(BOOL_SLP_SETTING_AUTOMATIC_TIME_UPDATE,
1427                                          &bvalue, &err);
1428                 if (bvalue) {
1429                         (void) setting_set_bool_slp_key (BOOL_SLP_SETTING_AUTOMATIC_TIME_UPDATE, SETTING_ON_OFF_BTN_OFF, &err);
1430                         elm_check_state_set(ad->chk_auto, 0);
1431
1432                         if (ad->data_tz) {
1433                                 setting_enable_genlist_item(ad->data_tz->item);
1434                         }
1435
1436                         if (ad->data_time) {
1437                                 ad->data_time->isItemDisableFlag = FALSE;
1438                                 setting_enable_evas_object(ad->data_time->eo_check);
1439                                 setting_enable_genlist_item(ad->data_time->item);
1440                         }
1441
1442                 } else {
1443 #if UN_SUPPORT_TIME_DYNAMIC_UPDATE
1444                         ad->pop =
1445                             setting_create_popup_with_btn(ad, ad->win_get, NULL,
1446                                                  _("IDS_ST_POP_RESTART_PHONE_TO_USE_AUTOMATIC_UPDATE_Q"),
1447                                                  setting_time_reboot_resp_cb,
1448                                                  0, 2,
1449                                                  dgettext("sys_string",
1450                                                        "IDS_COM_SK_OK"),
1451                                                  _("IDS_COM_SK_CANCEL"));
1452 #else
1453                         __time_auto_update(ad);
1454 #endif
1455                 }
1456         }
1457 }
1458 static void setting_time_main_mouse_up_Gendial_list_cb(void *data, Evas_Object *obj,
1459                                            void *event_info)
1460 {
1461         SETTING_TRACE_BEGIN;
1462         /* error check */
1463         setting_retm_if(data == NULL, "Data parameter is NULL");
1464
1465         retm_if(event_info == NULL, "Invalid argument: event info is NULL");
1466         Elm_Object_Item *item = (Elm_Object_Item *) event_info;
1467         elm_genlist_item_selected_set(item, 0);
1468         Setting_GenGroupItem_Data *list_item =
1469             (Setting_GenGroupItem_Data *) elm_object_item_data_get(item);
1470
1471         SettingTimeUG *ad = (SettingTimeUG *) data;
1472         SETTING_TRACE("clicking item[%s]", _(list_item->keyStr));
1473
1474         if (ad->data_time && ad->data_time != list_item) {
1475                 elm_object_focus_set(ad->data_time->eo_check, EINA_FALSE);
1476         }
1477
1478         if (ad->data_tz == list_item) {
1479                 ad->is_datefield_selected = EINA_FALSE;
1480                 if (1 == setting_time_check_automatic_time_update_state()) {
1481                         setting_create_simple_popup(ad, ad->win_get,
1482                                                     NULL, _(AUTO_TIME_UPDATE_ON));
1483                 } else {
1484                         setting_time_main_launch_worldclock_sg(ad);
1485                 }
1486
1487         } else if (ad->data_time == list_item) {
1488                 ad->is_datefield_selected = EINA_TRUE;
1489                 if (1 == setting_time_check_automatic_time_update_state()) {
1490                         setting_create_simple_popup(ad, ad->win_get,
1491                                                     NULL, _(AUTO_TIME_UPDATE_ON));
1492                 } else {
1493                         /* setting_view_change(&setting_view_time_main, &setting_view_time_time, ad); */
1494                 }
1495         } else if (ad->data_auto == list_item) {
1496                 ad->is_datefield_selected = EINA_FALSE;
1497                 int old_status = elm_check_state_get(list_item->eo_check);
1498                 /* new status */
1499                 list_item->chk_status = !old_status;
1500                 elm_check_state_set(list_item->eo_check, list_item->chk_status);
1501                 int err = 0;
1502                 if (!list_item->chk_status) {
1503                         (void)
1504                             setting_set_bool_slp_key
1505                             (BOOL_SLP_SETTING_AUTOMATIC_TIME_UPDATE,
1506                              SETTING_ON_OFF_BTN_OFF, &err);
1507
1508                         if (ad->data_tz) {
1509                                 setting_enable_genlist_item(ad->data_tz->item);
1510                         }
1511
1512                         if (ad->data_time) {
1513                                 ad->data_time->isItemDisableFlag = FALSE;
1514                                 setting_enable_evas_object(ad->data_time->eo_check);
1515                                 setting_enable_genlist_item(ad->data_time->item);
1516                         }
1517
1518                 } else {
1519                         #if UN_SUPPORT_TIME_DYNAMIC_UPDATE
1520                         ad->pop =
1521                             setting_create_popup_with_btn(ad, ad->win_get, NULL,
1522                                                  _("IDS_ST_POP_RESTART_PHONE_TO_USE_AUTOMATIC_UPDATE_Q"),
1523                                                  setting_time_reboot_resp_cb,
1524                                                  0, 2,
1525                                                  dgettext("sys_string", "IDS_COM_SK_OK"),
1526                                                  _("IDS_COM_SK_CANCEL"));
1527                         #else
1528                         __time_auto_update(ad);
1529                         #endif
1530                 }
1531
1532         }
1533         else if (ad->data_time_fmt == list_item
1534                    || ad->data_date_fmt == list_item
1535                    || ad->data_firstday_week_fmt == list_item) {
1536                 ad->is_datefield_selected = EINA_FALSE;
1537                 bool status = !elm_genlist_item_expanded_get(item);
1538                 elm_genlist_item_expanded_set(item, status);
1539         }
1540 }
1541
1542
1543 void setting_time_main_btn_update_ok_cb(void *cb)
1544 {
1545         SETTING_TRACE_BEGIN;
1546         SettingTimeUG *ad = (SettingTimeUG *) cb;
1547         int err;                /* error check */
1548         setting_set_bool_slp_key(BOOL_SLP_SETTING_AUTOMATIC_TIME_UPDATE,
1549                                  SETTING_ON_OFF_BTN_ON, &err);
1550         elm_check_state_set(ad->data_auto->eo_check, 1);
1551         ad->data_auto->chk_status = 1;
1552
1553         sysman_request_reboot();
1554
1555         /*  We'd better check return value from sysman_request_reboot() function. */
1556         /*  It will return 0 on success or -1 if failed. */
1557 }
1558
1559
1560 void setting_time_main_btn_update_cancel_cb(void *cb)
1561 {
1562         SETTING_TRACE_BEGIN;
1563         SettingTimeUG *ad = (SettingTimeUG *) cb;
1564
1565         int err;                /* error check */
1566
1567         retm_if(cb == NULL, "Data parameter is NULL");
1568         setting_set_bool_slp_key(BOOL_SLP_SETTING_AUTOMATIC_TIME_UPDATE,
1569                                  SETTING_ON_OFF_BTN_OFF, &err);
1570         elm_check_state_set(ad->data_auto->eo_check, 0);
1571         ad->data_auto->chk_status = 0;
1572
1573 }
1574
1575
1576 static UChar *uastrcpy(const char *chars)
1577 {
1578         int len = 0;
1579         UChar *str = NULL;
1580         len = safeStrLen(chars);
1581         str = (UChar *) malloc(sizeof(UChar) *(len + 1));
1582         if (!str)
1583                 return NULL;
1584         u_uastrcpy(str, chars);
1585         return str;
1586 }
1587
1588
1589 static int get_timezone_isdst(int* isdst)
1590 {
1591         SETTING_TRACE_BEGIN;
1592     struct tm *ts;
1593     time_t ctime;
1594
1595     enum { BUFFERSIZE = 1024 };
1596     char buf[BUFFERSIZE];
1597     ssize_t len = readlink("/opt/etc/localtime", buf, sizeof(buf)-1);
1598
1599     if (len != -1) {
1600         buf[len] = '\0';
1601     }
1602     else {
1603         /* handle error condition */
1604     }
1605
1606     ctime = time(NULL);
1607     ts = localtime(&ctime);
1608         if ( ! ts ) {
1609                 return SETTING_GENERAL_ERR_NULL_DATA_PARAMETER;
1610         }
1611
1612     SETTING_TRACE(" == tz_path = %s", buf);
1613     SETTING_TRACE(" == isdst = %d\n", ts->tm_isdst);
1614         *isdst = ts->tm_isdst;
1615
1616         return SETTING_RETURN_SUCCESS;
1617 }
1618
1619
1620 static void ICU_set_timezone(const char *timezone)
1621 {
1622         SETTING_TRACE("ICU_set_timezone = %s ", timezone);
1623         UErrorCode ec = U_ZERO_ERROR;
1624         UChar *str = uastrcpy(timezone);
1625
1626         ucal_setDefaultTimeZone(str, &ec);
1627         if (U_SUCCESS(ec)) {
1628                 SETTING_TRACE("ucal_setDefaultTimeZone() SUCCESS ");
1629         } else {
1630                 SETTING_TRACE("ucal_setDefaultTimeZone() FAILED : %s ",
1631                               u_errorName(ec));
1632         }
1633         FREE(str);
1634 }
1635
1636 #if DISABLED_CODE
1637 static void setting_time_main_controlbar_lbtn_label_set(
1638                                                         Evas_Object *controlbar,
1639                                                         char *label)
1640 {
1641         SETTING_TRACE_BEGIN;
1642         setting_retm_if(controlbar == NULL, "controlbar parameter is NULL");
1643         setting_retm_if(label == NULL, "label parameter is NULL");
1644
1645         Evas_Object *eo_lbtn = NULL;
1646         Elm_Object_Item *first_item = NULL;
1647
1648         first_item = elm_toolbar_first_item_get(controlbar);
1649         setting_retm_if(first_item == NULL, "get first_item failed");
1650
1651         eo_lbtn = elm_object_item_part_content_get(first_item, "object");
1652         setting_retm_if(eo_lbtn == NULL, "get eo_lbtn failed");
1653
1654         elm_object_text_set(eo_lbtn, label);
1655 }
1656 #endif
1657
1658 /**
1659  * ex) timezone : Asia/Seoul --> returns "+09"
1660  *
1661  * char outstr2[4];
1662  */
1663 static void get_gmt_offset(char *str_buf, int size)
1664 {
1665         // timezone string +/-<n> ex. +9, -1
1666         time_t t = time(0);     // get unix time. sec.
1667
1668         struct tm* data;
1669         data = localtime(&t);           // save time as structure.
1670         setting_retm_if(!data, "data is NULL");
1671         data->tm_isdst = 0;                     // summer time, not applied.
1672         time_t a = mktime(data);
1673
1674         data = gmtime(&a);
1675         data->tm_isdst = 0;                     // summer time, not applied.
1676         time_t b = mktime(data);
1677
1678         int gmtoffset_hour = (a-b)/3600;        // result : hour.
1679         int gmtoffset_min = ((a-b)%3600)/60;    // result : min.
1680         if(gmtoffset_min != 0) {
1681                 gmtoffset_min = 30;
1682         }
1683
1684         snprintf(str_buf, size, "%+d:%02u", gmtoffset_hour, gmtoffset_min);
1685         SETTING_TRACE("szTimezone is of a valid format: GMT: %s", str_buf);
1686 }
1687
1688
1689 // automatic
1690 static char* get_timezone_str()
1691 {
1692     SETTING_TRACE_BEGIN;
1693
1694     enum { BUFFERSIZE = 1024 };
1695     char buf[BUFFERSIZE];
1696     ssize_t len = readlink("/opt/etc/localtime", buf, sizeof(buf)-1);
1697
1698     if (len != -1) {
1699         buf[len] = '\0';
1700     }
1701     else {
1702         /* handle error condition */
1703     }
1704     return g_strdup(buf+20);            //Asia/Seoul
1705 }
1706
1707 static char* get_city_name_result()
1708 {
1709         return s_result;
1710 }
1711
1712
1713 // in_str = "Asia/Seoul"
1714 static bool get_city_name(char* tzname)
1715 {
1716         sqlite3 *pSQLite3 = NULL;
1717         char    *szErrMsg = NULL;
1718
1719         int rst = sqlite3_open( "/opt/dbspace/.worldclock.db", &pSQLite3);
1720         if ( rst )
1721         {
1722                 printf( "Can't open database: %s\n", sqlite3_errmsg( pSQLite3 ));
1723                 sqlite3_close( pSQLite3 );
1724                 pSQLite3 = NULL;
1725                 return false;
1726         }
1727         else
1728         {
1729                 printf("Database opened!!\n");
1730                 char query_str[256];
1731                 snprintf(query_str, 256, "SELECT city FROM city_table where tz_path=\"%s\"", tzname);
1732                 printf("%s \n", query_str);
1733                 rst = sqlite3_exec(pSQLite3, query_str, query_callback, 0, &szErrMsg);
1734         }
1735
1736         //객체해제
1737         sqlite3_free( szErrMsg );
1738         sqlite3_close( pSQLite3 );
1739         printf("Database close!!\n");
1740         return true;
1741 }
1742
1743 static int query_callback(void *NotUsed, int argc, char **argv, char **azColName)
1744 {
1745     int i = 0;
1746     printf("%s\n", argv[i] ? argv[i] : "NULL");
1747         s_result = g_strdup(argv[i] ? argv[i] : "NULL");
1748     return 0;
1749 };
1750
1751
1752 #if 0                   /* example */
1753 int main(int argc, char* argv[])
1754 {
1755         g_type_init ();
1756         int ret;
1757         // exporting - current status
1758         if ( (argc == 2) && (0 == strcmp(argv[1], "export"))) {
1759                         setting_export();
1760         }
1761         else if ( (argc == 2) && (0 == strcmp(argv[1], "timezone_init"))) {
1762
1763                 //////////////////////////////////////////////////////////////////////////
1764                 char* tz_path_zone_city = get_timezone_str();
1765                 bool ret = get_city_name(tz_path_zone_city);
1766                 if (ret) {
1767                         printf(">>>>>> RESULT : %s \n", get_city_name_result());
1768                 }
1769                 //////////////////////////////////////////////////////////////////////////
1770         }
1771         else {
1772                 // cfg create
1773                 // TRUE or FALSE
1774                 ret = setting_cfg_create();
1775         }
1776         return 0;
1777 }
1778 #endif
1779
1780
1781