src/setting-battery.c

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