src/setting-battery.c

   1 /*
   2  * Copyright (c) 2000 - 2013 Samsung Electronics Co., Ltd. All rights reserved.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (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://www.apache.org/licenses/LICENSE-2.0
   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 /*
  18  * setting-battery.c
  19  *
  20  *  Created on: Oct 12, 2013
  21  *      Author: min-hoyun
  22  */
  23 #include <vconf-keys.h>
  24 #include <ail.h>
  25 #include <aul.h>
  26 #include <vconf.h>
  27
  28 #include "setting-battery.h"
  29 #include "util.h"
  30
  31 Evas_Object* _create_battery_content2(void *data);
  32 static void _battery_percent_cb(void *data, Evas_Object *obj, void *event_info);
  33 static void _power_saving_cb(void *data, Evas_Object *obj, void *event_info);
  34
  35 static struct _battery_menu_item battery_menu_list[] = {
  36         { "IDS_ST_BODY_BATTERY_STATUS",                 DISABLE, _battery_status_cb },
  37         //{ "IDS_ST_BODY_BATTERY_PERCENTAGE_ABB",       DISABLE,        _battery_percent_cb },
  38         { "IDS_ST_MBODY_POWER_SAVER_ABB",       DISABLE,        _power_saving_cb }
  39 };
  40
  41 char * battery_icons[] = {
  42                 "b_setting_battery_01.png",
  43                 "b_setting_battery_02.png",
  44                 "b_setting_battery_03.png",
  45                 "b_setting_battery_04.png",
  46                 "b_setting_battery_05.png",
  47                 "b_setting_battery_06.png",
  48                 "b_setting_battery_07.png",
  49                 "b_setting_battery_08.png",
  50                 "b_setting_battery_09.png"
  51 };
  52
  53 char * battery_charging_icons[] = {
  54                 "b_setting_battery_charge_01.png",
  55                 "b_setting_battery_charge_02.png",
  56                 "b_setting_battery_charge_03.png",
  57                 "b_setting_battery_charge_04.png",
  58                 "b_setting_battery_charge_05.png",
  59                 "b_setting_battery_charge_06.png",
  60                 "b_setting_battery_charge_07.png",
  61                 "b_setting_battery_charge_08.png",
  62                 "b_setting_battery_charge_09.png"
  63 };
  64
  65 static char * power_saving_str[] = {
  66                 "IDS_ST_BODY_DISABLED_M_STATUS",
  67                 "IDS_EMAIL_BODY_ENABLED_M_STATUS"
  68 };
  69
  70 static appdata* temp_ad = NULL;
  71 static Ecore_Timer *pws_timer = NULL;
  72 static Evas_Object * g_pws_check = NULL;
  73 static Elm_Object_Item* pws_it = NULL;
  74
  75 static Eina_Bool _delete_timer(void * data)
  76 {
  77         DBG("_delete_timer");
  78         pws_timer = NULL;
  79         _power_saving_terminate_app(temp_ad);
  80
  81         return ECORE_CALLBACK_CANCEL;
  82 }
  83
  84 static void change_pws_key(keynode_t *key, void * data)
  85 {
  86         int mode_val = 0;
  87         vconf_get_int(VCONFKEY_SETAPPL_PSMODE, &mode_val);
  88
  89         if(mode_val)
  90         {
  91                 DBG("change_pws_key is power saving");
  92                 if(pws_timer)
  93                 {
  94                         ecore_timer_del(pws_timer);
  95                         pws_timer = NULL;
  96                 }
  97                 pws_timer = ecore_timer_add(1.0, (Ecore_Task_Cb) _delete_timer, NULL);
  98         }
  99
 100         else
 101         {
 102                 DBG("change_pws_key is normal");
 103         }
 104 }
 105
 106 void _initialize_battery()
 107 {
 108         battery_timer = NULL;
 109
 110         percent = 0;
 111         is_charging = false;
 112         prev_charging_state = false;
 113         is_alive = 0;
 114
 115         register_vconf_changing(VCONFKEY_SETAPPL_PSMODE, change_pws_key, NULL);
 116 }
 117
 118 Eina_Bool _clear_battery_list_cb(void *data, Elm_Object_Item *it)
 119 {
 120         return EINA_TRUE;
 121 }
 122
 123 void _clear_battery_cb(void *data , Evas *e, Evas_Object *obj, void *event_info)
 124 {
 125         if(battery_timer) {
 126                 ecore_timer_del(battery_timer);
 127                 battery_timer = NULL;
 128         }
 129         if(pws_timer)
 130         {
 131                 ecore_timer_del(pws_timer);
 132                 pws_timer = NULL;
 133         }
 134         percent = 0;
 135         is_charging = false;
 136         prev_charging_state = false;
 137         is_alive = 0;
 138
 139         g_pws_check = NULL;
 140         pws_it = NULL;
 141
 142         unregister_vconf_changing(VCONFKEY_SYSTEM_TIME_CHANGED, change_pws_key);
 143
 144         return;
 145 }
 146
 147 static int get_battery_img_index(int percent)
 148 {
 149         int index = 0;
 150
 151         if( percent > 0 && percent < 5 )
 152         {
 153                 index = 0;
 154         }
 155         else if( percent >= 5 && percent <= 10 )
 156         {
 157                 index = 1;
 158         }
 159         else if( percent >= 11 && percent <= 20 )
 160         {
 161                 index = 2;
 162         }
 163         else if( percent >= 21 && percent <= 34 )
 164         {
 165                 index = 3;
 166         }
 167         else if( percent >= 35 && percent <= 49 )
 168         {
 169                 index = 4;
 170         }
 171         else if( percent >= 50 && percent <= 64 )
 172         {
 173                 index = 5;
 174         }
 175         else if( percent >= 65 && percent <= 79 )
 176         {
 177                 index = 6;
 178         }
 179         else if( percent >= 80 && percent <= 94 )
 180         {
 181                 index = 7;
 182         }
 183         else if( percent >= 95 && percent <= 100 )
 184         {
 185                 index = 8;
 186         }
 187         return index;
 188 }
 189
 190 static int is_updated_battery_state() {
 191         int current_percent = 0;
 192         bool current_charging_state = false;
 193         char buf[1024];
 194
 195         if( device_battery_get_percent(&current_percent) != DEVICE_ERROR_NONE )
 196         {
 197                 DBG("Setting - Battery percent get error");
 198         }
 199
 200         if( device_battery_is_charging(&current_charging_state) != DEVICE_ERROR_NONE )
 201         {
 202                 DBG("Setting - Battery charging do not get. error");
 203         }
 204
 205         if( (current_percent != percent) || (current_charging_state != is_charging) ) {
 206                 percent = current_percent;
 207                 is_charging = current_charging_state;
 208
 209                 DBG("Setting - Updated battery state !! percent: %d, charging: %d", percent, is_charging);
 210
 211                 return TRUE;
 212         }
 213
 214         return FALSE;
 215 }
 216
 217 static int is_type_of_charging()
 218 {
 219         int status = 0;
 220
 221         vconf_get_int(VCONFKEY_SYSMAN_CHARGER_STATUS, &status);
 222
 223         if (status == VCONFKEY_SYSMAN_CHARGER_CONNECTED)
 224         {
 225                 vconf_get_int(VCONFKEY_SYSMAN_USB_STATUS, &status);
 226             if (status == VCONFKEY_SYSMAN_USB_AVAILABLE)
 227             {
 228                 return CHARGING_USB;
 229             }
 230         }
 231         return CHARGING_AC;
 232 }
 233
 234 static Evas_Object * create_icon(Evas_Object * parent, char * img_path)
 235 {
 236         if( img_path == NULL )
 237                 return NULL;
 238
 239         Evas_Object * icon = elm_image_add(parent);
 240         elm_image_file_set(icon, img_path, NULL);
 241         evas_object_size_hint_align_set(icon, EVAS_HINT_FILL, EVAS_HINT_FILL);
 242         evas_object_size_hint_weight_set(icon, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
 243
 244         return icon;
 245 }
 246
 247 static Eina_Bool _battery_timeout(void * data)
 248 {
 249         Evas_Object * layout = (Evas_Object*)data;
 250         if( layout == NULL ) {
 251                 return ECORE_CALLBACK_CANCEL;
 252         }
 253
 254         char buf[512];
 255         if( is_updated_battery_state() ) {
 256                 if( layout ) {
 257                         snprintf(buf, sizeof(buf)-1, "%s%c", ICU_NUM(percent), '\%');
 258                         char * temp_percent = strdup(buf);
 259                         elm_object_part_text_set(layout, "text1", temp_percent);
 260                         free(temp_percent);
 261
 262                         if( is_charging ) {
 263                                 snprintf(buf, sizeof(buf)-1, "%s%s", _("IDS_COM_BODY_CHARGING_GA"), (is_type_of_charging() == CHARGING_AC) ? "(AC)" : "(USB)");
 264                                 char * temp_charging_msg = strdup(buf);
 265                                 elm_object_part_text_set(layout, "text2", temp_charging_msg);
 266                                 free(temp_charging_msg);
 267                         }
 268                         else {
 269                                 elm_object_part_text_set(layout, "text2", _("IDS_ST_BODY_NOT_CHARGING_ABB"));
 270                         }
 271
 272                         int img_index = get_battery_img_index(percent);
 273                         if( ( img_index != image_index ) || (prev_charging_state != is_charging) ) {
 274                                 snprintf(buf, sizeof(buf)-1, "%s%s", IMG_DIR, (is_charging) ? battery_charging_icons[img_index] : battery_icons[img_index]);
 275
 276                                 Evas_Object * del_icon = elm_object_part_content_get(layout, "image");
 277                                 if( del_icon ) {
 278                                         evas_object_del(del_icon);
 279                                         del_icon = NULL;
 280                                 }
 281                                 elm_object_part_content_set(layout, "image", create_icon(layout, buf));
 282                         }
 283
 284                         prev_charging_state = is_charging;
 285
 286                         DBG("Setting - Update Battery Layout!!");
 287                 }
 288         }
 289
 290         DBG("Setting - check battery state!!");
 291
 292         return ECORE_CALLBACK_RENEW;
 293 }
 294
 295 void _start_timer_for_update(Evas_Object * obj)
 296 {
 297         is_alive = 1;
 298         if (battery_timer)
 299         {
 300                 ecore_timer_del(battery_timer);
 301                 battery_timer = NULL;
 302         }
 303         battery_timer = ecore_timer_add(1.0, (Ecore_Task_Cb)_battery_timeout, obj);
 304 }
 305
 306 void _battery_lang_changed(void *data, Evas_Object *obj, void *event_info)
 307 {
 308         DBG("Setting - _battery_lang_changed is called!");
 309
 310         char buf[512];
 311         if( obj )
 312         {
 313                 snprintf(buf, sizeof(buf)-1, "%s%c", ICU_NUM(percent), '\%');
 314                 char * temp_percent = strdup(buf);
 315                 elm_object_part_text_set(obj, "text1", temp_percent);
 316                 free(temp_percent);
 317
 318                 if( is_charging )
 319                 {
 320                         snprintf(buf, sizeof(buf)-1, "%s%s", _("IDS_COM_BODY_CHARGING_GA"), (is_type_of_charging() == CHARGING_AC) ? "(AC)" : "(USB)");
 321                         char * temp_charging_msg = strdup(buf);
 322                         elm_object_part_text_set(obj, "text2", temp_charging_msg);
 323                         free(temp_charging_msg);
 324                 }
 325                 else
 326                 {
 327                         elm_object_part_text_set(obj, "text2", _("IDS_ST_BODY_NOT_CHARGING_ABB"));
 328                 }
 329         }
 330 }
 331
 332 Evas_Object* _create_battery_content2(void *data)
 333 {
 334         Evas_Object *layout, *icon;
 335         char buf[1024];
 336         int img_index = 0;
 337         appdata *ad = (appdata *)data;
 338         if (ad == NULL)
 339                 return NULL;
 340
 341         layout = elm_layout_add(ad->nf);
 342         elm_layout_file_set(layout, EDJE_PATH, "setting-test/battery");
 343         evas_object_size_hint_weight_set (layout, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
 344         evas_object_size_hint_align_set(layout, EVAS_HINT_FILL, EVAS_HINT_FILL);
 345         evas_object_smart_callback_add(layout, "language,changed", _battery_lang_changed, NULL);
 346
 347         if( device_battery_get_percent(&percent) != DEVICE_ERROR_NONE )
 348         {
 349                 DBG("Setting - Battery percent get error");
 350         }
 351         snprintf(buf, sizeof(buf)-1, "%s%c", ICU_NUM(percent), '\%');
 352
 353         elm_object_part_text_set(layout, "text1", buf);
 354
 355         if( device_battery_is_charging(&is_charging) != DEVICE_ERROR_NONE )
 356         {
 357                 DBG("Setting - Battery charging do not get. error");
 358         }
 359         char * charging_text = NULL;
 360         if( is_charging ) {
 361                 snprintf(buf, sizeof(buf)-1, "%s%s", _("IDS_COM_BODY_CHARGING_GA"), (is_type_of_charging() == CHARGING_AC) ? "(AC)" : "(USB)");
 362                 charging_text = strdup(buf);
 363         }
 364         elm_object_part_text_set(layout, "text2", ( is_charging ) ? charging_text : _("IDS_ST_BODY_NOT_CHARGING_ABB"));
 365         free(charging_text);
 366
 367         prev_charging_state = is_charging;
 368
 369         image_index = get_battery_img_index(percent);
 370
 371         snprintf(buf, sizeof(buf)-1, "%s%s", IMG_DIR, ( is_charging ) ? battery_charging_icons[image_index] : battery_icons[image_index]);
 372
 373         elm_object_part_content_set(layout, "image", create_icon(layout, buf));
 374
 375         _start_timer_for_update(layout);        // updating timer start!
 376
 377         return layout;
 378 }
 379
 380 Evas_Object *_battery_status_cb(void *data)
 381 {
 382         Evas_Object* layout = NULL;
 383         Elm_Object_Item *nf_it = NULL;
 384         appdata *ad = data;
 385
 386         if( ad == NULL )
 387         {
 388                 DBG("Setting - ad is null");
 389                 return NULL;
 390         }
 391
 392         _initialize_battery();
 393         layout = _create_battery_content2(data);
 394         if(layout == NULL)
 395         {
 396                 DBG("%s", "battery cb - layout is null");
 397                 return NULL;;
 398         }
 399
 400         return layout;
 401         //nf_it = elm_naviframe_item_push(ad->nf, NULL, NULL, NULL, layout, NULL);
 402         //elm_naviframe_item_pop_cb_set(nf_it, _clear_battery_cb, ad);
 403         //elm_naviframe_item_title_enabled_set(nf_it, EINA_FALSE, EINA_FALSE);
 404 }
 405
 406 int _get_battery_percent_value()
 407 {
 408         int value = 0;
 409         if (vconf_get_bool(VCONFKEY_SETAPPL_BATTERY_PERCENTAGE_BOOL, &value) != 0) {
 410                 ERR("error get vconf value!!");
 411         }
 412         return value;
 413 }
 414
 415 int _set_battery_percent_value(int value)
 416 {
 417         if (vconf_set_bool(VCONFKEY_SETAPPL_BATTERY_PERCENTAGE_BOOL, value) != 0) {
 418                 ERR("error set vconf value!!");
 419                 return FALSE;
 420         }
 421         return TRUE;
 422 }
 423
 424 void _battery_percent_cb(void *data, Evas_Object *obj, void *event_info)
 425 {
 426         elm_genlist_item_selected_set((Elm_Object_Item *)event_info, EINA_FALSE);
 427
 428         _set_battery_percent_value(!_get_battery_percent_value());
 429
 430         elm_genlist_item_update((Elm_Object_Item *)event_info);
 431 }
 432
 433 int _power_saving_runapp_info_get(const aul_app_info *ainfo, void *data)
 434 {
 435         DBG("_power_saving_runapp_info_get");
 436         ail_appinfo_h handle;
 437         ail_error_e ret;
 438
 439         bool valb;
 440
 441         if(ainfo == NULL)
 442                 return -1;
 443         if(ainfo->pid <= 0)
 444                 return -1;
 445         if(ainfo->pkg_name == NULL)
 446                 return 0;
 447
 448         /* �� PID ���͸� */
 449         /*
 450         if(ainfo->pid == getpid()) {
 451                 return 0;
 452         }
 453         */
 454         ret = ail_get_appinfo(ainfo->pkg_name, &handle);
 455
 456         if(ret != AIL_ERROR_OK){
 457                 return -1;
 458         }
 459         /* APP�� TASKMANAGE üũ */
 460         ret = ail_appinfo_get_bool(handle, AIL_PROP_X_SLP_TASKMANAGE_BOOL, &valb);
 461         if(valb == 0) {
 462         ret = ail_destroy_appinfo(handle);
 463                 return 0;
 464         }
 465         /* ���� */
 466         aul_terminate_pid(ainfo->pid);
 467
 468         ret = ail_destroy_appinfo(handle);
 469         return 0;
 470 }
 471 /*
 472 static Eina_Bool _pws_timer(void *data)
 473 {
 474         DBG("_pws_timer");
 475         appdata *ad = (appdata *) data;
 476         if( ad == NULL )
 477                 return ECORE_CALLBACK_CANCEL;
 478
 479         if(ad->win_main)
 480         {
 481                 evas_object_del(ad->win_main);
 482                 ad->win_main = NULL;
 483         }
 484         pws_timer = NULL;
 485         return ECORE_CALLBACK_CANCEL;
 486 }
 487 */
 488 int _power_saving_terminate_app(void *data)
 489 {
 490         int ret = AUL_R_ERROR;
 491         appdata *ad = (appdata *) data;
 492
 493         if(ad->win_main)
 494         {
 495                 evas_object_del(ad->win_main);
 496                 ad->win_main = NULL;
 497         }
 498
 499         ret = aul_app_get_running_app_info(_power_saving_runapp_info_get, NULL);
 500         if(ret != AUL_R_OK) {
 501                 DBG("aul_app_get_running_app_info() failed");
 502         }
 503
 504         return 0;
 505 }
 506
 507 int _get_power_saving_status()
 508 {
 509         int value = 0;
 510         if (vconf_get_int(VCONFKEY_SETAPPL_PSMODE, &value) != 0) {
 511                 ERR("error get vconf value!!");
 512         }
 513         if(value)
 514                 battery_menu_list[BATT_MENU_POWER_SAVING].is_enable = ENABLE;
 515         else
 516                 battery_menu_list[BATT_MENU_POWER_SAVING].is_enable = DISABLE;
 517         return value;
 518 }
 519
 520 int _set_power_saving_status(int value)
 521 {
 522         if (vconf_set_int(VCONFKEY_SETAPPL_PSMODE, value) != 0) {
 523                 ERR("error set vconf value!!");
 524                 return FALSE;
 525         }
 526         if(value){
 527                 battery_menu_list[BATT_MENU_POWER_SAVING].is_enable = ENABLE;
 528         }
 529         else
 530                 battery_menu_list[BATT_MENU_POWER_SAVING].is_enable = DISABLE;
 531         return TRUE;
 532 }
 533
 534 static void _power_saving_cb(void *data, Evas_Object *obj, void *event_info)
 535 {
 536         elm_genlist_item_selected_set((Elm_Object_Item *)event_info, EINA_FALSE);
 537
 538         int pws_status; //int , 0:normal, 3:pws on
 539         pws_status = _get_power_saving_status();
 540
 541         if(pws_status)  {
 542                 //on -> off
 543                 DBG("psmode state [%d]", pws_status);
 544                 _set_power_saving_status(SETTING_PSMODE_NORMAL);
 545         }
 546         else if(!pws_status){
 547                 //off -> on
 548                 _pws_popup_cb(data, obj, event_info);
 549         }
 550
 551         elm_genlist_item_update((Elm_Object_Item *)event_info);
 552 }
 553
 554 char *_gl_battery_title_get(void *data, Evas_Object *obj, const char *part)
 555 {
 556         char buf[1024];
 557         Item_Data *id = data;
 558         int index = id->index;
 559         if (!strcmp(part, "elm.text.1") || !strcmp(part, "elm.text")) {
 560                 snprintf(buf, sizeof(buf)-1, "%s", _(battery_menu_list[index].name));
 561         }
 562         else if( !strcmp(part, "elm.text.2") && index == BATT_MENU_POWER_SAVING ){
 563                 snprintf(buf, sizeof(buf)-1, "%s", _(power_saving_str[battery_menu_list[index].is_enable]));
 564         }
 565         return strdup(buf);
 566 }
 567
 568
 569 Evas_Object *_gl_battery_check_get(void *data, Evas_Object *obj, const char *part)
 570 {
 571         Evas_Object *check = NULL;
 572
 573         Item_Data *id = data;
 574         int index = id->index;
 575
 576         if (!strcmp(part, "elm.icon")) {
 577                 check = elm_check_add(obj);
 578                 if(index == BATT_MENU_POWER_SAVING){
 579                         elm_check_state_set(check, (_get_power_saving_status()) ? EINA_TRUE : EINA_FALSE);
 580                         g_pws_check = check;
 581                 }
 582                 else{
 583                         elm_check_state_set(check, (_get_battery_percent_value()) ? EINA_TRUE : EINA_FALSE);
 584                 }
 585                 evas_object_size_hint_align_set(check, EVAS_HINT_FILL, EVAS_HINT_FILL);
 586                 evas_object_size_hint_weight_set(check, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
 587
 588         }
 589
 590         return check;
 591 }
 592
 593 void _gl_battery_del(void *data, Evas_Object *obj)
 594 {
 595         Item_Data *id = data;
 596         if (id)
 597                 free(id);
 598 }
 599
 600 Evas_Object* _create_battery_list(void *data)
 601 {
 602         appdata *ad = data;
 603
 604         if (!ad) {
 605                 ERR("appdata is null!!");
 606                 return NULL;
 607         }
 608
 609         Evas_Object *genlist = NULL;
 610         Evas_Object *layout = NULL;
 611         struct _battery_menu_item *menu_list = NULL;
 612         int idx = 0;
 613
 614         temp_ad = ad;
 615
 616         Elm_Genlist_Item_Class *itc = NULL;
 617
 618         Elm_Genlist_Item_Class *itc_1text = elm_genlist_item_class_new();
 619         itc_1text->item_style = "1text";
 620         itc_1text->func.text_get = _gl_battery_title_get;
 621         itc_1text->func.del = _gl_battery_del;
 622
 623         Elm_Genlist_Item_Class *itc_2text_1icon = elm_genlist_item_class_new();
 624         itc_2text_1icon->item_style = "2text.1icon.1";
 625         itc_2text_1icon->func.text_get = _gl_battery_title_get;
 626         itc_2text_1icon->func.content_get = _gl_battery_check_get;
 627         itc_2text_1icon->func.del = _gl_battery_del;
 628
 629         layout = elm_layout_add(ad->nf);
 630         elm_layout_file_set(layout, EDJE_PATH, "setting/genlist/layout");
 631         evas_object_size_hint_weight_set(layout, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
 632
 633         genlist = elm_genlist_add(layout);
 634         elm_genlist_mode_set(genlist, ELM_LIST_COMPRESS);
 635
 636         menu_list = battery_menu_list;
 637
 638         for (idx = 0; idx < sizeof(battery_menu_list) / sizeof(struct _battery_menu_item); idx++) {
 639                 if (idx == BATT_MENU_POWER_SAVING) {
 640                         itc = itc_2text_1icon;
 641                 }
 642                 else if (idx == BATT_MENU_STATUS){
 643                         itc = itc_1text;
 644                 }
 645
 646                 Item_Data *id = calloc(sizeof(Item_Data), 1);
 647                 id->index = idx;
 648                 id->item = elm_genlist_item_append(
 649                                 genlist,                // genlist object
 650                                 itc,                    // item class
 651                                 id,                     // data
 652                                 NULL,
 653                                 ELM_GENLIST_ITEM_NONE,
 654                                 menu_list[idx].func,    // call back
 655                                 ad);
 656
 657                 if(idx == BATT_MENU_POWER_SAVING)
 658                 {
 659                         pws_it = id->item;
 660                 }
 661         }
 662
 663         elm_genlist_item_class_free(itc_2text_1icon);
 664         //elm_genlist_item_class_free(itc_1text_1icon);
 665         elm_genlist_item_class_free(itc_1text);
 666         itc = NULL;
 667
 668         elm_object_part_content_set(layout, "elm.genlist", genlist);
 669
 670         return layout;
 671 }
 672
 673 static void _pws_cancel_cb(void *data, Evas_Object *obj, void *event_info)
 674 {
 675         appdata *ad = (appdata *) data;
 676         if( ad == NULL )
 677                 return;
 678
 679         if (ad->popup) {
 680                 evas_object_del(data);
 681                 ad->popup = NULL;
 682         }
 683 }
 684
 685 static void _pws_ok_cb(void *data, Evas_Object *obj, void *event_info)
 686 {
 687         appdata *ad = data;
 688
 689         if( ad == NULL )
 690         {
 691                 DBG("%s", "_disable_emergency_ok_cb : appdata is null");
 692                 return;
 693         }
 694
 695         if (ad->popup) {
 696                 evas_object_del(data);
 697                 ad->popup = NULL;
 698         }
 699
 700         if(pws_it){
 701                 battery_menu_list[BATT_MENU_POWER_SAVING].is_enable = ENABLE;
 702                 elm_genlist_item_fields_update( pws_it, "elm.text.2", ELM_GENLIST_ITEM_FIELD_TEXT);
 703                 elm_check_state_set(g_pws_check, EINA_TRUE);
 704         }
 705         _set_power_saving_status(SETTING_PSMODE_WEARABLE);
 706 }
 707
 708 void _pws_popup_cb(void *data, Evas_Object *obj, void *event_info)
 709 {
 710         Evas_Object *popup = NULL;
 711         Evas_Object *btn = NULL;
 712         Evas_Object *scroller = NULL;
 713         Evas_Object *label = NULL;
 714
 715         appdata *ad = (appdata *) data;
 716         if( ad == NULL )
 717                 return;
 718
 719         popup = elm_popup_add(ad->nf);
 720         evas_object_size_hint_weight_set(popup, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
 721         elm_object_part_text_set(popup, "title,text", _("IDS_ST_MBODY_POWER_SAVER_ABB"));
 722
 723         ad->popup = popup;
 724
 725         scroller = elm_scroller_add(popup);
 726         evas_object_size_hint_weight_set(scroller, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
 727         elm_object_style_set(scroller, "effect");
 728         elm_object_content_set(popup, scroller);
 729         evas_object_show(scroller);
 730
 731         label = elm_label_add(scroller);
 732         elm_object_style_set(label, "popup/default");
 733         elm_label_line_wrap_set(label, ELM_WRAP_MIXED);
 734
 735         char buf[1024];
 736
 737         char * font_size_frame = "<font_size=34>%s</font_size>";
 738         snprintf(buf, sizeof(buf)-1, font_size_frame, _("IDS_ST_POP_POWER_SAVER_WILL_BE_ENABLED_THIS_WILL_LIMIT_THE_MAXIMUM_PERFORMANCE_OF_THE_CPU_TURN_OFF_BLUETOOTH_AND_A_LOWER_SCREEN_POWER_LEVEL_WILL_BE_USED_MSG"));
 739
 740         char *txt = strdup(buf);
 741         elm_object_text_set(label, txt);
 742         free(txt);
 743         evas_object_size_hint_weight_set(label, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
 744         evas_object_size_hint_align_set(label, EVAS_HINT_FILL, EVAS_HINT_FILL);
 745         elm_object_content_set(scroller, label);
 746         evas_object_show(label);
 747
 748         ea_object_event_callback_add(popup, EA_CALLBACK_BACK, setting_popup_back_cb, ad);
 749
 750         btn = elm_button_add(popup);
 751         elm_object_style_set(btn, "popup");
 752         evas_object_size_hint_weight_set(btn, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
 753         elm_object_text_set(btn, _("IDS_ST_BUTTON_CANCEL_ABB2"));
 754         elm_object_part_content_set(popup, "button1", btn);
 755         evas_object_smart_callback_add(btn, "clicked", _pws_cancel_cb, popup);
 756
 757         btn = elm_button_add(popup);
 758         elm_object_style_set(btn, "popup");
 759         evas_object_size_hint_weight_set(btn, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
 760         elm_object_text_set(btn, _("IDS_WNOTI_BUTTON_OK_ABB2"));
 761         elm_object_part_content_set(popup, "button2", btn);
 762         evas_object_smart_callback_add(btn, "clicked", _pws_ok_cb, popup);
 763
 764         evas_object_show(popup);
 765 }
 766
 767