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