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

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