modules/clock/clock.c

   1 /*
   2  *  Indicator
   3  *
   4  * Copyright (c) 2000 - 2015 Samsung Electronics Co., Ltd. All rights reserved.
   5  *
   6  * Licensed under the Apache License, Version 2.0 (the "License");
   7  * you may not use this file except in compliance with the License.
   8  * You may obtain a copy of the License at
   9  *
  10  * http://www.apache.org/licenses/LICENSE-2.0
  11  *
  12  * Unless required by applicable law or agreed to in writing, software
  13  * distributed under the License is distributed on an "AS IS" BASIS,
  14  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  15  * See the License for the specific language governing permissions and
  16  * limitations under the License.
  17  *
  18  */
  19
  20
  21 #include <stdio.h>
  22 #include <stdlib.h>
  23 #include <vconf.h>
  24 //#include <Ecore_X.h>
  25 #include <unicode/udat.h>
  26 #include <unicode/udatpg.h>
  27 #include <unicode/ustring.h>
  28 #include <system_settings.h>
  29
  30 #include "common.h"
  31 #include "indicator.h"
  32 #include "main.h"
  33 #include "indicator_gui.h"
  34 #include "icon.h"
  35 #include "util.h"
  36 #include "modules.h"
  37 #include "box.h"
  38 #include "log.h"
  39
  40 #define SYSTEM_RESUME           "system_wakeup"
  41
  42 #define TIME_FONT_SIZE_24               ELM_SCALE_SIZE(30)
  43 #define TIME_FONT_SIZE_12               ELM_SCALE_SIZE(30)
  44 #define AMPM_FONT_SIZE          ELM_SCALE_SIZE(29)
  45
  46 #define TIME_FONT_COLOR         200, 200, 200, 255
  47 #define AMPM_FONT_COLOR         200, 200, 200, 255
  48 #define LABEL_STRING            "<font_size=%d>%s" \
  49         "</font_size>"
  50 #define LABEL_STRING_FONT               "%s</font>"
  51
  52 #define BATTERY_TIMER_INTERVAL          3
  53 #define BATTERY_TIMER_INTERVAL_CHARGING 30
  54
  55 #define CLOCK_STR_LEN 128
  56
  57 enum {
  58         INDICATOR_CLOCK_MODE_12H = 0,
  59         INDICATOR_CLOCK_MODE_24H,
  60         INDICATOR_CLOCK_MODE_MAX
  61 };
  62
  63 int clock_mode = INDICATOR_CLOCK_MODE_12H;
  64 int clock_hour = 0;
  65 static const char *colon = ":";
  66 static const char *ratio = "&#x2236;";
  67
  68 static int apm_length = 0;
  69 static int apm_position = 0;
  70 extern Ecore_Timer *clock_timer;
  71
  72 static UDateTimePatternGenerator *_last_generator = NULL;
  73 static char *_last_locale = NULL;
  74 static int battery_charging = 0;
  75
  76 static int register_clock_module(void *data);
  77 static int unregister_clock_module(void);
  78 static int language_changed_cb(void *data);
  79 static int region_changed_cb(void *data);
  80 static int wake_up_cb(void *data);
  81 #ifdef _SUPPORT_SCREEN_READER
  82 static int register_clock_tts(void *data,int win_type);
  83 #endif
  84
  85 #define ICON_PRIORITY   INDICATOR_PRIORITY_FIXED8
  86 #define MODULE_NAME             "clock"
  87
  88 static void indicator_get_apm_by_region(char* output, void* data);
  89 static void indicator_get_time_by_region(char* output, void* data);
  90
  91 static void ICU_set_timezone(const char *timezone);
  92
  93 icon_s sysclock = {
  94         .type = INDICATOR_TXT_ICON,
  95         .name = MODULE_NAME,
  96         .priority = ICON_PRIORITY,
  97         .always_top = EINA_FALSE,
  98         .img_obj = {0,},
  99         .obj_exist = EINA_FALSE,
 100         .exist_in_view = EINA_FALSE,
 101         .init = register_clock_module,
 102         .fini = unregister_clock_module,
 103         .lang_changed = NULL,
 104         .region_changed = region_changed_cb,
 105         .lang_changed = language_changed_cb,
 106         .wake_up = wake_up_cb,
 107 };
 108
 109
 110
 111 void cal_delete_last_generator(void)
 112 {
 113         if (_last_locale) {
 114                 free(_last_locale);
 115                 _last_locale = NULL;
 116         }
 117         if (_last_generator) {
 118                 udatpg_close(_last_generator);
 119                 _last_generator = NULL;
 120         }
 121 }
 122
 123
 124
 125 static UDateTimePatternGenerator *__cal_get_pattern_generator(const char *locale, UErrorCode *status)
 126 {
 127         if (!_last_generator || !_last_locale || strcmp(locale, _last_locale)) {
 128
 129                 cal_delete_last_generator();
 130
 131                 _last_locale = strdup(locale);
 132
 133                 _last_generator = udatpg_open(locale, status);
 134
 135         }
 136         return _last_generator;
 137 }
 138
 139
 140
 141 static void set_app_state(void* data)
 142 {
 143         sysclock.ad = data;
 144 }
 145
 146
 147
 148 static void indicator_clock_changed_cb(void *data)
 149 {
 150         char time_str[CLOCK_STR_LEN] = {0,};
 151         char time_buf[CLOCK_STR_LEN] = {0,};
 152         char ampm_buf[CLOCK_STR_LEN] = {0,};
 153         char ampm_str[CLOCK_STR_LEN] = {0,};
 154         char buf[CLOCK_STR_LEN] = {0,};
 155         char result[CLOCK_STR_LEN] = {0,};
 156         char icu_apm[CLOCK_STR_LEN] = {0,};
 157
 158         struct tm *ts = NULL;
 159         time_t ctime;
 160         struct appdata *ad = NULL;
 161         int len;
 162         int font_size;
 163         int ampm_size = AMPM_FONT_SIZE;
 164
 165         ret_if(!data);
 166
 167         ad = (struct appdata *)data;
 168
 169         if (icon_get_update_flag() == 0) return;
 170
 171         /* Set time */
 172         ctime = time(NULL);
 173         localtime_r(&ctime, ts);
 174         if (ts == NULL) {
 175                 _E("Fail to get localtime !");
 176                 return;
 177         }
 178
 179         if (clock_timer != NULL) {
 180                 ecore_timer_del(clock_timer);
 181                 clock_timer = NULL;
 182         }
 183
 184         memset(time_str, 0x00, sizeof(time_str));
 185         memset(ampm_str, 0x00, sizeof(ampm_str));
 186         memset(time_buf, 0x00, sizeof(time_buf));
 187         memset(ampm_buf, 0x00, sizeof(ampm_buf));
 188         memset(buf, 0x00, sizeof(buf));
 189
 190         clock_timer = ecore_timer_add(60 - ts->tm_sec, (void *)indicator_clock_changed_cb, data);
 191         if(!clock_timer) {
 192                 _E("Fail to add timer !");
 193         }
 194
 195         indicator_get_apm_by_region(icu_apm,data);
 196         indicator_get_time_by_region(time_buf,data);
 197
 198
 199         if (clock_mode == INDICATOR_CLOCK_MODE_12H) {
 200                 char bf1[32] = { 0, };
 201                 int hour;
 202                 static int pre_hour = 0;
 203                 const char *region = NULL;
 204
 205                 int bRegioncheck = 0;
 206                 char *lang1 = "it_IT";
 207
 208                 region = vconf_get_str(VCONFKEY_REGIONFORMAT);
 209                 ret_if(!region);
 210
 211                 if (strncmp(region,lang1,strlen(lang1)) == 0) bRegioncheck = 1;
 212
 213                 if (apm_length>=4 || bRegioncheck==1) {
 214                         if (ts->tm_hour >= 0 && ts->tm_hour < 12) {
 215                                 snprintf(ampm_buf, sizeof(ampm_buf),"%s","AM");
 216                         } else {
 217                                 snprintf(ampm_buf, sizeof(ampm_buf),"%s","PM");
 218                         }
 219                 } else {
 220                         snprintf(ampm_buf, sizeof(ampm_buf),"%s",icu_apm);
 221                 }
 222
 223                 strftime(bf1, sizeof(bf1), "%l", ts);
 224                 hour = atoi(bf1);
 225                 strftime(bf1, sizeof(bf1), ":%M", ts);
 226
 227                 font_size = TIME_FONT_SIZE_12;
 228                 clock_hour = hour;
 229
 230                 if ((pre_hour<10 && hour>=10)||(pre_hour>=10 && hour<10)) {
 231                         box_update_display(&(ad->win));
 232                 }
 233
 234                 pre_hour = hour;
 235         } else {
 236                 font_size = TIME_FONT_SIZE_24;
 237         }
 238
 239         snprintf(time_str, sizeof(time_str), LABEL_STRING, font_size, time_buf);
 240         snprintf(ampm_str, sizeof(ampm_str), LABEL_STRING, ampm_size, ampm_buf);
 241
 242         if (clock_mode == INDICATOR_CLOCK_MODE_12H) {
 243                 if (apm_position == 0) {
 244                         len = snprintf(buf, sizeof(buf), "%s %s", ampm_str, time_str);
 245                 } else {
 246                         len = snprintf(buf, sizeof(buf), "%s %s", time_str, ampm_str);
 247                 }
 248         } else {
 249                 len = snprintf(buf, sizeof(buf), "%s", time_str);
 250         }
 251
 252         snprintf(result, sizeof(result), LABEL_STRING_FONT, buf);
 253         if (len < 0) {
 254                 _E("Unexpected ERROR!");
 255                 return;
 256         }
 257
 258         _D("[CLOCK MODULE] Timer Status : %d Time: %s", clock_timer, result);
 259         util_part_text_emit(data, "elm.text.clock", result);
 260
 261         return;
 262 }
 263
 264
 265
 266 static void _clock_format_changed_cb(keynode_t *node, void *data)
 267 {
 268         struct appdata *ad = NULL;
 269         int mode_24 = 0;
 270
 271         ret_if(!data);
 272
 273         ad = (struct appdata *)data;
 274
 275         if (vconf_get_int(VCONFKEY_REGIONFORMAT_TIME1224,&mode_24) < 0)
 276         {
 277                 ERR("Error getting VCONFKEY_REGIONFORMAT_TIME1224 value");
 278                 return;
 279         }
 280
 281         /* Check Time format. If timeformat have invalid value, Set to 12H */
 282         if( mode_24==VCONFKEY_TIME_FORMAT_24)
 283         {
 284                 if(clock_mode == INDICATOR_CLOCK_MODE_12H)
 285                 {
 286                         clock_mode = INDICATOR_CLOCK_MODE_24H;
 287                         box_update_display(&(ad->win));
 288                 }
 289         }
 290         else
 291         {
 292                 if(clock_mode==INDICATOR_CLOCK_MODE_24H)
 293                 {
 294                         clock_mode = INDICATOR_CLOCK_MODE_12H;
 295                         box_update_display(&(ad->win));
 296                 }
 297         }
 298
 299         char *timezone = util_get_timezone_str();
 300         ICU_set_timezone(timezone);
 301         indicator_clock_changed_cb(data);
 302         if(timezone!=NULL)
 303                 free(timezone);
 304 }
 305
 306
 307
 308 static void indicator_clock_charging_now_cb(keynode_t *node, void *data)
 309 {
 310         int status = 0;
 311
 312         retif(data == NULL, , "Invalid parameter!");
 313
 314
 315         vconf_get_int(VCONFKEY_SYSMAN_CHARGER_STATUS, &status);
 316
 317         battery_charging = status;
 318 }
 319
 320
 321
 322 static int language_changed_cb(void *data)
 323 {
 324         const char *pa_lang = vconf_get_str(VCONFKEY_LANGSET);
 325         DBG("language_changed_cb %s",pa_lang);
 326         indicator_clock_changed_cb(data);
 327         return OK;
 328 }
 329
 330
 331
 332 static int region_changed_cb(void *data)
 333 {
 334         _clock_format_changed_cb(NULL, data);
 335         return OK;
 336 }
 337
 338
 339
 340 static int wake_up_cb(void *data)
 341 {
 342         indicator_clock_changed_cb(data);
 343
 344         return OK;
 345 }
 346
 347
 348
 349 /*static void _time_changed(system_settings_key_e key, void *data)
 350 {
 351         DBG("_time_changed");
 352         _clock_format_changed_cb(NULL,data);
 353 }*/
 354
 355
 356
 357 static void regionformat_changed(keynode_t *node, void *data)
 358 {
 359         DBG("regionformat_changed");
 360         _clock_format_changed_cb(NULL,data);
 361 }
 362
 363
 364
 365 static void timezone_int_changed(keynode_t *node, void *data)
 366 {
 367         DBG("timezone_int_changed");
 368         _clock_format_changed_cb(NULL,data);
 369 }
 370
 371
 372
 373 static void timezone_id_changed(keynode_t *node, void *data)
 374 {
 375         char *szTimezone = NULL;
 376         szTimezone = vconf_get_str(VCONFKEY_SETAPPL_TIMEZONE_ID);
 377
 378         DBG("timezone_id_changed %s",szTimezone);
 379         _clock_format_changed_cb(NULL,data);
 380 }
 381
 382
 383
 384 static int register_clock_module(void *data)
 385 {
 386         int r = 0, ret = -1;
 387
 388         retif(data == NULL, FAIL, "Invalid parameter!");
 389
 390         set_app_state(data);
 391
 392         /*ret = system_settings_set_changed_cb(SYSTEM_SETTINGS_KEY_TIME_CHANGED, _time_changed, data);
 393         if (ret != OK) {
 394                 r = r | ret;
 395         }*/
 396
 397         ret = vconf_notify_key_changed(VCONFKEY_REGIONFORMAT_TIME1224, regionformat_changed, data);
 398         if (ret != OK) {
 399                 r = r | ret;
 400         }
 401
 402         ret = vconf_notify_key_changed(VCONFKEY_SETAPPL_TIMEZONE_INT, timezone_int_changed, data);
 403         if (ret != OK) {
 404                 r = r | ret;
 405         }
 406
 407         ret = vconf_notify_key_changed(VCONFKEY_SETAPPL_TIMEZONE_ID, timezone_id_changed, data);
 408         if (ret != OK) {
 409                 r = r | ret;
 410         }
 411
 412         ret = vconf_notify_key_changed(VCONFKEY_REGIONFORMAT, regionformat_changed, data);
 413         if (ret != OK) {
 414                 r = r | ret;
 415         }
 416         _clock_format_changed_cb(NULL, data);
 417         indicator_clock_charging_now_cb(NULL,data);
 418
 419         return r;
 420 }
 421
 422
 423
 424 static int unregister_clock_module(void)
 425 {
 426         int ret = 0;
 427
 428         //ret = system_settings_unset_changed_cb(SYSTEM_SETTINGS_KEY_TIME_CHANGED);
 429         ret = ret | vconf_ignore_key_changed(VCONFKEY_REGIONFORMAT_TIME1224, regionformat_changed);
 430         ret = ret | vconf_ignore_key_changed(VCONFKEY_SETAPPL_TIMEZONE_INT, timezone_int_changed);
 431         ret = ret | vconf_ignore_key_changed(VCONFKEY_SETAPPL_TIMEZONE_ID, timezone_id_changed);
 432         ret = ret | vconf_ignore_key_changed(VCONFKEY_REGIONFORMAT, regionformat_changed);
 433
 434         if (clock_timer != NULL) {
 435                 ecore_timer_del(clock_timer);
 436                 clock_timer = NULL;
 437         }
 438
 439         cal_delete_last_generator();
 440
 441         return ret;
 442 }
 443
 444
 445
 446 static inline char *_extend_heap(char *buffer, int *sz, int incsz)
 447 {
 448         char *tmp;
 449
 450         *sz += incsz;
 451         tmp = realloc(buffer, *sz);
 452         if (!tmp) {
 453                 ERR("Heap");
 454                 return NULL;
 455         }
 456
 457         return tmp;
 458 }
 459
 460
 461
 462 static char *_string_replacer(const char *src, const char *pattern, const char *replace)
 463 {
 464         const char *ptr;
 465         char *tmp = NULL;
 466         char *ret = NULL;
 467         int idx = 0;
 468         int out_idx = 0;
 469         int out_sz = 0;
 470         int replace_len = 0;
 471
 472         enum {
 473                 STATE_START,
 474                 STATE_FIND,
 475                 STATE_CHECK,
 476                 STATE_END,
 477         } state;
 478
 479         if (!src || !pattern)
 480                 return NULL;
 481
 482         out_sz = strlen(src);
 483         ret = strdup(src);
 484         if (!ret) {
 485                 ERR("Heap");
 486                 return NULL;
 487         }
 488
 489         replace_len = strlen(replace);
 490         if (replace_len) {
 491                 ERR("Ratio");
 492                 return NULL;
 493         }
 494
 495         out_idx = 0;
 496         for (state = STATE_START, ptr = src; state != STATE_END; ptr++) {
 497                 switch (state) {
 498                 case STATE_START:
 499                         if (*ptr == '\0') {
 500                                 state = STATE_END;
 501                         } else if (!isblank(*ptr)) {
 502                                 state = STATE_FIND;
 503                                 ptr--;
 504                         }
 505                         break;
 506                 case STATE_FIND:
 507                         if (*ptr == '\0') {
 508                                 state = STATE_END;
 509                         } else if (*ptr == *pattern) {
 510                                 state = STATE_CHECK;
 511                                 ptr--;
 512                                 idx = 0;
 513                         } else {
 514                                 ret[out_idx] = *ptr;
 515                                 out_idx++;
 516                                 if (out_idx == out_sz) {
 517                                         tmp = _extend_heap(ret, &out_sz, strlen(replace) + 1);
 518                                         if (!tmp) {
 519                                                 free(ret);
 520                                                 return NULL;
 521                                         }
 522                                         ret = tmp;
 523                                 }
 524                         }
 525                         break;
 526                 case STATE_CHECK:
 527                         if (!pattern[idx]) {
 528                                 /*!
 529      * If there is no space for copying the replacement,
 530      * Extend size of the return buffer.
 531      */
 532                                 if (out_sz - out_idx < replace_len + 1) {
 533                                         tmp = _extend_heap(ret, &out_sz, strlen(replace) + 1);
 534                                         if (!tmp) {
 535                                                 free(ret);
 536                                                 return NULL;
 537                                         }
 538                                         ret = tmp;
 539                                 }
 540
 541                                 strncpy(ret + out_idx, replace, replace_len);
 542                                 out_idx += strlen(replace);
 543
 544                                 state = STATE_FIND;
 545                                 ptr--;
 546                         } else if (*ptr != pattern[idx]) {
 547                                 ptr -= idx;
 548
 549                                 /* Copy the first matched character */
 550                                 ret[out_idx] = *ptr;
 551                                 out_idx++;
 552                                 if (out_idx == out_sz) {
 553                                         tmp = _extend_heap(ret, &out_sz, strlen(replace) + 1);
 554                                         if (!tmp) {
 555                                                 free(ret);
 556                                                 return NULL;
 557                                         }
 558
 559                                         ret = tmp;
 560                                 }
 561
 562                                 state = STATE_FIND;
 563                         } else {
 564                                 idx++;
 565                         }
 566                         break;
 567                 default:
 568                         break;
 569                 }
 570         }
 571
 572         ret[out_idx] = '\0';
 573         return ret;
 574 }
 575
 576
 577
 578 void indicator_get_apm_by_region(char* output,void *data)
 579 {
 580         retif(data == NULL, , "Data parameter is NULL");
 581         retif(output == NULL, , "output parameter is NULL");
 582
 583
 584         UChar customSkeleton[CLOCK_STR_LEN] = { 0, };
 585         UChar u_timezone[64] = {0,};
 586
 587         UErrorCode status = U_ZERO_ERROR;
 588         UDateFormat *formatter = NULL;
 589
 590         UChar bestPattern[CLOCK_STR_LEN] = { 0, };
 591         UChar formatted[CLOCK_STR_LEN] = { 0, };
 592
 593         char bestPatternString[CLOCK_STR_LEN] = { 0, };
 594         char formattedString[CLOCK_STR_LEN] = { 0, };
 595
 596         UDateTimePatternGenerator *pattern_generator = NULL;
 597
 598         char *time_skeleton = "hhmm";
 599
 600         char* timezone_id = NULL;
 601         timezone_id = util_get_timezone_str();
 602
 603         char *locale = vconf_get_str(VCONFKEY_REGIONFORMAT);
 604         if(locale == NULL)
 605         {
 606                 ERR("[Error] get value of fail.");
 607                 free(timezone_id);
 608                 return;
 609         }
 610
 611         /* Remove ".UTF-8" in locale */
 612         char locale_tmp[32] = {0,};
 613         strncpy(locale_tmp, locale, sizeof(locale_tmp)-1);
 614         char *p = util_safe_str(locale_tmp, ".UTF-8");
 615         if (p) {
 616                 *p = 0;
 617         }
 618
 619         u_uastrncpy(customSkeleton, time_skeleton, strlen(time_skeleton));
 620
 621         pattern_generator = __cal_get_pattern_generator (locale_tmp, &status);
 622         if (pattern_generator == NULL) {
 623                 return ;
 624         }
 625
 626         int32_t bestPatternCapacity = (int32_t) (sizeof(bestPattern) / sizeof((bestPattern)[0]));
 627         (void)udatpg_getBestPattern(pattern_generator, customSkeleton,
 628                                     u_strlen(customSkeleton), bestPattern,
 629                                     bestPatternCapacity, &status);
 630
 631         u_austrcpy(bestPatternString, bestPattern);
 632         u_uastrcpy(bestPattern,"a");
 633
 634         DBG("TimeZone is %s", timezone_id);
 635
 636         if(bestPatternString[0] == 'a')
 637         {
 638                 apm_position = 0;
 639         }
 640         else
 641         {
 642                 apm_position = 1;
 643         }
 644
 645         UDate date = ucal_getNow();
 646         if(timezone_id)
 647         {
 648                 u_uastrncpy(u_timezone, timezone_id, sizeof(u_timezone));
 649                 formatter = udat_open(UDAT_IGNORE, UDAT_IGNORE, locale_tmp, u_timezone, -1, bestPattern, -1, &status);
 650         }
 651         else
 652         {
 653                 formatter = udat_open(UDAT_IGNORE, UDAT_IGNORE, locale_tmp, NULL, -1, bestPattern, -1, &status);
 654         }
 655         if (formatter == NULL) {
 656                 return ;
 657         }
 658
 659         int32_t formattedCapacity = (int32_t) (sizeof(formatted) / sizeof((formatted)[0]));
 660         (void)udat_format(formatter, date, formatted, formattedCapacity, NULL, &status);
 661         u_austrcpy(formattedString, formatted);
 662
 663         apm_length = u_strlen(formatted);
 664
 665         udat_close(formatter);
 666
 667         if(strlen(formattedString)<CLOCK_STR_LEN)
 668         {
 669                 strncpy(output,formattedString,strlen(formattedString));
 670         }
 671         else
 672         {
 673                 strncpy(output,formattedString,CLOCK_STR_LEN-1);
 674         }
 675
 676         return;
 677 }
 678
 679
 680
 681 void indicator_get_time_by_region(char* output,void *data)
 682 {
 683         retif(data == NULL, , "Data parameter is NULL");
 684         retif(output == NULL, , "output parameter is NULL");
 685
 686         UChar customSkeleton[CLOCK_STR_LEN] = { 0, };
 687         UChar u_timezone[64] = {0,};
 688
 689         UErrorCode status = U_ZERO_ERROR;
 690         UDateFormat *formatter = NULL;
 691
 692         UChar bestPattern[CLOCK_STR_LEN] = { 0, };
 693         UChar formatted[CLOCK_STR_LEN] = { 0, };
 694
 695         char bestPatternString[CLOCK_STR_LEN] = { 0, };
 696         char formattedString[CLOCK_STR_LEN] = { 0, };
 697         char* convertFormattedString = NULL;
 698
 699         char time_skeleton[20] = {0,};
 700         UDateTimePatternGenerator *pattern_generator = NULL;
 701
 702         if(clock_mode == INDICATOR_CLOCK_MODE_12H)
 703         {
 704                 strncpy(time_skeleton,"hm", 2);
 705         }
 706         else
 707         {
 708                 strncpy(time_skeleton,"Hm", 2);
 709         }
 710         char* timezone_id = NULL;
 711         timezone_id = util_get_timezone_str();
 712
 713         char *locale = vconf_get_str(VCONFKEY_REGIONFORMAT);
 714         if(locale == NULL)
 715         {
 716                 ERR("[Error] get value of fail.");
 717                 free(timezone_id);
 718                 return;
 719         }
 720
 721         /* Remove ".UTF-8" in locale */
 722         char locale_tmp[32] = {0,};
 723         strncpy(locale_tmp, locale, sizeof(locale_tmp)-1);
 724         char *p = util_safe_str(locale_tmp, ".UTF-8");
 725         if (p) {
 726                 *p = 0;
 727         }
 728
 729         u_uastrncpy(customSkeleton, time_skeleton, strlen(time_skeleton));
 730
 731         pattern_generator = __cal_get_pattern_generator (locale_tmp, &status);
 732         if (pattern_generator == NULL) {
 733                 return ;
 734         }
 735
 736         int32_t bestPatternCapacity = (int32_t) (sizeof(bestPattern) / sizeof((bestPattern)[0]));
 737         (void)udatpg_getBestPattern(pattern_generator, customSkeleton,
 738                                     u_strlen(customSkeleton), bestPattern,
 739                                     bestPatternCapacity, &status);
 740
 741         char a_best_pattern[64] = {0,};
 742         char *last_pattern = NULL;
 743         u_austrcpy(a_best_pattern, bestPattern);
 744         char *a_best_pattern_fixed = strtok_r(a_best_pattern, "a", &last_pattern);
 745         a_best_pattern_fixed = strtok_r(a_best_pattern_fixed, " ", &last_pattern);
 746         if(a_best_pattern_fixed)
 747         {
 748                 u_uastrcpy(bestPattern, a_best_pattern_fixed);
 749         }
 750
 751         u_austrcpy(bestPatternString, bestPattern);
 752
 753         DBG("BestPattern is %s", bestPatternString);
 754         DBG("TimeZone is %s", timezone_id);
 755
 756         UDate date = ucal_getNow();
 757         if(timezone_id)
 758         {
 759                 u_uastrncpy(u_timezone, timezone_id, sizeof(u_timezone));
 760                 formatter = udat_open(UDAT_IGNORE, UDAT_IGNORE, locale_tmp, u_timezone, -1, bestPattern, -1, &status);
 761         }
 762         else
 763         {
 764                 formatter = udat_open(UDAT_IGNORE, UDAT_IGNORE, locale_tmp, NULL, -1, bestPattern, -1, &status);
 765         }
 766
 767         if (formatter == NULL) {
 768                 return;
 769         }
 770         int32_t formattedCapacity = (int32_t) (sizeof(formatted) / sizeof((formatted)[0]));
 771         (void)udat_format(formatter, date, formatted, formattedCapacity, NULL, &status);
 772         u_austrcpy(formattedString, formatted);
 773         DBG("DATE & TIME is %s %s %d %s", locale_tmp, formattedString, u_strlen(formatted), bestPatternString);
 774
 775         DBG("24H :: Before change %s", formattedString);
 776         convertFormattedString = _string_replacer(formattedString, colon, ratio);
 777         DBG("24H :: After change %s", convertFormattedString);
 778
 779         if(convertFormattedString == NULL)
 780         {
 781                 DBG("_string_replacer return NULL");
 782                 udat_close(formatter);
 783                 return;
 784         }
 785
 786         udat_close(formatter);
 787
 788         if(strlen(convertFormattedString)<CLOCK_STR_LEN)
 789         {
 790                 strncpy(output,convertFormattedString,strlen(convertFormattedString));
 791         }
 792         else
 793         {
 794                 strncpy(output,convertFormattedString,CLOCK_STR_LEN-1);
 795         }
 796
 797         if(convertFormattedString != NULL)
 798         {
 799                 free(convertFormattedString);
 800                 convertFormattedString = NULL;
 801         }
 802
 803         return;
 804 }
 805
 806
 807
 808 static UChar *uastrcpy(const char *chars)
 809 {
 810         int len = 0;
 811         UChar *str = NULL;
 812         len = strlen(chars);
 813         str = (UChar *) malloc(sizeof(UChar) *(len + 1));
 814         if (!str)
 815                 return NULL;
 816         u_uastrcpy(str, chars);
 817         return str;
 818 }
 819
 820
 821
 822 static void ICU_set_timezone(const char *timezone)
 823 {
 824         if(timezone == NULL)
 825         {
 826                 ERR("TIMEZONE is NULL");
 827                 return;
 828         }
 829
 830         UErrorCode ec = U_ZERO_ERROR;
 831         UChar *str = uastrcpy(timezone);
 832
 833         ucal_setDefaultTimeZone(str, &ec);
 834         if (U_SUCCESS(ec)) {
 835         } else {
 836                 DBG("ucal_setDefaultTimeZone() FAILED : %s ",
 837                               u_errorName(ec));
 838         }
 839         free(str);
 840 }
 841
 842
 843
 844 #ifdef _SUPPORT_SCREEN_READER
 845 static char *_access_info_cb(void *data, Evas_Object *obj)
 846 {
 847         Evas_Object *item = data;
 848         char *tmp = NULL;
 849         char time_str[32];
 850         char time_buf[128], ampm_buf[128];
 851         char buf[CLOCK_STR_LEN];
 852         char buf1[CLOCK_STR_LEN];
 853         int ret = 0;
 854         int battery_capa = 0;
 855         int hour = 0;
 856         int minute = 0;
 857         char strHour[128] = { 0, };
 858         char strMin[128] = { 0, };
 859
 860
 861         struct tm *ts = NULL;
 862         time_t ctime;
 863         int len;
 864
 865         retif(data == NULL,NULL, "Invalid parameter!");
 866         char *timezone = util_get_timezone_str();
 867         ICU_set_timezone(timezone);
 868         if(timezone!=NULL)
 869                 free(timezone);
 870
 871         /* Set time */
 872         ctime = time(NULL);
 873         ts = localtime(&ctime);
 874         if (ts == NULL)
 875                 return NULL;
 876
 877         memset(time_str, 0x00, sizeof(time_str));
 878         memset(time_buf, 0x00, sizeof(time_buf));
 879         memset(ampm_buf, 0x00, sizeof(ampm_buf));
 880         memset(buf, 0x00, sizeof(buf));
 881         memset(buf1, 0x00, sizeof(buf1));
 882
 883         if (clock_mode == INDICATOR_CLOCK_MODE_12H) {
 884                 char bf1[32] = { 0, };
 885
 886                 if (ts->tm_hour >= 0 && ts->tm_hour < 12)
 887                         strncpy(ampm_buf, _("IDS_IDLE_OPT_AM_ABB"),sizeof(ampm_buf)-1);
 888                 else
 889                         strncpy(ampm_buf, _("IDS_IDLE_OPT_PM_ABB"),sizeof(ampm_buf)-1);
 890
 891                 strftime(bf1, sizeof(bf1), "%l", ts);
 892                 hour = atoi(bf1);
 893                 strftime(bf1, sizeof(bf1), "%M", ts);
 894                 minute = atoi(bf1);
 895         }
 896         else{
 897                 char bf1[32] = { 0, };
 898
 899                 strftime(bf1, sizeof(bf1), "%H", ts);
 900                 hour = atoi(bf1);
 901                 strftime(bf1, sizeof(bf1), "%M", ts);
 902                 minute = atoi(bf1);
 903         }
 904
 905         if(hour ==1)
 906         {
 907                 strncpy(strHour, _("IDS_COM_BODY_1_HOUR"),sizeof(strHour));
 908         }
 909         else
 910         {
 911                 snprintf(strHour, sizeof(strHour), _("IDS_COM_POP_PD_HOURS"),hour);
 912         }
 913
 914         if(minute ==1)
 915         {
 916                 strncpy(strMin, _("IDS_COM_BODY_1_MINUTE"),sizeof(strMin));
 917         }
 918         else
 919         {
 920                 snprintf(strMin, sizeof(strMin), _("IDS_COM_BODY_PD_MINUTES"),minute);
 921         }
 922
 923         if(clock_mode == INDICATOR_CLOCK_MODE_12H)
 924                 snprintf(time_str, sizeof(time_str), "%s, %s, %s", strHour, strMin,ampm_buf);
 925         else
 926                 snprintf(time_str, sizeof(time_str), "%s, %s", strHour, strMin);
 927
 928
 929         ret = vconf_get_int(VCONFKEY_SYSMAN_BATTERY_CAPACITY, &battery_capa);
 930         if (ret != OK)
 931         {
 932                 return NULL;
 933         }
 934         if (battery_capa < 0)
 935         {
 936                 return NULL;
 937         }
 938
 939         if (battery_capa > 100)
 940                 battery_capa = 100;
 941         snprintf(buf1, sizeof(buf1), _("IDS_IDLE_BODY_PD_PERCENT_OF_BATTERY_POWER_REMAINING"), battery_capa);
 942
 943         snprintf(buf, sizeof(buf), "%s, %s, %s", time_str, buf1, _("IDS_IDLE_BODY_STATUS_BAR_ITEM"));
 944
 945         DBG("buf: %s", buf);
 946         tmp = strdup(buf);
 947         if (!tmp) return NULL;
 948         return tmp;
 949 }
 950
 951
 952
 953 static int register_clock_tts(void *data,int win_type)
 954 {
 955         int r = 0, ret = -1;
 956
 957         retif(data == NULL, FAIL, "Invalid parameter!");
 958
 959         Evas_Object *to = NULL;
 960         Evas_Object *ao = NULL;
 961         struct appdata *ad = data;
 962
 963         to = (Evas_Object *) edje_object_part_object_get(elm_layout_edje_get(ad->win[win_type].layout), "elm.rect.clock.access");
 964         ao = util_access_object_register(to, ad->win[win_type].layout);
 965         util_access_object_info_cb_set(ao,ELM_ACCESS_INFO,_access_info_cb,data);
 966         return 0;
 967 }
 968 #endif
 969