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