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