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