modules/clock/clock.c

   1 /*
   2  * Copyright 2012  Samsung Electronics Co., Ltd
   3  *
   4  * Licensed under the Flora License, Version 1.1 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *  http://floralicense.org/license/
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 #include <stdio.h>
  18 #include <stdlib.h>
  19 #include <vconf.h>
  20 #include <runtime_info.h>
  21 #include <Ecore_X.h>
  22 #include <unicode/udat.h>
  23 #include <unicode/udatpg.h>
  24 #include <unicode/ustring.h>
  25
  26 #include "common.h"
  27 #include "indicator.h"
  28 #include "indicator_ui.h"
  29 #include "indicator_gui.h"
  30 #include "indicator_icon_util.h"
  31 #include "indicator_util.h"
  32 #include "modules.h"
  33
  34 #define SYSTEM_RESUME                           "system_wakeup"
  35
  36 #define TIME_FONT_SIZE_24       34
  37 #define TIME_FONT_SIZE_12       30
  38 #define TIME_FONT_SIZE_BATTERY  32
  39 #define TIME_FONT_COLOR         243, 243, 243, 255
  40
  41 #define AMPM_FONT_SIZE          24
  42 #define AMPM_FONT_COLOR         243, 243, 243, 255
  43 #define LABEL_STRING            "<font_size=%d>%s" \
  44                                 "</font_size></font>"
  45
  46 #define BATTERY_TIMER_INTERVAL          3
  47 #define BATTERY_TIMER_INTERVAL_CHARGING 30
  48
  49 #define CLOCK_STR_LEN 256
  50
  51 enum {
  52         INDICATOR_CLOCK_MODE_12H = 0,
  53         INDICATOR_CLOCK_MODE_24H,
  54         INDICATOR_CLOCK_MODE_MAX
  55 };
  56
  57 static int notifd;
  58 static int clock_mode = INDICATOR_CLOCK_MODE_12H;
  59 static int apm_length = 0;
  60 static int apm_position = 0;
  61 static Ecore_Timer *timer = NULL;
  62 static Ecore_Timer *battery_timer = NULL;
  63 static Ecore_Timer *battery_charging_timer = NULL;
  64 static int battery_charging = 0;
  65 static int battery_charging_first = 0;
  66
  67 static int register_clock_module(void *data);
  68 static int unregister_clock_module(void);
  69 static int language_changed_cb(void *data);
  70 static int region_changed_cb(void *data);
  71 static int wake_up_cb(void *data);
  72
  73 #define ICON_PRIORITY   INDICATOR_PRIORITY_FIXED6
  74 #define MODULE_NAME             "clock"
  75
  76 static void indicator_get_time_by_region(char* output, void* data);
  77 static void ICU_set_timezone(const char *timezone);
  78 static void indicator_clock_display_battery_percentage(void *data,int win_type );
  79
  80 Indicator_Icon_Object sysclock[INDICATOR_WIN_MAX] = {
  81 {
  82         .win_type = INDICATOR_WIN_PORT,
  83         .type = INDICATOR_TXT_ICON,
  84         .name = MODULE_NAME,
  85         .priority = ICON_PRIORITY,
  86         .always_top = EINA_FALSE,
  87         .txt_obj = {0,},
  88         .img_obj = {0,},
  89         .obj_exist = EINA_FALSE,
  90         .exist_in_view = EINA_FALSE,
  91         .init = register_clock_module,
  92         .fini = unregister_clock_module,
  93         .lang_changed = NULL,
  94         .region_changed = region_changed_cb,
  95         .lang_changed = language_changed_cb,
  96         .wake_up = wake_up_cb
  97 },
  98 {
  99         .win_type = INDICATOR_WIN_LAND,
 100         .type = INDICATOR_TXT_ICON,
 101         .name = MODULE_NAME,
 102         .priority = ICON_PRIORITY,
 103         .always_top = EINA_FALSE,
 104         .txt_obj = {0,},
 105         .img_obj = {0,},
 106         .obj_exist = EINA_FALSE,
 107         .exist_in_view = EINA_FALSE,
 108         .init = register_clock_module,
 109         .fini = unregister_clock_module,
 110         .lang_changed = NULL,
 111         .region_changed = region_changed_cb,
 112         .lang_changed = language_changed_cb,
 113         .wake_up = wake_up_cb
 114 }
 115 };
 116
 117 static void set_app_state(void* data)
 118 {
 119         int i = 0;
 120
 121         for (i=0 ; i<INDICATOR_WIN_MAX ; i++)
 122         {
 123                 sysclock[i].ad = data;
 124         }
 125 }
 126
 127 static void indicator_clock_changed_cb(void *data)
 128 {
 129         char time_str[32];
 130         char time_buf[128], ampm_buf[128];
 131         char buf[CLOCK_STR_LEN];
 132         char icu_apm[CLOCK_STR_LEN] = {0,};
 133
 134         struct tm *ts = NULL;
 135         time_t ctime;
 136         int len;
 137         int font_size;
 138
 139         retif(data == NULL, , "Invalid parameter!");
 140
 141         if(indicator_util_get_update_flag()==0)
 142         {
 143                 DBG("need to update");
 144                 return;
 145         }
 146
 147         if (battery_timer != NULL || battery_charging_timer != NULL)
 148         {
 149                 DBG("battery is displaying. ignore clock callback");
 150                 return;
 151         }
 152
 153         ctime = time(NULL);
 154         ts = localtime(&ctime);
 155         if (ts == NULL)
 156                 return;
 157
 158         if (timer != NULL) {
 159                 ecore_timer_del(timer);
 160                 timer = NULL;
 161         }
 162
 163         memset(time_str, 0x00, sizeof(time_str));
 164         memset(time_buf, 0x00, sizeof(time_buf));
 165         memset(ampm_buf, 0x00, sizeof(ampm_buf));
 166         memset(buf, 0x00, sizeof(buf));
 167
 168         timer =
 169             ecore_timer_add(60 - ts->tm_sec, (void *)indicator_clock_changed_cb,
 170                             data);
 171
 172         indicator_get_time_by_region(icu_apm,data);
 173
 174         if (clock_mode == INDICATOR_CLOCK_MODE_12H) {
 175                 char bf1[32] = { 0, };
 176                 int hour;
 177
 178                 if(apm_length>0 && apm_length<=4)
 179                 {
 180                         snprintf(ampm_buf, sizeof(ampm_buf),LABEL_STRING, AMPM_FONT_SIZE,icu_apm);
 181                 }
 182                 else
 183                 {
 184                         if (ts->tm_hour >= 0 && ts->tm_hour < 12)
 185                                 snprintf(ampm_buf, sizeof(ampm_buf),
 186                                          LABEL_STRING, AMPM_FONT_SIZE,
 187                                          "AM");
 188                         else
 189                                 snprintf(ampm_buf, sizeof(ampm_buf),
 190                                          LABEL_STRING, AMPM_FONT_SIZE,
 191                                          "PM");
 192                 }
 193
 194                 strftime(bf1, sizeof(bf1), "%l", ts);
 195                 hour = atoi(bf1);
 196                 strftime(bf1, sizeof(bf1), ":%M", ts);
 197
 198                 snprintf(time_str, sizeof(time_str), "%d%s", hour, bf1);
 199                 font_size = TIME_FONT_SIZE_12;
 200                 indicator_signal_emit(data,"indicator.clock.ampm","indicator.prog");
 201         }
 202         else{
 203                 font_size = TIME_FONT_SIZE_24;
 204                 strftime(time_str, sizeof(time_str), "%H:%M", ts);
 205                 indicator_signal_emit(data,"indicator.clock.default","indicator.prog");
 206         }
 207
 208         snprintf(time_buf, sizeof(time_buf), LABEL_STRING, font_size, time_str);
 209
 210         if(apm_position == 0)
 211                 len = snprintf(buf, sizeof(buf), "%s%s", ampm_buf, time_buf);
 212         else
 213                 len = snprintf(buf, sizeof(buf), "%s%s", time_buf, ampm_buf);
 214
 215         if (len < 0) {
 216                 ERR("Unexpected ERROR!");
 217                 return;
 218         }
 219
 220         INFO("[CLOCK MODULE] Timer Status : %d Time: %s", timer, buf);
 221
 222         indicator_part_text_emit(data,"elm.text.clock", buf);
 223
 224         return;
 225 }
 226
 227 static void indicator_clock_format_changed_cb(keynode_t *node, void *data)
 228 {
 229         retif(data == NULL, , "Invalid parameter!");
 230
 231         int r = -1;
 232
 233         bool is_24hour_enabled = false;
 234
 235         INFO("[Enter] indicator_clock_format_changed_cb");
 236
 237         r = runtime_info_get_value_bool(
 238                         RUNTIME_INFO_KEY_24HOUR_CLOCK_FORMAT_ENABLED, &is_24hour_enabled);
 239
 240         if( r==RUNTIME_INFO_ERROR_NONE&&is_24hour_enabled==true)
 241         {
 242                 clock_mode = INDICATOR_CLOCK_MODE_24H;
 243         }
 244         else
 245         {
 246                 clock_mode = INDICATOR_CLOCK_MODE_12H;
 247         }
 248
 249         char *timezone = vconf_get_str(VCONFKEY_SETAPPL_TIMEZONE_ID);
 250         ICU_set_timezone(timezone);
 251         indicator_clock_changed_cb(data);
 252         free(timezone);
 253 }
 254
 255 static void indicator_clock_pm_state_change_cb(keynode_t *node, void *data)
 256 {
 257         int status = 0;
 258
 259         retif(data == NULL, , "Invalid parameter!");
 260
 261         vconf_get_int(VCONFKEY_PM_STATE, &status);
 262
 263         switch(status)
 264         {
 265                 case VCONFKEY_PM_STATE_LCDOFF:
 266                         if (timer != NULL) {
 267                                 ecore_timer_del(timer);
 268                                 timer = NULL;
 269                         }
 270
 271                         if (battery_timer != NULL) {
 272                                 ecore_timer_del(battery_timer);
 273                                 battery_timer = NULL;
 274                         }
 275
 276                         if (battery_charging_timer != NULL) {
 277                                 ecore_timer_del(battery_charging_timer);
 278                                 battery_charging_timer = NULL;
 279                         }
 280                         break;
 281                 default:
 282                         break;
 283         }
 284
 285 }
 286
 287 static void indicator_clock_battery_disp_changed_cb(keynode_t *node, void *data)
 288 {
 289         int status = 0;
 290
 291         vconf_get_int(VCONFKEY_BATTERY_DISP_STATE,&status);
 292
 293         DBG("indicator_clock_battery_disp_changed_cb(%d)",status);
 294
 295         if(status==2)
 296         {
 297                 indicator_clock_display_battery_percentage(data,0);
 298                 indicator_clock_display_battery_percentage(data,1);
 299         }
 300         else
 301         {
 302                 indicator_clock_display_battery_percentage(data,status);
 303         }
 304 }
 305
 306 static void indicator_clock_charging_now_cb(keynode_t *node, void *data)
 307 {
 308         int status = 0;
 309         int lock_state = 0;
 310
 311         retif(data == NULL, , "Invalid parameter!");
 312
 313         vconf_get_int(VCONFKEY_IDLE_LOCK_STATE, &lock_state);
 314
 315         vconf_get_int(VCONFKEY_SYSMAN_BATTERY_CHARGE_NOW, &status);
 316
 317         battery_charging = status;
 318
 319         DBG("indicator_clock_charging_now_cb(%d)",status);
 320
 321         if(lock_state==VCONFKEY_IDLE_LOCK)
 322         {
 323                 DBG("indicator_clock_charging_now_cb:lock_state(%d)",lock_state);
 324                 return;
 325         }
 326
 327         if(battery_charging_first == 1&&status==1)
 328         {
 329                 DBG("indicator_clock_charging_now_cb : ignore(%d)",status);
 330         }
 331
 332         if(status==1)
 333         {
 334                 battery_charging_first = 1;
 335                 indicator_clock_display_battery_percentage(data,0);
 336         }
 337 }
 338
 339 static void indicator_clock_battery_capacity_cb(keynode_t *node, void *data)
 340 {
 341         retif(data == NULL, , "Invalid parameter!");
 342
 343         if(battery_charging==1&&battery_charging_timer!=NULL)
 344         {
 345                 DBG("indicator_clock_battery_capacity_cb:battery_charging(%d)",battery_charging);
 346                 indicator_clock_display_battery_percentage(data,0);
 347         }
 348 }
 349
 350
 351 static void indicator_clock_usb_cb(keynode_t *node, void *data)
 352 {
 353         int status = 0;
 354
 355         retif(data == NULL, , "Invalid parameter!");
 356
 357         vconf_get_int(VCONFKEY_SYSMAN_USB_STATUS, &status);
 358
 359         DBG("indicator_clock_usb_cb(%d)",status);
 360
 361         if(status==VCONFKEY_SYSMAN_USB_DISCONNECTED)
 362         {
 363                 battery_charging_first = 0;
 364                 if (battery_charging_timer != NULL)
 365                 {
 366                         ecore_timer_del(battery_charging_timer);
 367                         battery_charging_timer = NULL;
 368                 }
 369                 indicator_clock_changed_cb(data);
 370         }
 371 }
 372
 373 static void indicator_clock_battery_display_cb(void *data)
 374 {
 375         INFO("indicator_clock_battery_charging_stop_cb");
 376
 377         if (battery_timer != NULL) {
 378                 ecore_timer_del(battery_timer);
 379                 battery_timer = NULL;
 380         }
 381
 382         indicator_clock_changed_cb(data);
 383 }
 384
 385 static void indicator_clock_battery_charging_stop_cb(void *data)
 386 {
 387
 388         INFO("indicator_clock_battery_charging_stop_cb");
 389
 390         if (battery_charging_timer != NULL) {
 391                 ecore_timer_del(battery_charging_timer);
 392                 battery_charging_timer = NULL;
 393         }
 394
 395         indicator_clock_changed_cb(data);
 396 }
 397
 398 static void indicator_clock_lock_state_cb(keynode_t *node, void *data)
 399 {
 400         int status = 0;
 401
 402         retif(data == NULL, , "Invalid parameter!");
 403
 404         vconf_get_int(VCONFKEY_IDLE_LOCK_STATE, &status);
 405
 406         DBG("indicator_clock_lock_state_cb(%d)",status);
 407
 408         if(status==VCONFKEY_IDLE_UNLOCK && battery_charging==1)
 409         {
 410                 battery_charging_first = 1;
 411                 indicator_clock_display_battery_percentage(data,0);
 412         }
 413
 414 }
 415 static void indicator_clock_battery_precentage_setting_cb(keynode_t *node, void *data)
 416 {
 417         int ret = 0;
 418         int status = 0;
 419
 420         retif(data == NULL, , "Invalid parameter!");
 421
 422         ret = vconf_get_bool(VCONFKEY_SETAPPL_BATTERY_PERCENTAGE_BOOL, &status);
 423         if (ret != OK)
 424         {
 425                 ERR("Fail to get [%s: %d]",VCONFKEY_SETAPPL_BATTERY_PERCENTAGE_BOOL, ret);
 426                 return;
 427         }
 428         if(status==0)
 429         {
 430                 if (battery_charging_timer != NULL) {
 431                         ecore_timer_del(battery_charging_timer);
 432                         battery_charging_timer = NULL;
 433                 }
 434                 if (battery_timer != NULL) {
 435                         ecore_timer_del(battery_timer);
 436                         battery_timer = NULL;
 437                 }
 438                 indicator_clock_changed_cb(data);
 439         }
 440 }
 441
 442 static void indicator_clock_display_battery_percentage(void *data,int win_type )
 443 {
 444         int ret = FAIL;
 445         int status = 0;
 446         int battery_capa = 0;
 447         char buf[256] = {0,};
 448         char temp[256] = {0,};
 449         struct appdata *ad = (struct appdata *)data;
 450
 451
 452         if(battery_charging_timer!=NULL)
 453         {
 454                 INFO("30sec timer alive");
 455                 return;
 456         }
 457
 458         ret = vconf_get_bool(VCONFKEY_SETAPPL_BATTERY_PERCENTAGE_BOOL, &status);
 459         if (ret != OK)
 460                 ERR("Fail to get [%s: %d]",
 461                         VCONFKEY_SETAPPL_BATTERY_PERCENTAGE_BOOL, ret);
 462
 463         if(status)
 464         {
 465                 ret = vconf_get_int(VCONFKEY_SYSMAN_BATTERY_CAPACITY, &battery_capa);
 466                 if (ret != OK)
 467                 {
 468                         ERR("Fail to get [VCONFKEY_SYSMAN_BATTERY_CAPACITY:%d]", ret);
 469                         return;
 470                 }
 471                 if (battery_capa < 0)
 472                 {
 473                         INFO("Invalid Battery Capacity: %d", battery_capa);
 474                         return;
 475                 }
 476
 477                 INFO("Battery Capacity: %d", battery_capa);
 478
 479                 if (battery_capa > 100)
 480                         battery_capa = 100;
 481
 482                 snprintf(temp, sizeof(temp), "%d%%",battery_capa);
 483
 484                 snprintf(buf, sizeof(buf), LABEL_STRING, TIME_FONT_SIZE_BATTERY, temp);
 485
 486                 INFO("indicator_clock_display_battery_percentage %s", buf);
 487
 488                 indicator_part_text_emit_by_win(&(ad->win[win_type]),"elm.text.clock", buf);
 489
 490                 if(battery_charging == 1)
 491                 {
 492
 493                         battery_charging_timer =  ecore_timer_add(BATTERY_TIMER_INTERVAL_CHARGING, (void *)indicator_clock_battery_charging_stop_cb,data);
 494                 }
 495                 else
 496                 {
 497                         if (battery_timer != NULL) {
 498                                 ecore_timer_del(battery_timer);
 499                                 battery_timer = NULL;
 500                         }
 501
 502                         battery_timer =  ecore_timer_add(BATTERY_TIMER_INTERVAL, (void *)indicator_clock_battery_display_cb,data);
 503                 }
 504         }
 505
 506 }
 507
 508
 509 static int language_changed_cb(void *data)
 510 {
 511         DBG("language_changed_cb");
 512         indicator_clock_changed_cb(data);
 513         return OK;
 514 }
 515
 516 static int region_changed_cb(void *data)
 517 {
 518         DBG("region_changed_cb");
 519         indicator_clock_format_changed_cb(NULL, data);
 520         return OK;
 521 }
 522
 523 static int wake_up_cb(void *data)
 524 {
 525         int status = 0;
 526
 527         INFO("CLOCK wake_up_cb");
 528
 529         retif(data == NULL, FAIL, "Invalid parameter!");
 530
 531         vconf_get_int(VCONFKEY_IDLE_LOCK_STATE, &status);
 532
 533         DBG("wake_up_cb(%d)",status);
 534
 535         if(status==VCONFKEY_IDLE_UNLOCK && battery_charging==1)
 536         {
 537                 indicator_clock_display_battery_percentage(data,0);
 538         }
 539         else
 540         {
 541                 indicator_clock_changed_cb(data);
 542         }
 543         return OK;
 544 }
 545
 546 static int register_clock_module(void *data)
 547 {
 548         int r = 0, ret = -1;
 549
 550         retif(data == NULL, FAIL, "Invalid parameter!");
 551
 552         set_app_state(data);
 553
 554         ret = vconf_notify_key_changed(VCONFKEY_SYSTEM_TIME_CHANGED,
 555                                        indicator_clock_format_changed_cb, data);
 556         if (ret != OK) {
 557                 ERR("Fail: register VCONFKEY_SYSTEM_TIME_CHANGED");
 558                 r = r | ret;
 559         }
 560
 561         ret = vconf_notify_key_changed(VCONFKEY_REGIONFORMAT_TIME1224,
 562                                        indicator_clock_format_changed_cb, data);
 563         if (ret != OK) {
 564                 ERR("Fail: register VCONFKEY_REGIONFORMAT_TIME1224");
 565                 r = r | ret;
 566         }
 567
 568         ret = vconf_notify_key_changed(VCONFKEY_SETAPPL_TIMEZONE_INT,
 569                                        indicator_clock_format_changed_cb, data);
 570         if (ret != OK) {
 571                 ERR("Fail: register VCONFKEY_SETAPPL_TIMEZONE_INT");
 572                 r = r | ret;
 573         }
 574
 575         ret = vconf_notify_key_changed(VCONFKEY_PM_STATE, indicator_clock_pm_state_change_cb, (void *)data);
 576
 577         if (ret != OK) {
 578                 ERR("Fail: register VCONFKEY_PM_STATE");
 579                 r = r | ret;
 580         }
 581
 582         ret = vconf_notify_key_changed(VCONFKEY_BATTERY_DISP_STATE,
 583                                        indicator_clock_battery_disp_changed_cb, data);
 584         if (ret != OK) {
 585                 ERR("Fail: register VCONFKEY_SETAPPL_TIMEZONE_INT");
 586                 r = r | ret;
 587         }
 588
 589         ret = vconf_notify_key_changed(VCONFKEY_SYSMAN_BATTERY_CAPACITY,
 590                                        indicator_clock_battery_capacity_cb, data);
 591         if (ret != OK) {
 592                 ERR("Failed to register callback!");
 593                 r = r | ret;
 594         }
 595
 596         ret = vconf_notify_key_changed(VCONFKEY_SYSMAN_BATTERY_CHARGE_NOW,
 597                                        indicator_clock_charging_now_cb, data);
 598         if (ret != OK) {
 599                 ERR("Failed to register callback!");
 600                 r = r | ret;
 601         }
 602
 603         ret = vconf_notify_key_changed(VCONFKEY_SYSMAN_USB_STATUS,
 604                                        indicator_clock_usb_cb, data);
 605         if (ret != OK) {
 606                 ERR("Failed to register callback!");
 607                 r = r | ret;
 608         }
 609
 610
 611         ret = vconf_notify_key_changed(VCONFKEY_IDLE_LOCK_STATE,
 612                                        indicator_clock_lock_state_cb, data);
 613         if (ret != OK) {
 614                 ERR("Failed to register callback!");
 615                 r = r | ret;
 616         }
 617
 618         ret = vconf_notify_key_changed(VCONFKEY_SETAPPL_BATTERY_PERCENTAGE_BOOL,
 619                                         indicator_clock_battery_precentage_setting_cb, data);
 620         if (ret != OK) {
 621                 ERR("Failed to register callback!");
 622                 r = r | ret;
 623         }
 624
 625         indicator_clock_format_changed_cb(NULL, data);
 626
 627         return r;
 628 }
 629
 630 static int unregister_clock_module(void)
 631 {
 632         int ret;
 633
 634         ret = vconf_ignore_key_changed(VCONFKEY_SYSTEM_TIME_CHANGED,
 635                                                indicator_clock_format_changed_cb);
 636         if (ret != OK)
 637                 ERR("Fail: unregister VCONFKEY_SYSTEM_TIME_CHANGED");
 638
 639         ret = vconf_ignore_key_changed(VCONFKEY_REGIONFORMAT_TIME1224,
 640                                        indicator_clock_format_changed_cb);
 641         if (ret != OK)
 642                 ERR("Fail: unregister VCONFKEY_REGIONFORMAT_TIME1224");
 643
 644         ret = vconf_ignore_key_changed(VCONFKEY_SETAPPL_TIMEZONE_INT,
 645                                        indicator_clock_format_changed_cb);
 646         if (ret != OK)
 647                 ERR("Fail: unregister VCONFKEY_SETAPPL_TIMEZONE_INT");
 648
 649         ret = vconf_ignore_key_changed(VCONFKEY_PM_STATE,
 650                                                indicator_clock_battery_disp_changed_cb);
 651         if (ret != OK)
 652                 ERR("Fail: unregister VCONFKEY_PM_STATE");
 653
 654         ret = vconf_ignore_key_changed(VCONFKEY_BATTERY_DISP_STATE,
 655                                                indicator_clock_pm_state_change_cb);
 656         if (ret != OK)
 657                 ERR("Fail: unregister VCONFKEY_BATTERY_DISP_STATE");
 658
 659         ret = vconf_ignore_key_changed(VCONFKEY_SYSMAN_BATTERY_CAPACITY,
 660                                                indicator_clock_battery_capacity_cb);
 661         if (ret != OK)
 662                 ERR("Fail: unregister VCONFKEY_SYSMAN_BATTERY_CHARGE_NOW");
 663
 664         ret = vconf_ignore_key_changed(VCONFKEY_SYSMAN_BATTERY_CHARGE_NOW,
 665                                                indicator_clock_charging_now_cb);
 666         if (ret != OK)
 667                 ERR("Fail: unregister VCONFKEY_SYSMAN_BATTERY_CHARGE_NOW");
 668
 669         ret = vconf_ignore_key_changed(VCONFKEY_SYSMAN_USB_STATUS,
 670                                                indicator_clock_usb_cb);
 671         if (ret != OK)
 672                 ERR("Fail: unregister VCONFKEY_SYSMAN_BATTERY_CHARGE_NOW");
 673
 674
 675         ret = vconf_ignore_key_changed(VCONFKEY_IDLE_LOCK_STATE,
 676                                                indicator_clock_lock_state_cb);
 677         if (ret != OK)
 678                 ERR("Fail: unregister VCONFKEY_SYSMAN_BATTERY_CHARGE_NOW");
 679
 680         ret = vconf_ignore_key_changed(VCONFKEY_SETAPPL_BATTERY_PERCENTAGE_BOOL,
 681                                                indicator_clock_battery_precentage_setting_cb);
 682         if (ret != OK)
 683                 ERR("Fail: unregister VCONFKEY_SYSMAN_BATTERY_CHARGE_NOW");
 684
 685         if (timer != NULL) {
 686                 ecore_timer_del(timer);
 687                 timer = NULL;
 688         }
 689
 690         if (battery_timer != NULL) {
 691                 ecore_timer_del(battery_timer);
 692                 battery_timer = NULL;
 693         }
 694
 695         if (battery_charging_timer != NULL) {
 696                 ecore_timer_del(battery_charging_timer);
 697                 battery_charging_timer = NULL;
 698         }
 699
 700         return OK;
 701 }
 702
 703 void indicator_get_time_by_region(char* output,void *data)
 704 {
 705         retif(data == NULL, , "Data parameter is NULL");
 706         retif(output == NULL, , "output parameter is NULL");
 707
 708
 709         UChar customSkeleton[CLOCK_STR_LEN] = { 0, };
 710         UErrorCode status = U_ZERO_ERROR;
 711         UDateFormat *formatter = NULL;
 712
 713         UChar bestPattern[CLOCK_STR_LEN] = { 0, };
 714         UChar formatted[CLOCK_STR_LEN] = { 0, };
 715
 716         char bestPatternString[CLOCK_STR_LEN] = { 0, };
 717         char formattedString[CLOCK_STR_LEN] = { 0, };
 718
 719         UDateTimePatternGenerator *pattern_generator = NULL;
 720
 721         char *time_skeleton = "hhmm";
 722
 723         char *locale = vconf_get_str(VCONFKEY_REGIONFORMAT);
 724         if (locale == NULL) {
 725                 DBG("[Error] get value of VCONFKEY_REGIONFORMAT fail.");
 726         }
 727
 728         u_uastrncpy(customSkeleton, time_skeleton, strlen(time_skeleton));
 729
 730         pattern_generator = udatpg_open(locale, &status);
 731
 732         int32_t bestPatternCapacity = (int32_t) (sizeof(bestPattern) / sizeof((bestPattern)[0]));
 733         (void)udatpg_getBestPattern(pattern_generator, customSkeleton,
 734                                     u_strlen(customSkeleton), bestPattern,
 735                                     bestPatternCapacity, &status);
 736
 737         u_austrcpy(bestPatternString, bestPattern);
 738         u_uastrcpy(bestPattern,"a");
 739
 740         if(bestPatternString[0] == 'a')
 741         {
 742                 apm_position = 0;
 743         }
 744         else
 745         {
 746                 apm_position = 1;
 747         }
 748
 749         UDate date = ucal_getNow();
 750         formatter = udat_open(UDAT_IGNORE, UDAT_IGNORE, locale, NULL, -1, bestPattern, -1, &status);
 751         int32_t formattedCapacity = (int32_t) (sizeof(formatted) / sizeof((formatted)[0]));
 752         (void)udat_format(formatter, date, formatted, formattedCapacity, NULL, &status);
 753         u_austrcpy(formattedString, formatted);
 754
 755         DBG("DATE & TIME is %s %s %d %s", locale, formattedString, u_strlen(formatted), bestPatternString);
 756
 757         apm_length = u_strlen(formatted);
 758
 759         udatpg_close(pattern_generator);
 760
 761         udat_close(formatter);
 762
 763         if(strlen(formattedString)<CLOCK_STR_LEN)
 764         {
 765                 strncpy(output,formattedString,strlen(formattedString));
 766         }
 767         else
 768         {
 769                 strncpy(output,formattedString,CLOCK_STR_LEN-1);
 770         }
 771
 772         return;
 773 }
 774
 775 static UChar *uastrcpy(const char *chars)
 776 {
 777         int len = 0;
 778         UChar *str = NULL;
 779         len = strlen(chars);
 780         str = (UChar *) malloc(sizeof(UChar) *(len + 1));
 781         if (!str)
 782                 return NULL;
 783         u_uastrcpy(str, chars);
 784         return str;
 785 }
 786
 787 static void ICU_set_timezone(const char *timezone)
 788 {
 789         if(timezone == NULL)
 790         {
 791                 ERR("TIMEZONE is NULL");
 792                 return;
 793         }
 794
 795         DBG("ICU_set_timezone = %s ", timezone);
 796         UErrorCode ec = U_ZERO_ERROR;
 797         UChar *str = uastrcpy(timezone);
 798
 799         ucal_setDefaultTimeZone(str, &ec);
 800         if (U_SUCCESS(ec)) {
 801                 DBG("ucal_setDefaultTimeZone() SUCCESS ");
 802         } else {
 803                 DBG("ucal_setDefaultTimeZone() FAILED : %s ",
 804                               u_errorName(ec));
 805         }
 806         free(str);
 807 }
 808
 809