src/setting-safety.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-safety.c
  13  *
  14  *  Created on: Jan 14, 2014
  15  *      Author: min-hoyun
  16  */
  17
  18 #include "setting-safety.h"
  19 #include "util.h"
  20 #include "setting_debug.h"
  21 #include "setting_data_vconf.h"
  22
  23
  24 static struct _safety_menu_item safety_menu_list[] = {
  25         { "IDS_ST_MBODY_ULTRA_POWER_SAVING_MODE",               NULL,   _emergency_mode_cb },
  26 //      { "Trauma",                             NULL,             _trauma_cb               },
  27 //      { "No activity",                NULL,             _no_activity_cb    },
  28 //      { "Set interval",               NULL,             _set_interval_cb   },
  29         { "IDS_ST_MBODY_HELP",                                  NULL,             _help_cb                 }
  30 };
  31
  32 static struct _set_interval_menu_item interval_menu_list[] = {
  33         { "Trauma",             "Warning %s",           _trauma_interval_cb      },
  34         { "No activity",        "Warning %s",           _no_activity_interval_cb }
  35 };
  36
  37 static struct _interval_trauma_menu_item interval_trauma_time_arr[] = {
  38                 { "After %s seconds", "30" },
  39                 { "After %s minute" , "1"  },
  40                 { "After %s minutes", "5"  },
  41                 { "After %s minutes", "10" },
  42                 { "After %s minutes", "20" },
  43 };
  44
  45 static char * interval_no_activity_hour_arr[] = {
  46                 "6", "12", "24", "48"
  47 };
  48
  49
  50 static Safety_Data safety_data;
  51 static Evas_Object * g_safety_genlist = NULL;
  52
  53 /*  */
  54 static void _emergency_mode_vconf_changed_cb(keynode_t * key, void * data);
  55
  56
  57 void initialize_safety()
  58 {
  59         DBG("initialize safety");
  60
  61         safety_data.g_safety_genlist = NULL;
  62         safety_data.temp_ad = NULL;
  63
  64         safety_data.interval_no_activity = 0;
  65         safety_data.interval_trauma = 0;
  66         safety_data.is_enable_no_activity = 0;
  67         safety_data.is_enable_trauma = 0;
  68         safety_data.is_support_emergency = 0;
  69
  70         vconf_get_bool(VCONFKEY_SETAPPL_EMERGENCY_STATUS_BOOL, &safety_data.is_enable_emergency_mode);
  71         register_vconf_changing(VCONFKEY_SETAPPL_EMERGENCY_STATUS_BOOL, _emergency_mode_vconf_changed_cb, NULL);
  72 }
  73
  74 Eina_Bool clear_safety_cb(void *data, Elm_Object_Item *it)
  75 {
  76         g_safety_genlist = NULL;
  77
  78         unregister_vconf_changing(VCONFKEY_SETAPPL_EMERGENCY_STATUS_BOOL, _emergency_mode_vconf_changed_cb);
  79
  80         return EINA_TRUE;
  81 }
  82
  83 static void _emergency_mode_vconf_changed_cb(keynode_t * key, void * data)
  84 {
  85         DBG("Setting - _emergency_mode_vconf_changed_cb() is called!");
  86
  87         int enable = vconf_keynode_get_bool(key);
  88
  89         if( enable == safety_data.is_enable_emergency_mode )
  90         {
  91                 DBG("Setting - this value was set from Setting!!");
  92                 return;
  93         }
  94         else
  95         {
  96                 DBG("Setting - this value is set from WMS");
  97
  98                 safety_data.is_enable_emergency_mode = enable;
  99                 if( g_safety_genlist )
 100                 {
 101                         elm_genlist_realized_items_update(g_safety_genlist);
 102                 }
 103         }
 104 }
 105
 106 static void _emergency_mode_cb(void *data, Evas_Object *obj, void *event_info)
 107 {
 108         DBG("emergency_mode_cb() is called.");
 109
 110         Elm_Object_Item* it = (Elm_Object_Item *)event_info;
 111         elm_genlist_item_selected_set(it, EINA_FALSE);
 112
 113         appdata *ad = data;
 114         if( ad == NULL )
 115         {
 116                 DBG("%s", "_emergency_mode_cb - ad is null");
 117                 return;
 118         }
 119
 120         if(safety_data.is_enable_emergency_mode)
 121         {
 122                 //confirm popup ok to off to device restart
 123                 _disable_emergency_popup_cb(data, obj, event_info);
 124         }
 125         else
 126         {
 127                 safety_data.is_enable_emergency_mode = !safety_data.is_enable_emergency_mode;
 128                 vconf_set_bool(VCONFKEY_SETAPPL_EMERGENCY_STATUS_BOOL, safety_data.is_enable_emergency_mode);
 129
 130                 //DBG("Setting - Emergency mode is %d", safety_data.is_enable_emergency_mode);
 131                 //elm_genlist_item_update(it);
 132                 elm_exit();     //gonna be changed regarding freezer
 133         }
 134 }
 135
 136 static void _trauma_cb(void *data, Evas_Object *obj, void *event_info)
 137 {
 138         DBG("trauma_cb() is called.");
 139
 140         Elm_Object_Item* it = (Elm_Object_Item *)event_info;
 141         elm_genlist_item_selected_set(it, EINA_FALSE);
 142
 143         appdata *ad = data;
 144         if( ad == NULL )
 145         {
 146                 DBG("%s", "_emergency_mode_cb - ad is null");
 147                 return;
 148         }
 149
 150         safety_data.is_enable_trauma = !safety_data.is_enable_trauma;
 151
 152         elm_genlist_item_update(it);
 153 }
 154
 155 static void _no_activity_cb(void *data, Evas_Object *obj, void *event_info)
 156 {
 157         DBG("_no_activity_cb() is called.");
 158
 159         Elm_Object_Item* it = (Elm_Object_Item *)event_info;
 160         elm_genlist_item_selected_set(it, EINA_FALSE);
 161
 162         appdata *ad = data;
 163         if( ad == NULL )
 164         {
 165                 DBG("%s", "_no_activity_cb - ad is null");
 166                 return;
 167         }
 168
 169         safety_data.is_enable_no_activity = !safety_data.is_enable_no_activity;
 170
 171         elm_genlist_item_update(it);
 172 }
 173
 174 static void _set_interval_cb(void *data, Evas_Object *obj, void *event_info)
 175 {
 176         DBG("_set_interval_cb() is called.");
 177
 178         elm_genlist_item_selected_set((Elm_Object_Item *)event_info, EINA_FALSE);
 179
 180         appdata *ad = data;
 181         if( ad == NULL )
 182         {
 183                 DBG("%s", "_set_interval_cb - ad is null");
 184                 return;
 185         }
 186
 187         show_interval_list(ad);
 188 }
 189
 190 static void _help_cb(void *data, Evas_Object *obj, void *event_info)
 191 {
 192         DBG("_help_cb() is called.");
 193
 194         elm_genlist_item_selected_set((Elm_Object_Item *)event_info, EINA_FALSE);
 195
 196         appdata *ad = data;
 197         if( ad == NULL )
 198         {
 199                 DBG("%s", "_help_cb - ad is null");
 200                 return;
 201         }
 202         _help_popup_cb(data, obj, event_info);
 203 }
 204
 205 static int _is_enable(int index)
 206 {
 207         int enable = DISABLE;
 208         switch(index)
 209         {
 210         case 0:
 211                 vconf_get_bool(VCONFKEY_SETAPPL_EMERGENCY_STATUS_BOOL, &safety_data.is_enable_emergency_mode);
 212                 enable = safety_data.is_enable_emergency_mode;
 213                 break;
 214         case 1:
 215                 enable = safety_data.is_enable_trauma;
 216                 break;
 217         case 2:
 218                 enable = safety_data.is_enable_no_activity;
 219                 break;
 220         case 3:
 221                 break;
 222         case 4:
 223                 break;
 224         }
 225         return enable;
 226 }
 227
 228 static char * _gl_safety_title_get(void *data, Evas_Object *obj, const char *part)
 229 {
 230         char buf[1024];
 231         Safety_Item_Data *id = data;
 232         int index = id->index;
 233
 234         if( !strcmp(part, "elm.text.1") || !strcmp(part, "elm.text") )
 235         {
 236                 snprintf(buf, sizeof(buf)-1, "%s", _(safety_menu_list[index].name));
 237         }
 238         else if( !strcmp(part, "elm.text.2") )
 239         {
 240                 snprintf(buf, sizeof(buf)-1, "%s", _is_enable(index) ? _("IDS_EMAIL_BODY_ENABLED_M_STATUS") : _("IDS_ST_BODY_DISABLED_M_STATUS"));
 241         }
 242         return strdup(buf);
 243 }
 244
 245 Evas_Object * _gl_safety_check_get(void *data, Evas_Object *obj, const char *part)
 246 {
 247         Evas_Object *check = NULL;
 248         appdata *ad = data;
 249
 250         Safety_Item_Data *id = data;
 251         int index = id->index;
 252
 253         if( !strcmp(part, "elm.icon") )
 254         {
 255                 check = elm_check_add(obj);
 256                 elm_check_state_set(check, _is_enable(index) ? EINA_TRUE : EINA_FALSE);
 257                 evas_object_size_hint_align_set(check, EVAS_HINT_FILL, EVAS_HINT_FILL);
 258                 evas_object_size_hint_weight_set(check, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
 259         }
 260
 261         return check;
 262 }
 263
 264 static void _gl_safety_del(void *data, Evas_Object *obj)
 265 {
 266         Safety_Item_Data *id = data;
 267         if (id)
 268         {
 269                 free(id);
 270         }
 271 }
 272
 273 Evas_Object *create_safety_list(void *data)
 274 {
 275         DBG("create_safety_list() is called.");
 276
 277         appdata *ad = data;
 278         if ( ad == NULL )
 279         {
 280                 ERR("appdata is null!!");
 281                 return NULL;
 282         }
 283
 284         Evas_Object *genlist = NULL;
 285         Evas_Object *layout = NULL;
 286         Elm_Object_Item *nf_it = NULL;
 287         Elm_Genlist_Item_Class *itc_temp = NULL;
 288         struct _safety_menu_item *menu_list = NULL;
 289         int idx = 0;
 290
 291         Elm_Genlist_Item_Class *itc_1text_1check = elm_genlist_item_class_new();
 292         itc_1text_1check->item_style = "1text.1icon.1";
 293         itc_1text_1check->func.text_get = _gl_safety_title_get;
 294         itc_1text_1check->func.content_get = _gl_safety_check_get;
 295         itc_1text_1check->func.del = _gl_safety_del;
 296
 297         Elm_Genlist_Item_Class *itc_2text_1check = elm_genlist_item_class_new();
 298         itc_2text_1check->item_style = "2text.1icon.1";
 299         itc_2text_1check->func.text_get = _gl_safety_title_get;
 300         itc_2text_1check->func.content_get = _gl_safety_check_get;
 301         itc_2text_1check->func.del = _gl_safety_del;
 302
 303         Elm_Genlist_Item_Class *itc_1text = elm_genlist_item_class_new();
 304         itc_1text->item_style = "1text";
 305         itc_1text->func.text_get = _gl_safety_title_get;
 306         itc_1text->func.del = _gl_safety_del;
 307
 308         layout = elm_layout_add(ad->nf);
 309         elm_layout_file_set(layout, EDJE_PATH, "setting/genlist/layout");
 310         evas_object_size_hint_weight_set(layout, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
 311
 312         genlist = elm_genlist_add(layout);
 313         elm_genlist_block_count_set(genlist, 14);
 314         elm_genlist_mode_set(genlist, ELM_LIST_COMPRESS);
 315
 316         menu_list = safety_menu_list;
 317
 318         int count = 0;
 319         count = sizeof(safety_menu_list) / sizeof(struct _safety_menu_item);
 320
 321         for (idx = 0; idx < count; idx++)
 322         {
 323                 if( idx == 0 )
 324                 {
 325                         itc_temp = itc_2text_1check;
 326                 }
 327 #if 0
 328                 else if( idx > 0 && idx < 3 )
 329                 {
 330                         itc_temp = itc_1text_1check;
 331                 }
 332 #endif
 333                 else
 334                 {
 335                         itc_temp = itc_1text;
 336                 }
 337
 338                 Safety_Item_Data *id = calloc(sizeof(Safety_Item_Data), 1);
 339                 id->index = idx;
 340                 id->item = elm_genlist_item_append(
 341                                 genlist,                // genlist object
 342                                 itc_temp,               // item class
 343                                 id,                     // data
 344                                 NULL,
 345                                 ELM_GENLIST_ITEM_NONE,
 346                                 menu_list[idx].func,    // call back
 347                                 ad);
 348                 if(idx == 0){
 349                         vconf_get_bool("db/setting/support_emergency", &safety_data.is_support_emergency);
 350                         //not support list for emergency mode
 351                         if(!safety_data.is_support_emergency)
 352                                 elm_object_item_disabled_set(id->item, EINA_TRUE);
 353                 }
 354         }
 355
 356         elm_genlist_item_class_free(itc_2text_1check);
 357         elm_genlist_item_class_free(itc_1text_1check);
 358         elm_genlist_item_class_free(itc_1text);
 359
 360         elm_object_part_content_set(layout, "elm.genlist", genlist);
 361
 362         return layout;
 363 }
 364
 365 static void _trauma_interval_cb(void *data, Evas_Object *obj, void *event_info)
 366 {
 367         DBG("_trauma_interval_cb() is called.");
 368
 369         elm_genlist_item_selected_set((Elm_Object_Item *)event_info, EINA_FALSE);
 370
 371         _show_interval_trauma_list(data);
 372 }
 373
 374 static void _no_activity_interval_cb(void *data, Evas_Object *obj, void *event_info)
 375 {
 376         DBG("_no_activity_interval_cb() is called.");
 377
 378         elm_genlist_item_selected_set((Elm_Object_Item *)event_info, EINA_FALSE);
 379
 380         _show_interval_no_activity_list(data);
 381 }
 382
 383 static char * _gl_interval_title_get(void *data, Evas_Object *obj, const char *part)
 384 {
 385         DBG("_gl_interval_title_get() is called.");
 386
 387         char buf[1024];
 388         Safety_Item_Data *id = data;
 389         int index = id->index;
 390
 391         if( !strcmp(part, "elm.text.1") )
 392         {
 393                 snprintf(buf, sizeof(buf)-1, "%s", interval_menu_list[index].title);
 394         }
 395         else if( !strcmp(part, "elm.text.2") )
 396         {
 397                 snprintf(buf, sizeof(buf)-1, interval_menu_list[index].sub_title, "after 30 seconds");
 398         }
 399         return strdup(buf);
 400 }
 401
 402 static void show_interval_list(void *data)
 403 {
 404         DBG("show_interval_list() is called.");
 405
 406         appdata *ad = data;
 407         if (!ad) {
 408                 ERR("appdata is null!!");
 409                 return;
 410         }
 411
 412         Evas_Object *genlist = NULL;
 413         Evas_Object *layout = NULL;
 414         Elm_Object_Item *nf_it = NULL;
 415         struct _set_interval_menu_item *menu_list = NULL;
 416         int idx = 0;
 417
 418         Elm_Genlist_Item_Class *itc_2text = elm_genlist_item_class_new();
 419         itc_2text->item_style = "2text";
 420         itc_2text->func.text_get = _gl_interval_title_get;
 421         itc_2text->func.del = _gl_safety_del;
 422
 423         layout = elm_layout_add(ad->nf);
 424         elm_layout_file_set(layout, EDJE_PATH, "setting/genlist/layout");
 425         evas_object_size_hint_weight_set(layout, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
 426
 427         genlist = elm_genlist_add(layout);
 428         elm_genlist_block_count_set(genlist, 14);
 429         elm_genlist_mode_set(genlist, ELM_LIST_COMPRESS);
 430
 431         menu_list = interval_menu_list;
 432
 433         int count = 0;
 434         count = sizeof(interval_menu_list) / sizeof(struct _set_interval_menu_item);
 435
 436         for (idx = 0; idx < count; idx++)
 437         {
 438                 Safety_Item_Data *id = calloc(sizeof(Safety_Item_Data), 1);
 439                 id->index = idx;
 440                 id->item = elm_genlist_item_append(
 441                                 genlist,                // genlist object
 442                                 itc_2text,              // item class
 443                                 id,                     // data
 444                                 NULL,
 445                                 ELM_GENLIST_ITEM_NONE,
 446                                 menu_list[idx].func,    // call back
 447                                 ad);
 448         }
 449
 450         elm_genlist_item_class_free(itc_2text);
 451
 452         elm_object_part_content_set(layout, "elm.genlist", genlist);
 453
 454         nf_it = elm_naviframe_item_push( ad->nf, NULL, NULL, NULL, layout, NULL );
 455         elm_naviframe_item_title_enabled_set(nf_it, EINA_FALSE, EINA_FALSE);
 456 }
 457
 458
 459 static char * _gl_interval_trauma_title_get(void *data, Evas_Object *obj, const char *part)
 460 {
 461         DBG("_gl_interval_trauma_title_get() is called.");
 462
 463         char buf[512];
 464         Safety_Item_Data *id = data;
 465
 466         if( !strcmp(part, "elm.text") )
 467         {
 468                 snprintf(buf, sizeof(buf)-1, interval_trauma_time_arr[id->index].str,
 469                                                                          interval_trauma_time_arr[id->index].time);
 470         }
 471         return strdup(buf);
 472 }
 473
 474 static Evas_Object * _gl_interval_trauma_ridio_get(void *data, Evas_Object *obj, const char *part)
 475 {
 476         DBG("_gl_interval_trauma_ridio_get() is called.");
 477
 478         Evas_Object *radio = NULL;
 479         Evas_Object *radio_main = evas_object_data_get(obj, "radio_main");
 480         Safety_Item_Data *id = data;
 481
 482         if( !strcmp(part, "elm.icon") )
 483         {
 484                 radio = elm_radio_add(obj);
 485                 elm_radio_state_value_set(radio, id->index);
 486                 evas_object_size_hint_align_set(radio, EVAS_HINT_FILL, EVAS_HINT_FILL);
 487                 evas_object_size_hint_weight_set(radio, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
 488                 elm_radio_group_add(radio, radio_main);
 489
 490                 if( safety_data.interval_trauma == id->index )
 491                 {
 492                         elm_radio_value_set(radio_main, safety_data.interval_trauma);
 493                 }
 494         }
 495         return radio;
 496 }
 497
 498 static void _trauma_interval_radio_cb(void *data, Evas_Object *obj, void *event_info)
 499 {
 500         DBG("_trauma_interval_radio_cb is called!");
 501
 502         elm_genlist_item_selected_set((Elm_Object_Item *)event_info, EINA_FALSE);
 503
 504         DBG("selected trauma interval : %d", (int*)data);
 505
 506         if( safety_data.temp_ad )
 507         {
 508                 elm_naviframe_item_pop(safety_data.temp_ad->nf);
 509         }
 510 }
 511
 512 static void _show_interval_trauma_list(void* data)
 513 {
 514         DBG("_show_interval_trauma_list() is called.");
 515
 516         appdata *ad = data;
 517         if( ad == NULL )
 518         {
 519                 ERR("%s", "_show_interval_trauma_list - appdata is null");
 520                 return;
 521         }
 522         Evas_Object *genlist  = NULL;
 523         Elm_Object_Item *nf_it = NULL;
 524         int idx;
 525
 526         safety_data.temp_ad = ad;
 527
 528         Elm_Genlist_Item_Class *itc = elm_genlist_item_class_new();
 529         itc->item_style = "1text.1icon.1";
 530         itc->func.text_get = _gl_interval_trauma_title_get;
 531         itc->func.content_get = _gl_interval_trauma_ridio_get;
 532         itc->func.del = _gl_safety_del;
 533
 534         genlist = elm_genlist_add(ad->nf);
 535         elm_genlist_mode_set(genlist, ELM_LIST_COMPRESS);
 536
 537         const int count = sizeof(interval_trauma_time_arr) / sizeof(interval_trauma_time_arr[0]);
 538         for( idx = 0; idx < count; idx++ )
 539         {
 540                 Safety_Item_Data *id = calloc(sizeof(Safety_Item_Data), 1);
 541                 id->index = idx;
 542                 id->item = elm_genlist_item_append( genlist,
 543                                                                                         itc,
 544                                                                                         id,
 545                                                                                         NULL,
 546                                                                                         ELM_GENLIST_ITEM_NONE,
 547                                                                                         _trauma_interval_radio_cb,
 548                                                                                         (void*)idx );
 549         }
 550
 551         ad->safety_interval_trauma_rdg = elm_radio_add(genlist);
 552         elm_radio_state_value_set(ad->safety_interval_trauma_rdg, count);
 553         elm_radio_value_set(ad->safety_interval_trauma_rdg, count);
 554
 555         evas_object_data_set(genlist, "radio_main", ad->safety_interval_trauma_rdg);
 556
 557         elm_genlist_item_class_free(itc);
 558
 559         nf_it = elm_naviframe_item_push(ad->nf, NULL, NULL, NULL, genlist, NULL);
 560         elm_naviframe_item_title_enabled_set(nf_it, EINA_FALSE, EINA_FALSE);
 561 }
 562
 563 static char * _gl_interval_no_activity_title_get(void *data, Evas_Object *obj, const char *part)
 564 {
 565         char buf[512];
 566         Safety_Item_Data *id = data;
 567
 568         if( !strcmp(part, "elm.text") )
 569         {
 570                 snprintf(buf, sizeof(buf)-1, "After %s hours", interval_no_activity_hour_arr[id->index]);
 571         }
 572         return strdup(buf);
 573 }
 574
 575 static Evas_Object * _gl_interval_no_activity_ridio_get(void *data, Evas_Object *obj, const char *part)
 576 {
 577         Evas_Object *radio = NULL;
 578         Evas_Object *radio_main = evas_object_data_get(obj, "radio_main");
 579         Safety_Item_Data *id = data;
 580
 581         if( !strcmp(part, "elm.icon") )
 582         {
 583                 radio = elm_radio_add(obj);
 584                 elm_radio_state_value_set(radio, id->index);
 585                 evas_object_size_hint_align_set(radio, EVAS_HINT_FILL, EVAS_HINT_FILL);
 586                 evas_object_size_hint_weight_set(radio, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
 587                 elm_radio_group_add(radio, radio_main);
 588
 589                 if( safety_data.interval_no_activity == id->index )
 590                 {
 591                         elm_radio_value_set(radio_main, safety_data.interval_no_activity);
 592                 }
 593         }
 594         return radio;
 595 }
 596
 597 static void _no_activity_interval_radio_cb(void *data, Evas_Object *obj, void *event_info)
 598 {
 599         DBG("_no_activity_interval_radio_cb is called!");
 600
 601         elm_genlist_item_selected_set((Elm_Object_Item *)event_info, EINA_FALSE);
 602
 603         DBG("selected no activity interval : %d", (int*)data);
 604
 605         if( safety_data.temp_ad )
 606         {
 607                 elm_naviframe_item_pop(safety_data.temp_ad->nf);
 608         }
 609 }
 610
 611 static void _show_interval_no_activity_list(void* data)
 612 {
 613         DBG("_show_interval_no_activity_list() is called.");
 614
 615         appdata *ad = data;
 616         if( ad == NULL )
 617         {
 618                 ERR("%s", "_show_interval_no_activity_list - appdata is null");
 619                 return;
 620         }
 621         Evas_Object *genlist  = NULL;
 622         Elm_Object_Item *nf_it = NULL;
 623         int idx;
 624
 625         safety_data.temp_ad = ad;
 626
 627         Elm_Genlist_Item_Class *itc = elm_genlist_item_class_new();
 628         itc->item_style = "1text.1icon.1";
 629         itc->func.text_get = _gl_interval_no_activity_title_get;
 630         itc->func.content_get = _gl_interval_no_activity_ridio_get;
 631         itc->func.del = _gl_safety_del;
 632
 633         genlist = elm_genlist_add(ad->nf);
 634         elm_genlist_mode_set(genlist, ELM_LIST_COMPRESS);
 635
 636         const int count = sizeof(interval_no_activity_hour_arr) / sizeof(interval_no_activity_hour_arr[0]);
 637         for( idx = 0; idx < count; idx++ )
 638         {
 639                 Safety_Item_Data *id = calloc(sizeof(Safety_Item_Data), 1);
 640                 id->index = idx;
 641                 id->item = elm_genlist_item_append( genlist,
 642                                                                                         itc,
 643                                                                                         id,
 644                                                                                         NULL,
 645                                                                                         ELM_GENLIST_ITEM_NONE,
 646                                                                                         _no_activity_interval_radio_cb,
 647                                                                                         (void*)idx );
 648         }
 649
 650         ad->safety_interval_no_activity_rdg = elm_radio_add(genlist);
 651         elm_radio_state_value_set(ad->safety_interval_no_activity_rdg, count);
 652         elm_radio_value_set(ad->safety_interval_no_activity_rdg, count);
 653
 654         evas_object_data_set(genlist, "radio_main", ad->safety_interval_no_activity_rdg);
 655
 656         elm_genlist_item_class_free(itc);
 657
 658         nf_it = elm_naviframe_item_push(ad->nf, NULL, NULL, NULL, genlist, NULL);
 659         elm_naviframe_item_title_enabled_set(nf_it, EINA_FALSE, EINA_FALSE);
 660 }
 661
 662 void _help_popup_cb(void *data, Evas_Object *obj, void *event_info)
 663 {
 664         Evas_Object *popup = NULL;
 665         Evas_Object *btn = NULL;
 666         Evas_Object *scroller = NULL;
 667         Evas_Object *label = NULL;
 668
 669         appdata *ad = (appdata *) data;
 670         if( ad == NULL )
 671                 return;
 672
 673         popup = elm_popup_add(ad->nf);
 674         evas_object_size_hint_weight_set(popup, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
 675         elm_object_part_text_set(popup, "title,text", _("IDS_ST_MBODY_HELP"));
 676
 677         ad->popup = popup;
 678
 679         scroller = elm_scroller_add(popup);
 680         evas_object_size_hint_weight_set(scroller, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
 681         elm_scroller_bounce_set(scroller, EINA_FALSE, EINA_TRUE);
 682         elm_scroller_policy_set(scroller, ELM_SCROLLER_POLICY_OFF, ELM_SCROLLER_POLICY_AUTO);
 683         elm_object_content_set(popup, scroller);
 684         evas_object_show(scroller);
 685
 686         label = elm_label_add(scroller);
 687         elm_object_style_set(label, "popup/default");
 688         elm_label_line_wrap_set(label, ELM_WRAP_MIXED);
 689         char *txt = elm_entry_utf8_to_markup(_("IDS_ST_BODY_THE_HOME_SCREEN_WILL_BE_CHANGED_TO_THE_BLACK_THEME_TO_REDUCE_BATTERY_CONSUMPTION_MSG"));
 690         elm_object_text_set(label, txt);
 691         free(txt);
 692         evas_object_size_hint_weight_set(label, EVAS_HINT_EXPAND, 0.0);
 693         evas_object_size_hint_align_set(label, EVAS_HINT_FILL, EVAS_HINT_FILL);
 694         elm_object_content_set(scroller, label);
 695         evas_object_show(label);
 696
 697         ea_object_event_callback_add(popup, EA_CALLBACK_BACK, setting_popup_back_cb, ad);
 698
 699         evas_object_show(popup);
 700 }
 701
 702 static void _disable_emergency_cancel_cb(void *data, Evas_Object *obj, void *event_info)
 703 {
 704         appdata *ad = (appdata *) data;
 705         if( ad == NULL )
 706                 return;
 707
 708         if (ad->popup) {
 709                 evas_object_del(data);
 710                 ad->popup = NULL;
 711         }
 712 }
 713
 714 static void _disable_emergency_ok_cb(void *data, Evas_Object *obj, void *event_info)
 715 {
 716         appdata *ad = data;
 717
 718         if( ad == NULL )
 719         {
 720                 DBG("%s", "_disable_emergency_ok_cb : appdata is null");
 721                 return;
 722         }
 723
 724         if (ad->popup) {
 725                 evas_object_del(data);
 726                 ad->popup = NULL;
 727         }
 728
 729         safety_data.is_enable_emergency_mode = EINA_FALSE;
 730         vconf_set_bool(VCONFKEY_SETAPPL_EMERGENCY_STATUS_BOOL, safety_data.is_enable_emergency_mode);
 731         vconf_set_int(VCONFKEY_SYSMAN_POWER_OFF_STATUS, VCONFKEY_SYSMAN_POWER_OFF_RESTART);
 732 }
 733
 734 void _disable_emergency_popup_cb(void *data, Evas_Object *obj, void *event_info)
 735 {
 736         Evas_Object *popup = NULL;
 737         Evas_Object *btn = NULL;
 738         Evas_Object *scroller = NULL;
 739         Evas_Object *label = NULL;
 740
 741         appdata *ad = (appdata *) data;
 742         if( ad == NULL )
 743                 return;
 744
 745         popup = elm_popup_add(ad->nf);
 746         evas_object_size_hint_weight_set(popup, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
 747         elm_object_part_text_set(popup, "title,text", _("Disable Ultra power saving mode"));
 748
 749         ad->popup = popup;
 750
 751         scroller = elm_scroller_add(popup);
 752         evas_object_size_hint_weight_set(scroller, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
 753         elm_object_content_set(popup, scroller);
 754         evas_object_show(scroller);
 755
 756         label = elm_label_add(scroller);
 757         elm_object_style_set(label, "popup/default");
 758         elm_label_line_wrap_set(label, ELM_WRAP_MIXED);
 759         char *txt = elm_entry_utf8_to_markup(_("IDS_ST_POP_TO_DISABLE_ULTRA_POWER_SAVING_MODE_YOUR_DEVICE_WILL_RESTART"));
 760         elm_object_text_set(label, txt);
 761         free(txt);
 762         evas_object_size_hint_weight_set(label, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
 763         evas_object_size_hint_align_set(label, EVAS_HINT_FILL, EVAS_HINT_FILL);
 764         elm_object_content_set(scroller, label);
 765         evas_object_show(label);
 766
 767         ea_object_event_callback_add(popup, EA_CALLBACK_BACK, setting_popup_back_cb, ad);
 768
 769         btn = elm_button_add(popup);
 770         elm_object_style_set(btn, "popup");
 771         evas_object_size_hint_weight_set(btn, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
 772         elm_object_text_set(btn, _("IDS_ST_BUTTON_CANCEL_ABB2"));
 773         elm_object_part_content_set(popup, "button1", btn);
 774         evas_object_smart_callback_add(btn, "clicked", _disable_emergency_cancel_cb, popup);
 775
 776         btn = elm_button_add(popup);
 777         elm_object_style_set(btn, "popup");
 778         evas_object_size_hint_weight_set(btn, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
 779         elm_object_text_set(btn, _("IDS_WNOTI_BUTTON_OK_ABB2"));
 780         elm_object_part_content_set(popup, "button2", btn);
 781         evas_object_smart_callback_add(btn, "clicked", _disable_emergency_ok_cb, popup);
 782
 783         evas_object_show(popup);
 784 }
 785
 786