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, Evas_Object *win_obj, char *title_str, char *lbutton_str, char *rbutton_str, char *mbutton_str, setting_call_back_func lbutton_click_cb, setting_call_back_func rbutton_click_cb, setting_call_back_func mbutton_click_cb, void *cb_data, Evas_Object *eo_view,   /*any container obj constructed on any evas obj */
 603                                             Evas_Object **navi_bar,
 604                                             Evas_Object **titleobj)
 605 {
 606
 607         Evas_Object *layout = setting_create_win_layout2(win_layout, win_obj);
 608         *navi_bar = setting_create_navi_bar(layout);
 609
 610         setting_create_navi_bar_buttons(title_str,
 611                                         lbutton_str, rbutton_str, mbutton_str,
 612                                         lbutton_click_cb, rbutton_click_cb,
 613                                         mbutton_click_cb, cb_data, eo_view /*content */ ,
 614                                         *navi_bar, NULL);
 615         return layout;
 616 }
 617
 618 static int setting_time_main_create(void *cb)
 619 {
 620         SETTING_TRACE_BEGIN;
 621         retv_if(cb == NULL, SETTING_GENERAL_ERR_NULL_DATA_PARAMETER);
 622
 623         SettingTimeUG *ad = (SettingTimeUG *) cb;
 624
 625         char *l_btn = NULL;
 626         char *r_btn = NULL;
 627         char *title = _("IDS_ST_BODY_DATE_AND_TIME");
 628         char *caller = NULL;
 629         ad->is_datefield_selected = EINA_FALSE;
 630
 631         setting_call_back_func l_button_cb = NULL;
 632         setting_call_back_func r_button_cb = NULL;
 633
 634         service_h service = ad->bundle_data;
 635
 636         service_get_extra_data(service, "caller", &caller);
 637         service_get_extra_data(service, "lbutton", &l_btn);
 638         if(l_btn)
 639                 l_button_cb = setting_time_main_click_softkey_caller_exist_left_cb;
 640         service_get_extra_data(service, "title", &title);
 641         service_get_extra_data(service, "rbutton", &r_btn);
 642         if(r_btn)
 643                 r_button_cb = setting_time_main_click_softkey_caller_exist_right_cb;
 644
 645         Evas_Object *scroller;  /*  scroller is a genlist */
 646
 647         ad->caller = caller;
 648         if (ad->caller) {
 649                 /* for setup wizard */
 650                 char *lbtn_str = (char *)g_strdup(l_btn);
 651                 bool same_flag = FALSE;
 652                 if (0 == safeStrCmp(l_btn, _("IDS_COM_BODY_BACK"))) {
 653                         l_btn = (char *)dgettext("sys_string", "IDS_COM_BODY_BACK");
 654                         same_flag = TRUE;
 655                 }
 656
 657                 //Evas_Object *controllbar = NULL;
 658
 659                 scroller = elm_genlist_add(ad->win_main_layout);
 660                 elm_object_style_set(scroller, "dialogue");
 661                 if(scroller == NULL) {
 662                         SETTING_TRACE_ERROR("Cannot set scroller object  as contento of layout");
 663                         // free allocated data before return.
 664                         FREE(lbtn_str);
 665                         return SETTING_DRAW_ERR_FAIL_SCROLLER;
 666                 }
 667
 668                 elm_genlist_clear(scroller);
 669                 ad->ly_main =
 670                             setting_create_layout_navi_bar2(ad->win_main_layout,
 671                                                            ad->win_get,
 672                                                            title,
 673                                                            NULL, NULL, NULL,
 674                                                            NULL, NULL, NULL,
 675                                                            ad, scroller,
 676                                                            &ad->navi_bar,
 677                                                            NULL);
 678                 /* left button */
 679                 Evas_Object *lbtn_obj = elm_button_add(ad->win_main_layout);
 680                 if(lbtn_obj == NULL)
 681                         return SETTING_DRAW_ERR_FAIL_SCROLLER;
 682
 683                 Evas_Object *licon_obj = elm_icon_add(ad->win_main_layout);
 684                 if(licon_obj == NULL)
 685                         return SETTING_DRAW_ERR_FAIL_SCROLLER;
 686                 elm_icon_file_set(licon_obj, IMG_PREVIOUS, NULL);
 687
 688                 elm_object_style_set(lbtn_obj, "naviframe/toolbar/default");
 689                 elm_object_text_set(lbtn_obj, l_btn);
 690                 elm_object_part_content_set(lbtn_obj, "elm.swallow.content", licon_obj);
 691                 evas_object_smart_callback_add(lbtn_obj, "clicked", l_button_cb, ad);
 692
 693                 /* right button */
 694                 Evas_Object *rbtn_obj = elm_button_add(ad->win_main_layout);
 695                 if(rbtn_obj == NULL)
 696                         return SETTING_DRAW_ERR_FAIL_SCROLLER;
 697
 698                 Evas_Object *ricon_obj = elm_icon_add(ad->win_main_layout);
 699                 if(ricon_obj == NULL)
 700                         return SETTING_DRAW_ERR_FAIL_SCROLLER;
 701                 elm_icon_file_set(ricon_obj, IMG_NEXT, NULL);
 702
 703                 elm_object_style_set(rbtn_obj, "naviframe/toolbar/default");
 704                 elm_object_text_set(rbtn_obj, r_btn);
 705                 elm_object_part_content_set(rbtn_obj, "elm.swallow.content", ricon_obj);
 706                 evas_object_smart_callback_add(rbtn_obj, "clicked", r_button_cb, ad);
 707
 708                 Elm_Object_Item *navi_it = elm_naviframe_top_item_get(ad->navi_bar);
 709                 if(navi_it)
 710                 {
 711                         elm_object_item_part_content_set(navi_it, "toolbar_button1", lbtn_obj);
 712                         elm_object_item_part_content_set(navi_it, "toolbar_button2", rbtn_obj);
 713                 }
 714         } else {
 715                 l_btn = _("IDS_COM_BODY_BACK");
 716                 title = _("IDS_ST_BODY_DATE_AND_TIME");
 717                 ad->ly_main =
 718                     setting_create_layout_navi_bar_genlist(ad->win_main_layout,
 719                                                            ad->win_get, title,
 720                                                            l_btn, NULL,
 721                                                            setting_time_main_click_softkey_left_cb,
 722                                                            NULL, ad, &scroller,
 723                                                            &ad->navi_bar);
 724         }
 725         ad->scrl_main = scroller;
 726
 727         int value;
 728         int err;
 729         int ret = 0;
 730         Elm_Object_Item *item;
 731
 732         item = elm_genlist_item_append(scroller, &(ad->itc_seperator), NULL, NULL,
 733                                     ELM_GENLIST_ITEM_NONE, NULL, NULL);
 734         elm_genlist_item_select_mode_set(item, ELM_OBJECT_SELECT_MODE_DISPLAY_ONLY);
 735         setting_get_bool_slp_key(BOOL_SLP_SETTING_AUTOMATIC_TIME_UPDATE, &value,
 736                                  &err);
 737         bool auto_flag = value;
 738
 739         if(auto_flag) //do special process only when auto mode
 740         {
 741                 //to read TAPI vconfs
 742                 int ret = 0;
 743                 int t_nitz = 0;
 744                 int t_offset = 0;
 745                 ret += vconf_get_int(VCONFKEY_TELEPHONY_NITZ_GMT, &t_nitz);
 746                 ret += vconf_get_int(VCONFKEY_TELEPHONY_NITZ_EVENT_GMT, &t_offset);
 747                 char *tzpath = vconf_get_str(VCONFKEY_TELEPHONY_NITZ_ZONE);
 748                 if (ret == 0 && !isEmptyStr(tzpath))
 749                 {
 750                         //1.to update timezone
 751                         char tz_path[MAX_COMMON_BUFFER_LEN / 4 + 1];
 752                         safeCopyStr(tz_path, SETTING_TIME_ZONEINFO_PATH, MAX_COMMON_BUFFER_LEN / 4);
 753                         g_strlcat(tz_path, tzpath, sizeof(tz_path));
 754                         SETTING_TRACE("full tz_path:%s", tz_path);
 755                         ret = sysman_set_timezone(tz_path);
 756                         if (ret < 0) {
 757                                 SETTING_TRACE("tzpath is not valid.");
 758                         } else
 759                                 SETTING_TRACE("sysman_set_timezone - successful : %s \n", tz_path);
 760                         if (!__setting_set_city_tzone(tzpath)) {
 761                                 SETTING_TRACE("__setting_set_city_tzone ERROR")
 762                         }
 763                         if (get_city_name(tzpath)) {
 764                                 SETTING_TRACE(">>>>>> RESULT : %s", get_city_name_result());
 765                         }
 766                         char* city = get_city_name_result();
 767                         SETTING_TRACE("city:%s", city);
 768                         ret = vconf_set_str(VCONFKEY_SETAPPL_CITYNAME_INDEX_INT, city);
 769
 770                         // 2.to set current time
 771                         int t_uptime = 0;
 772                         FILE *fp = fopen("/proc/uptime", "r");
 773                         if (fp) {
 774                                 if (!fscanf(fp, "%d", &t_uptime)) {
 775                                         SETTING_TRACE_ERROR("fscanf error");
 776                                 }
 777                                 fclose(fp);
 778                                 fp = NULL;
 779                         } else {
 780                                 SETTING_TRACE_ERROR("fopen error");
 781                         }
 782
 783                         SETTING_TRACE("t_nitz:%d, t_offset:%d, t_uptime:%d", t_nitz, t_offset, t_uptime);
 784                         time_t t_current = t_nitz + t_uptime - t_offset;
 785                         SETTING_TRACE("t_current:%d", t_current);
 786                         ret = sysman_set_datetime(t_current);
 787                 }
 788         }
 789
 790         /*  UI automatic */
 791         if (!isEmulBin()) {
 792                 ad->data_auto =
 793                     setting_create_Gendial_field_def(scroller, &(ad->itc_1text_1icon),
 794                                                      setting_time_main_mouse_up_Gendial_list_cb,
 795                                                      ad, SWALLOW_Type_1TOGGLE, NULL,
 796                                                      NULL, value,
 797                                                      "IDS_ST_BODY_AUTOMATIC_UPDATE", NULL,
 798                                                      setting_time_main_chk_btn_cb);
 799                 if (ad->data_auto) {
 800                         ad->data_auto->userdata = ad;
 801                 } else {
 802                         SETTING_TRACE_ERROR("ad->data_auto is NULL");
 803                 }
 804
 805                 setting_create_Gendial_field_def(scroller, &itc_multiline_text, NULL,
 806                                                  ad, SWALLOW_Type_LAYOUT_SPECIALIZTION_X,
 807                                                  NULL, NULL, 0, SETTING_TIME_AUTO_UPDATE_DESC, NULL,
 808                                                  NULL);
 809                 elm_genlist_item_select_mode_set(elm_genlist_item_append(scroller, &(itc_seperator), NULL, NULL,ELM_GENLIST_ITEM_NONE, NULL, NULL),
 810                                                  ELM_OBJECT_SELECT_MODE_DISPLAY_ONLY);
 811         }
 812
 813         setting_set_i18n("worldclock", SETTING_TIME_SHARE_LOCAL_PATH);
 814
 815         char time_zone_sub_str[CITY_BUF_SIZE + GMT_BUF_SIZE + 3] = { 0, };
 816         char *pa_timezone = NULL;
 817         char *pa_city = NULL;
 818
 819         pa_city = vconf_get_str(VCONFKEY_SETAPPL_CITYNAME_INDEX_INT);   // IDS_WCL_BODY_CITYNAME_SEOUL
 820         pa_timezone = vconf_get_str(VCONFKEY_SETAPPL_TIMEZONE_INT);             // "Asia/Seoul"
 821
 822         if ((pa_timezone != NULL) && (_(pa_city) != NULL)) {
 823
 824                 // don't use hard coded value
 825                 // get value from current timezone
 826
 827                 char str_buf[GMT_BUF_SIZE] = {0, };
 828                 get_gmt_offset(str_buf, GMT_BUF_SIZE);
 829
 830                 char* timezone_str = get_timezone_str();
 831
 832                 bool ret = get_city_name(timezone_str);
 833                 if (ret) {
 834                         SETTING_TRACE(">>>>>> RESULT : %s", get_city_name_result());
 835                 }
 836                 char* cityname_id = _(get_city_name_result());
 837                 SETTING_TRACE("cityname_id:%s", cityname_id);
 838                 if (cityname_id && 0 != safeStrCmp(cityname_id, "NULL"))
 839                         ret = snprintf(time_zone_sub_str, CITY_BUF_SIZE + GMT_BUF_SIZE + 2, "%s, GMT %s", cityname_id, _(str_buf));
 840                 else
 841                         ret = snprintf(time_zone_sub_str, CITY_BUF_SIZE + GMT_BUF_SIZE + 2, "%s, GMT +09", _("IDS_WCL_BODY_CITYNAME_SEOUL"));
 842
 843                 FREE(pa_city);
 844                 FREE(pa_timezone);
 845                 retv_if(ret < 0, 0);
 846         } else {
 847                 // default code
 848                 ret = snprintf(time_zone_sub_str, CITY_BUF_SIZE + GMT_BUF_SIZE + 2, "%s, GMT +09", _("IDS_WCL_BODY_CITYNAME_SEOUL"));
 849                 retv_if(ret < 0, 0);
 850         }
 851
 852         /*  UI create time zone */
 853         ad->data_tz =
 854             setting_create_Gendial_field_def(scroller, &(ad->itc_2text_2),
 855                                              setting_time_main_mouse_up_Gendial_list_cb,
 856                                              ad, SWALLOW_Type_INVALID, NULL,
 857                                              NULL, 0, "IDS_ST_BODY_TIME_ZONE",
 858                                              time_zone_sub_str, NULL);
 859         if (ad->data_tz) {
 860                 ad->data_tz->userdata = ad;
 861         } else {
 862                 SETTING_TRACE_ERROR("ad->data_tz is NULL");
 863         }
 864
 865         /* create DATE_AND_TIME */
 866         /* DATE_AND_TIME */
 867         ret =
 868             setting_get_int_slp_key(INT_SLP_SETTING_REGIONFORMAT_TIME1224,
 869                                     &value, &err);
 870         if (ret == SETTING_RETURN_FAIL) {
 871                 value = VCONFKEY_TIME_FORMAT_12;
 872         }
 873         bool is_12hours = (value == VCONFKEY_TIME_FORMAT_12 ? TRUE : FALSE);
 874         char *date_format_str[] = { "%d %b %Y", "%b %d %Y", "%Y %b %d", "%Y %d %b" };
 875         ret =
 876             setting_get_int_slp_key(INT_SLP_SETTING_DATE_FORMAT, &value, &err);
 877         if (ret == SETTING_RETURN_FAIL)
 878                 value = SETTING_DATE_FORMAT_DD_MM_YYYY;
 879
 880         /*  UI format string */
 881         (void)setting_create_Gendial_field_titleItem(scroller,
 882                                                      &(itc_group_item),
 883                                                      "IDS_ST_BODY_DATE_AND_TIME", NULL);
 884         ad->data_time =
 885             setting_create_Gendial_field_def(scroller, &(ad->itc_layout),
 886                                              setting_time_main_mouse_up_Gendial_list_cb,
 887                                              ad, SWALLOW_Type_LAYOUT_DATEFIELD,
 888                                              NULL, NULL, is_12hours,
 889                                              NULL,//"IDS_ST_BODY_DATE_AND_TIME",
 890                                              date_format_str[value],
 891                                              setting_time_main_datefield_change_cb);
 892         if (ad->data_time) {
 893                 ad->data_time->userdata = ad;
 894                 ad->data_time->isItemDisableFlag = auto_flag;
 895                 elm_genlist_item_select_mode_set(ad->data_time->item, ELM_OBJECT_SELECT_MODE_DISPLAY_ONLY);
 896         } else {
 897                 SETTING_TRACE_ERROR("ad->data_time is NULL");
 898         }
 899         item = elm_genlist_item_append(scroller, &(ad->itc_seperator), NULL, NULL,
 900                                     ELM_GENLIST_ITEM_NONE, NULL, NULL);
 901         elm_genlist_item_select_mode_set(item, ELM_OBJECT_SELECT_MODE_DISPLAY_ONLY);
 902
 903         /*  UI create "Time format" */
 904         setting_enable_expandable_genlist(scroller, ad,
 905                                           __setting_time_main_exp_cb, NULL);
 906
 907         char* pa_time_format = get_pa_time_format_str();
 908         ad->data_time_fmt = setting_create_Gendial_exp_parent_field(scroller,
 909                                                     &(ad->itc_2text_3_parent),
 910                                                     setting_time_main_mouse_up_Gendial_list_cb,
 911                                                     ad, SWALLOW_Type_INVALID,
 912                                                     "IDS_ST_BODY_TIME_FORMAT",
 913                                                     pa_time_format);
 914         if (ad->data_time_fmt) {
 915                 ad->data_time_fmt->int_slp_setting_binded =
 916                         INT_SLP_SETTING_REGIONFORMAT_TIME1224;
 917         } else {
 918                 SETTING_TRACE_ERROR("ad->data_time_fmt is NULL");
 919         }
 920         G_FREE(pa_time_format);
 921
 922 #if APPLIED_DATATIME_DATA_FORMAT
 923         char* pa_date_format = get_pa_date_format_str();
 924         ad->data_date_fmt = setting_create_Gendial_exp_parent_field(scroller,
 925                                                     &(ad->itc_2text_3_parent),
 926                                                     setting_time_main_mouse_up_Gendial_list_cb,
 927                                                     ad, SWALLOW_Type_INVALID,
 928                                                     "IDS_ST_BODY_DATE_FORMAT",
 929                                                     pa_time_format);
 930         if (ad->data_date_fmt) {
 931                 ad->data_date_fmt->int_slp_setting_binded =
 932                         INT_SLP_SETTING_DATE_FORMAT;
 933         } else {
 934                 SETTING_TRACE_ERROR("ad->data_date_fmt is NULL");
 935         }
 936         G_FREE(pa_date_format);
 937 #endif
 938
 939 #if APPLIED_DATATIME_FIRSTDAY_WEEK
 940     char* pa_week = get_pa_week_format_str();
 941         ad->data_firstday_week_fmt =
 942             setting_create_Gendial_exp_parent_field(scroller,
 943                                                     &(ad->itc_2text_3_parent),
 944                                                     setting_time_main_mouse_up_Gendial_list_cb,
 945                                                     ad, SWALLOW_Type_INVALID,
 946                                                     "IDS_CLD_BODY_FIRST_DAY_OF_WEEK",
 947                                                     pa_week);
 948         if (ad->data_firstday_week_fmt) {
 949                 ad->data_firstday_week_fmt->int_slp_setting_binded =
 950                         INT_SLP_SETTING_WEEK_FORMAT;
 951         } else {
 952                 SETTING_TRACE_ERROR("ad->data_firstday_week_fmt is NULL");
 953         }
 954     G_FREE(pa_week);
 955 #endif
 956
 957         item = elm_genlist_item_append(scroller, &itc_bottom_seperator, NULL, NULL,
 958                                     ELM_GENLIST_ITEM_NONE, NULL, NULL);
 959         elm_genlist_item_select_mode_set(item, ELM_OBJECT_SELECT_MODE_DISPLAY_ONLY);
 960
 961         if (auto_flag)
 962         {
 963                 if (ad->data_tz) {
 964                         setting_disable_genlist_item(ad->data_tz->item);
 965                 }
 966                 if (ad->data_time) {
 967                         setting_disable_genlist_item(ad->data_time->item);
 968                 }
 969         }
 970
 971         setting_view_time_main.is_create = 1;
 972         vconf_notify_key_changed(VCONFKEY_SYSTEM_TIME_CHANGED, time_changed_callback, (void *)ad);
 973
 974         /*  register vconf key to get event callback for converting 12/24H */
 975         vconf_notify_key_changed(VCONFKEY_REGIONFORMAT_TIME1224, setting_time_main_int_vconf_change_cb, ad);
 976         /*  register vconf key to get event callback for date format */
 977         vconf_notify_key_changed(VCONFKEY_SETAPPL_DATE_FORMAT_INT, setting_time_main_int_vconf_change_cb, ad);
 978
 979         vconf_notify_key_changed(VCONFKEY_TELEPHONY_NITZ_GMT, __sim_time_info_chg_cb, ad);
 980         vconf_notify_key_changed(VCONFKEY_TELEPHONY_NITZ_EVENT_GMT, __sim_time_info_chg_cb, ad);
 981         vconf_notify_key_changed(VCONFKEY_TELEPHONY_NITZ_ZONE, __sim_time_info_chg_cb, ad);
 982
 983         /* to avoid update time-diff, every per 3s to update. */
 984         ad->update_timer = ecore_timer_add(3, (Ecore_Task_Cb) __refresh_date_timer, ad);
 985
 986         return SETTING_RETURN_SUCCESS;
 987 }
 988
 989 static int setting_time_main_destroy(void *cb)
 990 {
 991         SETTING_TRACE_BEGIN;
 992         /* error check */
 993         retv_if(cb == NULL, SETTING_GENERAL_ERR_NULL_DATA_PARAMETER);
 994
 995         SettingTimeUG *ad = (SettingTimeUG *) cb;
 996
 997         if (ad->update_timer) {
 998                 ecore_timer_del(ad->update_timer);
 999                 ad->update_timer = NULL;
1000         }
1001
1002 #if PROGRESS_POPUP_SHOW
1003         if (ad->pop_progress) {
1004                 evas_object_del(ad->pop_progress);
1005                 ad->pop_progress = NULL;
1006         }
1007 #endif
1008
1009         if (ad->update_timezone_idler) {
1010                 ecore_idler_del(ad->update_timezone_idler);
1011                 ad->update_timezone_idler = NULL;
1012         }
1013         if (ad->refresh_time_idler) {
1014                 ecore_idler_del(ad->refresh_time_idler);
1015                 ad->refresh_time_idler = NULL;
1016         }
1017
1018         vconf_ignore_key_changed(VCONFKEY_SYSTEM_TIME_CHANGED,
1019                                  time_changed_callback);
1020
1021         vconf_ignore_key_changed(VCONFKEY_REGIONFORMAT_TIME1224,
1022                                  setting_time_main_int_vconf_change_cb);
1023         vconf_ignore_key_changed(VCONFKEY_SETAPPL_DATE_FORMAT_INT,
1024                                  setting_time_main_int_vconf_change_cb);
1025
1026         vconf_ignore_key_changed(VCONFKEY_TELEPHONY_NITZ_GMT, __sim_time_info_chg_cb);
1027         vconf_ignore_key_changed(VCONFKEY_TELEPHONY_NITZ_EVENT_GMT, __sim_time_info_chg_cb);
1028         vconf_ignore_key_changed(VCONFKEY_TELEPHONY_NITZ_ZONE, __sim_time_info_chg_cb);
1029
1030         if (ad->ly_main != NULL) {
1031                 evas_object_del(ad->ly_main);
1032                 setting_view_time_main.is_create = 0;
1033         }
1034
1035         return SETTING_RETURN_SUCCESS;
1036 }
1037
1038 static int setting_time_main_update(void *cb)
1039 {
1040         SETTING_TRACE_BEGIN;
1041         retv_if(cb == NULL, SETTING_GENERAL_ERR_NULL_DATA_PARAMETER);
1042
1043         SettingTimeUG *ad = (SettingTimeUG *) cb;
1044
1045         if (ad->ly_main != NULL) {
1046                 evas_object_show(ad->ly_main);
1047                 // update timezone
1048                 if (ad->update_timezone_idler) {
1049                         ecore_idler_del(ad->update_timezone_idler);
1050                         ad->update_timezone_idler = NULL;
1051                 }
1052                 ad->update_timezone_idler =
1053                     ecore_idler_add((Ecore_Task_Cb) __update_timezone_idler, ad);
1054                 // update time
1055                 if (ad->refresh_time_idler) {
1056                         ecore_idler_del(ad->refresh_time_idler);
1057                         ad->refresh_time_idler = NULL;
1058                 }
1059                 ad->refresh_time_idler = ecore_idler_add(setting_update_datefield, ad);
1060         }
1061         return SETTING_RETURN_SUCCESS;
1062 }
1063
1064 static int setting_time_main_cleanup(void *cb)
1065 {
1066         SETTING_TRACE_BEGIN;
1067         return SETTING_RETURN_SUCCESS;
1068 }
1069
1070
1071 /* ***************************************************
1072  **
1073  **general func
1074  **
1075  ****************************************************/
1076
1077 int setting_time_check_automatic_time_update_state()
1078 {
1079         SETTING_TRACE_BEGIN;
1080         int bvalue = 0;
1081         int ret = 0;
1082         int err = 0;
1083
1084         ret =
1085             setting_get_bool_slp_key(BOOL_SLP_SETTING_AUTOMATIC_TIME_UPDATE,
1086                                      &bvalue, &err);
1087
1088         return bvalue;
1089
1090 }
1091
1092 static int __setting_set_city_tzone(const char* pTZPath)
1093 {
1094         // let's get city & timezone string from pTZPath
1095         // 1. city name
1096         char szTimezone[GMT_BUF_SIZE] = {0,};
1097         char* pStr = strdup(pTZPath);
1098
1099         // 2. timezone string +/-<n> ex. +9, -1
1100         get_gmt_offset(szTimezone, GMT_BUF_SIZE);
1101
1102         int ret = vconf_set_str(VCONFKEY_SETAPPL_TIMEZONE_INT, szTimezone);
1103         if (ret == -1) {
1104                 FREE(pStr);
1105                 SETTING_TRACE("set vconf failed");
1106                 return FALSE;
1107         }
1108
1109         // set timezone_id
1110         /** @todo replace with vconf ID */
1111         ret = vconf_set_str(VCONFKEY_SETAPPL_TIMEZONE_ID, pStr);
1112         FREE(pStr);
1113
1114         return TRUE;
1115 }
1116
1117 static void
1118 setting_time_main_launch_worldclock_result_ug_cb(ui_gadget_h ug,
1119                                                  service_h result, void *priv)
1120 {
1121         SETTING_TRACE_BEGIN;
1122         /* error check */
1123         retm_if(priv == NULL, "Data parameter is NULL");
1124
1125         SettingTimeUG *ad = (SettingTimeUG *) priv;
1126
1127         char *city = NULL;
1128         char *tzpath = NULL;
1129         service_get_extra_data(result, "city", &city);
1130         service_get_extra_data(result, "tzpath", &tzpath);
1131
1132         if (!tzpath) {
1133                 SETTING_TRACE("tzpath from worldclock UG is null.");
1134                 return;
1135         } else {
1136                 SETTING_TRACE("tzpath : %s", tzpath );
1137         }
1138         SETTING_TRACE("city : %s", city );
1139
1140         /* --------------------------------------------------------------------- */
1141         char tz_path[MAX_COMMON_BUFFER_LEN / 4 + 1];
1142         safeCopyStr(tz_path, SETTING_TIME_ZONEINFO_PATH, MAX_COMMON_BUFFER_LEN / 4);
1143         g_strlcat(tz_path, tzpath, sizeof(tz_path));
1144         SETTING_TRACE("full tz_path:%s", tz_path);
1145
1146         int ret = sysman_set_timezone(tz_path);
1147         if (ret < 0) {
1148                 SETTING_TRACE("tzpath is not valid.");
1149                 return;
1150         } else
1151                 SETTING_TRACE("sysman_set_timezone - successful : %s \n", tz_path);
1152
1153         ret = vconf_set_str(VCONFKEY_SETAPPL_CITYNAME_INDEX_INT, city);
1154         setting_retm_if(ret != 0, "set vconf failed");
1155
1156         // parse city and GMT offset from tzpath and system time property
1157         // set the strings in vconf which will be used while updating display of timezone
1158         if (!__setting_set_city_tzone(tzpath)) {
1159                 SETTING_TRACE("__setting_set_city_tzone ERROR")
1160                 return;
1161         }
1162
1163         // update the display for timezone
1164         setting_update_timezone(ad);
1165         static int t_event_val = -1;
1166         vconf_set_int (VCONFKEY_SYSTEM_TIME_CHANGED, t_event_val);
1167         SETTING_TRACE_END;
1168 }
1169
1170 void setting_time_main_launch_worldclock_destroy_ug_cb(ui_gadget_h ug,
1171                                                        void *priv)
1172 {
1173         SETTING_TRACE_BEGIN;
1174         /* if(ug) ug_destroy(ug); */
1175         /* restore the '<-' button on the navigate bar */
1176         ret_if(!priv);
1177         SettingTimeUG *ad = (SettingTimeUG *) priv;
1178         if (ug) {
1179                 ug_destroy(ug);
1180                 ad->ug_loading = NULL;
1181         }
1182         Elm_Object_Item *navi_it = elm_naviframe_top_item_get(ad->navi_bar);
1183         ret_if(!navi_it);
1184         Evas_Object *back_btn = elm_object_item_part_content_get(navi_it, "prev_btn");
1185
1186         if (back_btn != NULL) {
1187                 elm_object_style_set(back_btn, NAVI_BACK_BUTTON_STYLE); /* take into effect */
1188         }
1189
1190 }
1191
1192 void setting_time_main_launch_worldclock_layout_ug_cb(ui_gadget_h ug,
1193                                                       enum ug_mode mode,
1194                                                       void *priv)
1195 {
1196         SETTING_TRACE_BEGIN;
1197         SettingTimeUG *ad = (SettingTimeUG *) priv;
1198         Evas_Object *base;
1199
1200         if (!priv)
1201                 return;
1202
1203         base = (Evas_Object *) ug_get_layout(ug);
1204         if (!base)
1205                 return;
1206
1207         switch (mode) {
1208         case UG_MODE_FULLVIEW:
1209                 evas_object_size_hint_weight_set(base, EVAS_HINT_EXPAND,
1210                                                  EVAS_HINT_EXPAND);
1211                 elm_win_resize_object_add(ad->win_get, base);
1212                 evas_object_show(base);
1213                 break;
1214         default:
1215                 break;
1216         }
1217         SETTING_TRACE_END;
1218 }
1219
1220
1221 void setting_time_main_launch_worldclock_sg(void *data)
1222 {
1223         SETTING_TRACE_BEGIN;
1224         /* error check */
1225         retm_if(data == NULL, "Data parameter is NULL");
1226
1227         SettingTimeUG *ad = (SettingTimeUG *) data;
1228
1229         struct ug_cbs *cbs = (struct ug_cbs *)calloc(1, sizeof(struct ug_cbs));
1230         setting_retm_if(!cbs, "calloc failed");
1231         cbs->layout_cb = setting_time_main_launch_worldclock_layout_ug_cb;
1232         cbs->result_cb = setting_time_main_launch_worldclock_result_ug_cb;
1233         cbs->destroy_cb = setting_time_main_launch_worldclock_destroy_ug_cb;
1234         cbs->priv = (void *)ad;
1235
1236         SETTING_TRACE("to load ug[%s]", "worldclock-efl");
1237         ad->ug_loading =
1238             ug_create(ad->ug, "worldclock-efl", UG_MODE_FULLVIEW, NULL, cbs);
1239         if (NULL == ad->ug_loading) {   /* error handling */
1240         }
1241
1242         FREE(cbs);
1243         return;
1244 }
1245
1246
1247 Eina_Bool setting_update_datefield(void *cb)
1248 {
1249         SETTING_TRACE_BEGIN;
1250         retvm_if(cb == NULL, EINA_FALSE, "Data parameter is NULL");
1251         SettingTimeUG *ad = (SettingTimeUG *) cb;
1252
1253         //__refresh_date_timer(ad);
1254         if (ad->data_time) {
1255                 time_t ctime = time(NULL);
1256                 struct tm ts_ret;
1257                 struct tm *ts = localtime_r(&ctime, &ts_ret);
1258                 if (ts) elm_datetime_value_set(ad->data_time->eo_check, &ts_ret);
1259         }
1260         ad->refresh_time_idler = NULL;
1261         return 0;
1262 }
1263
1264 /* ***************************************************
1265  **
1266  **call back func
1267  **
1268  ****************************************************/
1269
1270 void
1271 setting_time_main_click_softkey_left_cb(void *data, Evas_Object *obj,
1272                                         void *event_info)
1273 {
1274         SETTING_TRACE_BEGIN;
1275         retm_if(data == NULL, "Data parameter is NULL");
1276
1277         SettingTimeUG *ad = (SettingTimeUG *) data;
1278
1279         /* Send destroy request */
1280         ug_destroy_me(ad->ug);
1281 }
1282
1283 /* ***************************************************
1284  **
1285  **call back func
1286  **
1287  ****************************************************/
1288
1289 void
1290 setting_time_main_click_softkey_caller_exist_left_cb(void *data,
1291                                                      Evas_Object *obj,
1292                                                      void *event_info)
1293 {
1294         SETTING_TRACE_BEGIN;
1295         /* error check */
1296         retm_if(data == NULL, "Data parameter is NULL");
1297
1298         SettingTimeUG *ad = (SettingTimeUG *) data;
1299
1300         /*  Create Bundle and send message */
1301         service_h svc;
1302         if (service_create(&svc))
1303                 return;
1304
1305         service_add_extra_data(svc, "result", "lbutton_click");
1306         ug_send_result(ad->ug, svc);
1307
1308         service_destroy(svc);
1309
1310         /* Send destroy request */
1311         ug_destroy_me(ad->ug);
1312 }
1313
1314 void
1315 setting_time_main_click_softkey_caller_exist_right_cb(void *data,
1316                                                       Evas_Object *obj,
1317                                                       void *event_info)
1318 {
1319         SETTING_TRACE_BEGIN;
1320         /* error check */
1321         retm_if(data == NULL, "Data parameter is NULL");
1322
1323         SettingTimeUG *ad = (SettingTimeUG *) data;
1324
1325         /*  Create Bundle and send message */
1326         service_h svc;
1327         if (service_create(&svc))
1328                 return;
1329
1330         service_add_extra_data(svc, "result", "rbutton_click");
1331         ug_send_result(ad->ug, svc);
1332
1333         service_destroy(svc);
1334
1335         /* Send destroy request */
1336         ug_destroy_me(ad->ug);
1337 }
1338
1339 #if UN_SUPPORT_TIME_DYNAMIC_UPDATE
1340 static void setting_time_reboot_resp_cb(void *data, Evas_Object *obj,
1341                                         void *event_info)
1342 {
1343         SETTING_TRACE_BEGIN;
1344         int response_type = btn_type(obj);
1345         if (POPUP_RESPONSE_OK == response_type) {
1346                 setting_time_main_btn_update_ok_cb(data);
1347         } else if (POPUP_RESPONSE_CANCEL == response_type) {
1348                 setting_time_main_btn_update_cancel_cb(data);
1349         }
1350
1351         SettingTimeUG *ad = data;
1352         if (ad->pop)
1353         {
1354                 evas_object_del(ad->pop);
1355                 ad->pop = NULL;
1356         }
1357 }
1358 #endif
1359
1360 static void __time_auto_update(void *data)
1361 {
1362         setting_retm_if(data == NULL, "Data parameter is NULL");
1363         SettingTimeUG *ad = (SettingTimeUG *) data;
1364         int err;
1365         setting_set_bool_slp_key(BOOL_SLP_SETTING_AUTOMATIC_TIME_UPDATE,
1366              SETTING_ON_OFF_BTN_ON, &err);
1367         if (ad->data_tz) {
1368                 setting_disable_genlist_item(ad->data_tz->item);
1369         }
1370
1371         if (ad->data_time) {
1372                 ad->data_time->isItemDisableFlag = FALSE;
1373                 setting_disable_evas_object(ad->data_time->eo_check);
1374                 setting_disable_genlist_item(ad->data_time->item);
1375         }
1376         __update_time_via_sim_card(ad);
1377 }
1378
1379 static void
1380 setting_time_main_chk_btn_cb(void *data, Evas_Object *obj, void *event_info)
1381 {
1382         SETTING_TRACE_BEGIN;
1383         /* error check */
1384         retm_if(data == NULL, "Data parameter is NULL");
1385         SettingTimeUG *ad = NULL;
1386         Setting_GenGroupItem_Data *list_item =
1387             (Setting_GenGroupItem_Data *) data;
1388         ad = list_item->userdata;
1389         list_item->chk_status = elm_check_state_get(obj);       /*  for genlist update status */
1390         if (ad->data_auto)
1391                 ad->chk_auto = ad->data_auto->eo_check;
1392         if (ad->data_dst)
1393                 ad->chk_dst = ad->data_dst->eo_check;
1394
1395         if (ad->data_time) {
1396                 elm_object_focus_set(ad->data_time->eo_check, EINA_FALSE);
1397         }
1398
1399         int err;
1400         if (obj == ad->chk_auto) {
1401                 int bvalue;
1402                 setting_get_bool_slp_key(BOOL_SLP_SETTING_AUTOMATIC_TIME_UPDATE,
1403                                          &bvalue, &err);
1404                 if (bvalue) {
1405                         (void) setting_set_bool_slp_key (BOOL_SLP_SETTING_AUTOMATIC_TIME_UPDATE, SETTING_ON_OFF_BTN_OFF, &err);
1406                         elm_check_state_set(ad->chk_auto, 0);
1407
1408                         if (ad->data_tz) {
1409                                 setting_enable_genlist_item(ad->data_tz->item);
1410                         }
1411
1412                         if (ad->data_time) {
1413                                 ad->data_time->isItemDisableFlag = FALSE;
1414                                 setting_enable_evas_object(ad->data_time->eo_check);
1415                                 setting_enable_genlist_item(ad->data_time->item);
1416                         }
1417
1418                 } else {
1419 #if UN_SUPPORT_TIME_DYNAMIC_UPDATE
1420                         ad->pop =
1421                             setting_create_popup_with_btn(ad, ad->win_get, NULL,
1422                                                  _("IDS_ST_POP_RESTART_PHONE_TO_USE_AUTOMATIC_UPDATE_Q"),
1423                                                  setting_time_reboot_resp_cb,
1424                                                  0, 2,
1425                                                  dgettext("sys_string",
1426                                                        "IDS_COM_SK_OK"),
1427                                                  _("IDS_COM_SK_CANCEL"));
1428 #else
1429                         __time_auto_update(ad);
1430 #endif
1431                 }
1432         }
1433 }
1434 static void setting_time_main_mouse_up_Gendial_list_cb(void *data, Evas_Object *obj,
1435                                            void *event_info)
1436 {
1437         SETTING_TRACE_BEGIN;
1438         /* error check */
1439         setting_retm_if(data == NULL, "Data parameter is NULL");
1440
1441         retm_if(event_info == NULL, "Invalid argument: event info is NULL");
1442         Elm_Object_Item *item = (Elm_Object_Item *) event_info;
1443         elm_genlist_item_selected_set(item, 0);
1444         Setting_GenGroupItem_Data *list_item =
1445             (Setting_GenGroupItem_Data *) elm_object_item_data_get(item);
1446
1447         SettingTimeUG *ad = (SettingTimeUG *) data;
1448         SETTING_TRACE("clicking item[%s]", _(list_item->keyStr));
1449
1450         if (ad->data_time && ad->data_time != list_item) {
1451                 elm_object_focus_set(ad->data_time->eo_check, EINA_FALSE);
1452         }
1453
1454         if (ad->data_tz == list_item) {
1455                 ad->is_datefield_selected = EINA_FALSE;
1456                 if (1 == setting_time_check_automatic_time_update_state()) {
1457                         setting_create_simple_popup(ad, ad->win_get,
1458                                                     NULL, _(AUTO_TIME_UPDATE_ON));
1459                 } else {
1460                         setting_time_main_launch_worldclock_sg(ad);
1461                 }
1462
1463         } else if (ad->data_time == list_item) {
1464                 ad->is_datefield_selected = EINA_TRUE;
1465                 if (1 == setting_time_check_automatic_time_update_state()) {
1466                         setting_create_simple_popup(ad, ad->win_get,
1467                                                     NULL, _(AUTO_TIME_UPDATE_ON));
1468                 } else {
1469                         /* setting_view_change(&setting_view_time_main, &setting_view_time_time, ad); */
1470                 }
1471         } else if (ad->data_auto == list_item) {
1472                 ad->is_datefield_selected = EINA_FALSE;
1473                 int old_status = elm_check_state_get(list_item->eo_check);
1474                 /* new status */
1475                 list_item->chk_status = !old_status;
1476                 elm_check_state_set(list_item->eo_check, list_item->chk_status);
1477                 int err = 0;
1478                 if (!list_item->chk_status) {
1479                         (void)
1480                             setting_set_bool_slp_key
1481                             (BOOL_SLP_SETTING_AUTOMATIC_TIME_UPDATE,
1482                              SETTING_ON_OFF_BTN_OFF, &err);
1483
1484                         if (ad->data_tz) {
1485                                 setting_enable_genlist_item(ad->data_tz->item);
1486                         }
1487
1488                         if (ad->data_time) {
1489                                 ad->data_time->isItemDisableFlag = FALSE;
1490                                 setting_enable_evas_object(ad->data_time->eo_check);
1491                                 setting_enable_genlist_item(ad->data_time->item);
1492                         }
1493
1494                 } else {
1495                         #if UN_SUPPORT_TIME_DYNAMIC_UPDATE
1496                         ad->pop =
1497                             setting_create_popup_with_btn(ad, ad->win_get, NULL,
1498                                                  _("IDS_ST_POP_RESTART_PHONE_TO_USE_AUTOMATIC_UPDATE_Q"),
1499                                                  setting_time_reboot_resp_cb,
1500                                                  0, 2,
1501                                                  dgettext("sys_string", "IDS_COM_SK_OK"),
1502                                                  _("IDS_COM_SK_CANCEL"));
1503                         #else
1504                         __time_auto_update(ad);
1505                         #endif
1506                 }
1507
1508         }
1509         else if (ad->data_time_fmt == list_item
1510                    || ad->data_date_fmt == list_item
1511                    || ad->data_firstday_week_fmt == list_item) {
1512                 ad->is_datefield_selected = EINA_FALSE;
1513                 bool status = !elm_genlist_item_expanded_get(item);
1514                 elm_genlist_item_expanded_set(item, status);
1515         }
1516 }
1517
1518
1519 void setting_time_main_btn_update_ok_cb(void *cb)
1520 {
1521         SETTING_TRACE_BEGIN;
1522         SettingTimeUG *ad = (SettingTimeUG *) cb;
1523         int err;                /* error check */
1524         setting_set_bool_slp_key(BOOL_SLP_SETTING_AUTOMATIC_TIME_UPDATE,
1525                                  SETTING_ON_OFF_BTN_ON, &err);
1526         elm_check_state_set(ad->data_auto->eo_check, 1);
1527         ad->data_auto->chk_status = 1;
1528
1529         sysman_request_reboot();
1530
1531         /*  We'd better check return value from sysman_request_reboot() function. */
1532         /*  It will return 0 on success or -1 if failed. */
1533 }
1534
1535
1536 void setting_time_main_btn_update_cancel_cb(void *cb)
1537 {
1538         SETTING_TRACE_BEGIN;
1539         SettingTimeUG *ad = (SettingTimeUG *) cb;
1540
1541         int err;                /* error check */
1542
1543         retm_if(cb == NULL, "Data parameter is NULL");
1544         setting_set_bool_slp_key(BOOL_SLP_SETTING_AUTOMATIC_TIME_UPDATE,
1545                                  SETTING_ON_OFF_BTN_OFF, &err);
1546         elm_check_state_set(ad->data_auto->eo_check, 0);
1547         ad->data_auto->chk_status = 0;
1548
1549 }
1550
1551
1552 static UChar *uastrcpy(const char *chars)
1553 {
1554         int len = 0;
1555         UChar *str = NULL;
1556         len = safeStrLen(chars);
1557         str = (UChar *) malloc(sizeof(UChar) *(len + 1));
1558         if (!str)
1559                 return NULL;
1560         u_uastrcpy(str, chars);
1561         return str;
1562 }
1563
1564
1565 static int get_timezone_isdst(int* isdst)
1566 {
1567         SETTING_TRACE_BEGIN;
1568     struct tm *ts;
1569     time_t ctime;
1570
1571     enum { BUFFERSIZE = 1024 };
1572     char buf[BUFFERSIZE];
1573     ssize_t len = readlink("/opt/etc/localtime", buf, sizeof(buf)-1);
1574
1575     if (len != -1) {
1576         buf[len] = '\0';
1577     }
1578     else {
1579         /* handle error condition */
1580     }
1581
1582     ctime = time(NULL);
1583     ts = localtime(&ctime);
1584         if ( ! ts ) {
1585                 return SETTING_GENERAL_ERR_NULL_DATA_PARAMETER;
1586         }
1587
1588     SETTING_TRACE(" == tz_path = %s", buf);
1589     SETTING_TRACE(" == isdst = %d\n", ts->tm_isdst);
1590         *isdst = ts->tm_isdst;
1591
1592         return SETTING_RETURN_SUCCESS;
1593 }
1594
1595
1596 static void ICU_set_timezone(const char *timezone)
1597 {
1598         SETTING_TRACE("ICU_set_timezone = %s ", timezone);
1599         UErrorCode ec = U_ZERO_ERROR;
1600         UChar *str = uastrcpy(timezone);
1601
1602         ucal_setDefaultTimeZone(str, &ec);
1603         if (U_SUCCESS(ec)) {
1604                 SETTING_TRACE("ucal_setDefaultTimeZone() SUCCESS ");
1605         } else {
1606                 SETTING_TRACE("ucal_setDefaultTimeZone() FAILED : %s ",
1607                               u_errorName(ec));
1608         }
1609         FREE(str);
1610 }
1611
1612 #if DISABLED_CODE
1613 static void setting_time_main_controlbar_lbtn_label_set(
1614                                                         Evas_Object *controlbar,
1615                                                         char *label)
1616 {
1617         SETTING_TRACE_BEGIN;
1618         setting_retm_if(controlbar == NULL, "controlbar parameter is NULL");
1619         setting_retm_if(label == NULL, "label parameter is NULL");
1620
1621         Evas_Object *eo_lbtn = NULL;
1622         Elm_Object_Item *first_item = NULL;
1623
1624         first_item = elm_toolbar_first_item_get(controlbar);
1625         setting_retm_if(first_item == NULL, "get first_item failed");
1626
1627         eo_lbtn = elm_object_item_part_content_get(first_item, "object");
1628         setting_retm_if(eo_lbtn == NULL, "get eo_lbtn failed");
1629
1630         elm_object_text_set(eo_lbtn, label);
1631 }
1632 #endif
1633
1634 /**
1635  * ex) timezone : Asia/Seoul --> returns "+09"
1636  *
1637  * char outstr2[4];
1638  */
1639 static void get_gmt_offset(char *str_buf, int size)
1640 {
1641         // timezone string +/-<n> ex. +9, -1
1642         time_t t = time(0);     // get unix time. sec.
1643
1644         struct tm* data;
1645         data = localtime(&t);           // save time as structure.
1646         setting_retm_if(!data, "data is NULL");
1647         data->tm_isdst = 0;                     // summer time, not applied.
1648         time_t a = mktime(data);
1649
1650         data = gmtime(&a);
1651         data->tm_isdst = 0;                     // summer time, not applied.
1652         time_t b = mktime(data);
1653
1654         int gmtoffset_hour = (a-b)/3600;        // result : hour.
1655         int gmtoffset_min = ((a-b)%3600)/60;    // result : min.
1656         if(gmtoffset_min != 0) {
1657                 gmtoffset_min = 30;
1658         }
1659
1660         snprintf(str_buf, size, "%+d:%02u", gmtoffset_hour, gmtoffset_min);
1661         SETTING_TRACE("szTimezone is of a valid format: GMT: %s", str_buf);
1662 }
1663
1664
1665 // automatic
1666 static char* get_timezone_str()
1667 {
1668     SETTING_TRACE_BEGIN;
1669
1670     enum { BUFFERSIZE = 1024 };
1671     char buf[BUFFERSIZE];
1672     ssize_t len = readlink("/opt/etc/localtime", buf, sizeof(buf)-1);
1673
1674     if (len != -1) {
1675         buf[len] = '\0';
1676     }
1677     else {
1678         /* handle error condition */
1679     }
1680     return g_strdup(buf+20);            //Asia/Seoul
1681 }
1682
1683 static char* get_city_name_result()
1684 {
1685         return s_result;
1686 }
1687
1688
1689 // in_str = "Asia/Seoul"
1690 static bool get_city_name(char* tzname)
1691 {
1692         sqlite3 *pSQLite3 = NULL;
1693         char    *szErrMsg = NULL;
1694
1695         int rst = sqlite3_open( "/opt/dbspace/.worldclock.db", &pSQLite3);
1696         if ( rst )
1697         {
1698                 printf( "Can't open database: %s\n", sqlite3_errmsg( pSQLite3 ));
1699                 sqlite3_close( pSQLite3 );
1700                 pSQLite3 = NULL;
1701                 return false;
1702         }
1703         else
1704         {
1705                 printf("Database opened!!\n");
1706                 char query_str[256];
1707                 snprintf(query_str, 256, "SELECT city FROM city_table where tz_path=\"%s\"", tzname);
1708                 printf("%s \n", query_str);
1709                 rst = sqlite3_exec(pSQLite3, query_str, query_callback, 0, &szErrMsg);
1710         }
1711
1712         //객체해제
1713         sqlite3_free( szErrMsg );
1714         sqlite3_close( pSQLite3 );
1715         printf("Database close!!\n");
1716         return true;
1717 }
1718
1719 static int query_callback(void *NotUsed, int argc, char **argv, char **azColName)
1720 {
1721     int i = 0;
1722     printf("%s\n", argv[i] ? argv[i] : "NULL");
1723         s_result = g_strdup(argv[i] ? argv[i] : "NULL");
1724     return 0;
1725 };
1726
1727
1728 #if 0                   /* example */
1729 int main(int argc, char* argv[])
1730 {
1731         g_type_init ();
1732         int ret;
1733         // exporting - current status
1734         if ( (argc == 2) && (0 == strcmp(argv[1], "export"))) {
1735                         setting_export();
1736         }
1737         else if ( (argc == 2) && (0 == strcmp(argv[1], "timezone_init"))) {
1738
1739                 //////////////////////////////////////////////////////////////////////////
1740                 char* tz_path_zone_city = get_timezone_str();
1741                 bool ret = get_city_name(tz_path_zone_city);
1742                 if (ret) {
1743                         printf(">>>>>> RESULT : %s \n", get_city_name_result());
1744                 }
1745                 //////////////////////////////////////////////////////////////////////////
1746         }
1747         else {
1748                 // cfg create
1749                 // TRUE or FALSE
1750                 ret = setting_cfg_create();
1751         }
1752         return 0;
1753 }
1754 #endif
1755
1756
1757