src/setting-battery.c

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