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