tools/apps/ode/src/ode-app-confirm.c

   1 /*
   2  *
   3  * Copyright (c) 2017 Samsung Electronics Co., Ltd All Rights Reserved
   4  *
   5  * Licensed under the Apache License, Version 2.0 (the "License");
   6  * you may not use this file except in compliance with the License.
   7  * You may obtain a copy of the License at
   8  *
   9  * http://www.apache.org/licenses/LICENSE-2.0
  10  *
  11  * Unless required by applicable law or agreed to in writing, software
  12  * distributed under the License is distributed on an "AS IS" BASIS,
  13  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14  * See the License for the specific language governing permissions and
  15  * limitations under the License.
  16  *
  17  */
  18
  19 #include "ode-app.h"
  20 #include <ode/external-encryption.h>
  21 #include <ode/internal-encryption.h>
  22
  23 char *confirm_button_text[] = {
  24         "IDS_ST_BUTTON_BACK",
  25         "IDS_ST_BUTTON_ENCRYPT_ABB2",
  26         "IDS_ST_BUTTON_DECRYPT_DEVICE"
  27 };
  28 extern char *encrypt_header_text[];
  29 static int sdcard_option_selected = 0;
  30 static int device_full_encryption_state = 0;
  31
  32 #define sdcard_option_num 2
  33 static void _confirm_next_btn_clicked_cb(void *data, Evas_Object *obj, void *event_info)
  34 {
  35         int ret = 0;
  36         appdata_s *ad = (appdata_s *) data;
  37         dlog_print(DLOG_DEBUG, LOG_TAG, "_confirm_btn_clicked_cb start");
  38
  39         switch (ad->view_type) {
  40         case ENCRYPT_DEVICE:
  41                 dlog_print(DLOG_DEBUG, LOG_TAG, "encrypt device confirm");
  42                 ret = ode_internal_encryption_encrypt("tizen", 0);
  43                 if (ret != 0) {
  44                         dlog_print(DLOG_DEBUG, LOG_TAG, "internal encryption failed");
  45                 }
  46                 ui_app_exit();
  47                 break;
  48         case DECRYPT_DEVICE:
  49                 dlog_print(DLOG_DEBUG, LOG_TAG, "decrypt device confirm");
  50                 ret = ode_internal_encryption_decrypt("tizen");
  51                 if (ret != 0) {
  52                         dlog_print(DLOG_DEBUG, LOG_TAG, "internal decryption failed");
  53                 }
  54                 ui_app_exit();
  55                 break;
  56         case ENCRYPT_SD_CARD:
  57                 dlog_print(DLOG_DEBUG, LOG_TAG, "encrypt sd card confrim");
  58                 create_base_window();
  59                 create_progress_view("Encrypting", "External");
  60                 ret = ode_external_encryption_encrypt(ad->entry_data, 0);
  61                 if (ret != 0) {
  62                         dlog_print(DLOG_DEBUG, LOG_TAG, "external encryption failed");
  63                 }
  64                 break;
  65         case DECRYPT_SD_CARD:
  66                 dlog_print(DLOG_DEBUG, LOG_TAG, "decrypt sd card confrim");
  67                 create_base_window();
  68                 create_progress_view("Decrypting", "External");
  69                 ret = ode_external_encryption_decrypt(ad->entry_data);
  70                 if (ret != 0) {
  71                         dlog_print(DLOG_DEBUG, LOG_TAG, "external decryption failed");
  72                 }
  73                 break;
  74         }
  75 }
  76
  77 static char *confirm_multiline_text_get(void *data, Evas_Object *obj, const char *part)
  78 {
  79         char *genlist_text[] = {
  80                 "IDS_ST_MBODY_FULL_ENCRYPTION",
  81                 "IDS_ST_SBODY_ENCRYPT_NOT_ONLY_THE_USED_PHONE_STORAGE_BUT_ALSO_ANY_EMPTY_SPACE_THIS_WILL_TAKE_MORE_TIME"
  82         };
  83
  84         if (!strcmp(part, "elm.text"))
  85                 return strdup(__(genlist_text[0]));
  86         else if (!strcmp(part, "elm.text.multiline"))
  87                 return strdup(__(genlist_text[1]));
  88
  89         return NULL;
  90 }
  91
  92 void device_encrypt_option_changed_cb(void *data, Evas_Object *obj, void *event_info)
  93 {
  94         dlog_print(DLOG_INFO, LOG_TAG, "The value has changed \n");
  95         if (elm_check_state_get(obj) == EINA_TRUE)
  96                 device_full_encryption_state = 1;
  97         else
  98                 device_full_encryption_state = 0;
  99 }
 100
 101 static Evas_Object *device_encrypt_content_get(void *data, Evas_Object *obj, const char *part)
 102 {
 103         if (!strcmp(part, "elm.swallow.end")) {
 104                 Evas_Object *check = elm_check_add(obj);
 105                 elm_object_style_set(check, "default");
 106                 elm_check_state_set(check, EINA_FALSE);
 107                 evas_object_smart_callback_add(check, "changed", device_encrypt_option_changed_cb, data);
 108                 return check;
 109         }
 110
 111         return NULL;
 112 }
 113
 114 static void _prev_btn_clicked_cb(void *data, Evas_Object *obj, void *event_info)
 115 {
 116         appdata_s *ad = (appdata_s *)data;
 117         elm_naviframe_item_pop(ad->navi_bar);
 118 }
 119
 120 static void set_confirm_two_btn_layout(Evas_Object *layout, appdata_s *ad, int text_idx)
 121 {
 122         Evas_Object *btn_layout;
 123         Evas_Object *prev_btn, *next_btn;
 124
 125         btn_layout = ode_create_layout(layout, ad->edj_path, "two_button_layout");
 126
 127         prev_btn = ode_create_button(layout, __(confirm_button_text[0]), "bottom");
 128         elm_object_part_content_set(btn_layout, "prev_button", prev_btn);
 129         evas_object_smart_callback_add(prev_btn, "clicked", _prev_btn_clicked_cb, ad);
 130
 131         next_btn = ode_create_button(layout, __(confirm_button_text[text_idx]), "bottom");
 132         elm_object_part_content_set(btn_layout, "next_button", next_btn);
 133
 134         evas_object_smart_callback_add(next_btn, "clicked", _confirm_next_btn_clicked_cb, ad);
 135         elm_object_part_content_set(layout, "bottom_layout", btn_layout);
 136         return;
 137 }
 138
 139 static char *sd_confirm_multiline_text_get(void *data, Evas_Object *obj, const char *part)
 140 {
 141         char *genlist_text[2][2] = {
 142                 {
 143                         "IDS_ST_MBODY_ENCRYPT_ALL_FILES",
 144                         "IDS_ST_SBODY_ENCRYPT_ALL_FILES_SAVED_ON_THE_SD_CARD_NEW_FILES_WILL_ALSO_BE_ENCRYPTED"
 145                 },
 146                 {
 147                         "IDS_ST_MBODY_ENCRYPT_NEW_FILES",
 148                         "IDS_ST_BODY_ENCRYPT_ALL_NEW_FILES_SAVED_ON_THIS_SD_CARD_EXISTING_FILES_WILL_NOT_BE_ENCRYPTED"
 149                 }
 150         };
 151
 152         char **text = genlist_text[(intptr_t)data];
 153
 154         if (!strcmp(part, "elm.text"))
 155                 return strdup(__(text[0]));
 156         else if (!strcmp(part, "elm.text.multiline"))
 157                 return strdup(__(text[1]));
 158         return NULL;
 159 }
 160
 161 void radio_changed_cb(void *data, Evas_Object *obj, void *event_info)
 162 {
 163         dlog_print(DLOG_INFO, LOG_TAG, "The value has changed %d\n", (intptr_t)data);
 164         sdcard_option_selected = (intptr_t)data;
 165
 166         dlog_print(DLOG_INFO, LOG_TAG, "sdcard_option_selected is  %d\n", sdcard_option_selected);
 167 }
 168
 169 static Evas_Object *sd_confirm_content_get(void *data, Evas_Object *obj, const char *part)
 170 {
 171         static Evas_Object *group = NULL;
 172         int idx = (intptr_t)data;
 173
 174         if (!strcmp(part, "elm.swallow.end")) {
 175                 if (idx == 0) {
 176                         dlog_print(DLOG_DEBUG, LOG_TAG, "radio group null");
 177                         group = elm_radio_add(obj);
 178                         elm_radio_state_value_set(group, 0);
 179                         elm_radio_value_set(group, 0);
 180                 }
 181
 182                 dlog_print(DLOG_DEBUG, LOG_TAG, "radio group not null");
 183                 Evas_Object *radio = elm_radio_add(obj);
 184                 elm_radio_state_value_set(radio, idx);
 185
 186                 if (idx == sdcard_option_selected) {
 187                         elm_radio_state_value_set(radio, idx);
 188                 }
 189
 190                 elm_radio_group_add(radio, group);
 191                 evas_object_propagate_events_set(radio, EINA_FALSE);
 192                 evas_object_repeat_events_set(radio, EINA_FALSE);
 193
 194                 evas_object_smart_callback_add(radio, "changed", radio_changed_cb, data);
 195                 return radio;
 196         }
 197         return NULL;
 198 }
 199
 200 static Eina_Bool sdcard_encrypt_view_pop_cb(void *data, Elm_Object_Item *it)
 201 {
 202         sdcard_option_selected = 0;
 203         return EINA_TRUE;
 204 }
 205
 206 static Eina_Bool device_encrypt_view_pop_cb(void *data, Elm_Object_Item *it)
 207 {
 208         appdata_s *ad = (appdata_s *)data;
 209
 210         if (ad->view_type == ENCRYPT_DEVICE)
 211                 device_full_encryption_state = 0;
 212         return EINA_TRUE;
 213 }
 214
 215
 216 void ode_confirm_encrypt_device_create_view(appdata_s *ad)
 217 {
 218         Evas_Object *naviframe = ad->navi_bar;
 219         Evas_Object *base_layout = NULL;
 220         Evas_Object *confirm_msg = NULL;
 221         Evas_Object *confirm_layout = NULL;
 222
 223         Evas_Object *genlist = NULL;
 224         Elm_Genlist_Item_Class *itc;
 225         Elm_Object_Item *item;
 226
 227         dlog_print(DLOG_DEBUG, LOG_TAG, "start ode_confirm_encrypt_device_create_view");
 228
 229         char string[PATH_MAX] = "";
 230         char *confirm_text[2][3] = {
 231                 {
 232                         "IDS_ST_BODY_TAP_ENCRYPT_TO_START_THE_ENCRYPTION_PROCESS",
 233                         "IDS_ST_BODY_THE_ENCRYPTION_CANT_BE_CANCELLED_AND_DATA_WILL_BE_LOST_IF_THE_PROCESS_IS_INTERRUPTED_DURING_MSG",
 234                         "IDS_ST_HEADER_ENCRYPTION_OPTIONS_ABB"
 235                 },
 236                 {
 237                         "IDS_ST_BODY_TAP_DECRYPT_TO_START_THE_DECRYPTION_PROCESS",
 238                         "IDS_ST_BODY_THE_DECRYPTION_CANT_BE_CANCELLED_AND_DATA_WILL_BE_LOST_IF_THE_PROCESS_IS_INTERRUPTED_DURING_THE_DECRYPTION_MSG",
 239                         ""
 240                 }
 241         };
 242
 243         char **text = confirm_text[ad->view_type];
 244
 245         if (naviframe == NULL) {
 246                 dlog_print(DLOG_ERROR, LOG_TAG, "naviframe is null");
 247                 return;
 248         }
 249
 250         base_layout = ode_create_layout(naviframe, ad->edj_path, "base_layout");
 251         confirm_layout = ode_create_layout(base_layout, ad->edj_path, "encrypt_device_confirm_layout");
 252         text = confirm_text[ad->view_type];
 253         snprintf(string, sizeof(string), "%s<br><br>%s", __(text[0]), __(text[1]));
 254         confirm_msg = ode_create_textblock(confirm_layout, string, MSG_TEXT_STYLE);
 255         elm_object_part_content_set(confirm_layout, "msg_content", confirm_msg);
 256
 257         if (ad->view_type == ENCRYPT_DEVICE) {
 258                 /* add group index */
 259                 genlist = elm_genlist_add(confirm_layout);
 260                 elm_object_style_set(genlist, "solid/default");
 261                 elm_layout_content_set(confirm_layout, "genlist_base", genlist);
 262                 elm_genlist_mode_set(genlist, ELM_LIST_COMPRESS);
 263
 264                 itc =  ode_create_genlist_item_class("group_index", ode_group_text_get, NULL);
 265                 ode_append_genlist_item(genlist, itc, ELM_OBJECT_SELECT_MODE_DISPLAY_ONLY, text[2]);
 266
 267                 itc = ode_create_genlist_item_class("multiline", confirm_multiline_text_get, device_encrypt_content_get);
 268                 ode_append_genlist_item(genlist, itc, ELM_OBJECT_SELECT_MODE_DISPLAY_ONLY, NULL);
 269         }
 270
 271         elm_object_part_content_set(base_layout, "content_layout", confirm_layout);
 272         /* set button */
 273         set_confirm_two_btn_layout(base_layout, ad, (ad->view_type + 1));
 274         item = elm_naviframe_item_push(naviframe, __(encrypt_header_text[ad->view_type]), NULL, NULL, base_layout, NULL);
 275         elm_naviframe_item_pop_cb_set(item, device_encrypt_view_pop_cb, ad);
 276 }
 277
 278 void ode_confirm_encrypt_sd_card_create_view(appdata_s *ad)
 279 {
 280         Evas_Object *naviframe = ad->navi_bar;
 281         Evas_Object *base_layout = NULL;
 282         Evas_Object *confirm_msg = NULL;
 283         Evas_Object *confirm_layout = NULL;
 284
 285         Evas_Object *genlist = NULL;
 286         Elm_Genlist_Item_Class *itc;
 287         Elm_Object_Item *item;
 288
 289         dlog_print(DLOG_DEBUG, LOG_TAG, "start ode_confirm_encrypt_sd_card_create_view");
 290
 291         char string[PATH_MAX] = "";
 292         char *confirm_text[] = {
 293                 "IDS_ST_BODY_TAP_ENCRYPT_SD_CARD_TO_START_THE_ENCRYPTION_PROCESS",
 294                 "IDS_ST_BODY_ALL_OPEN_FILES_ON_SD_CARD_WILL_BE_CLOSED",
 295                 "IDS_ST_BODY_THE_ENCRYPTION_CANT_BE_CANCELLED_AND_DATA_WILL_BE_LOST_IF_THE_PROCESS_IS_INTERRUPTED_DURING_THE_MSG",
 296                 "IDS_ST_HEADER_ENCRYPTION_OPTIONS_ABB"
 297         };
 298
 299         if (naviframe == NULL) {
 300                 dlog_print(DLOG_ERROR, LOG_TAG, "naviframe is null");
 301                 return;
 302         }
 303
 304         base_layout = ode_create_layout(naviframe, ad->edj_path, "base_layout");
 305         confirm_layout = ode_create_layout(base_layout, ad->edj_path, "encrypt_device_confirm_layout");
 306
 307         snprintf(string, sizeof(string), "%s<br><br>%s%s", __(confirm_text[0]), __(confirm_text[1]), __(confirm_text[2]));
 308         confirm_msg = ode_create_textblock(confirm_layout, string, MSG_TEXT_STYLE);
 309         elm_object_part_content_set(confirm_layout, "msg_content", confirm_msg);
 310
 311         genlist = elm_genlist_add(confirm_layout);
 312         elm_object_style_set(genlist, "solid/default");
 313         elm_layout_content_set(confirm_layout, "genlist_base", genlist);
 314         elm_genlist_mode_set(genlist, ELM_LIST_COMPRESS);
 315
 316         itc =  ode_create_genlist_item_class("group_index", ode_group_text_get, NULL);
 317         ode_append_genlist_item(genlist, itc, ELM_OBJECT_SELECT_MODE_DISPLAY_ONLY, confirm_text[3]);
 318
 319         int index;
 320         itc = ode_create_genlist_item_class("multiline", sd_confirm_multiline_text_get, sd_confirm_content_get);
 321
 322         for (index = 0; index < sdcard_option_num; index++) {
 323                 item = elm_genlist_item_append(genlist, itc, (void*)(intptr_t)index, NULL, ELM_GENLIST_ITEM_NONE , NULL, NULL);
 324                 elm_genlist_item_select_mode_set(item, ELM_OBJECT_SELECT_MODE_NONE);
 325         }
 326
 327         elm_object_part_content_set(base_layout, "content_layout", confirm_layout);
 328         set_confirm_two_btn_layout(base_layout, ad, 1);
 329         item = elm_naviframe_item_push(naviframe, __(encrypt_header_text[2]), NULL, NULL, base_layout, NULL);
 330         elm_naviframe_item_pop_cb_set(item, sdcard_encrypt_view_pop_cb, NULL);
 331 }
 332
 333 void ode_confirm_decrypt_sd_card_create_view(appdata_s *ad)
 334 {
 335         Evas_Object *naviframe = ad->navi_bar;
 336         Evas_Object *base_layout = NULL;
 337         Evas_Object *confirm_msg = NULL;
 338         Evas_Object *confirm_layout = NULL;
 339
 340         dlog_print(DLOG_DEBUG, LOG_TAG, "start ode_confirm_decrypt_sd_card_create_view");
 341
 342         char string[PATH_MAX] = "";
 343         char *confirm_text[] = {
 344                 "IDS_ST_BODY_TAP_ENCRYPT_SD_CARD_TO_START_THE_ENCRYPTION_PROCESS",
 345                 "IDS_ST_BODY_ALL_OPEN_FILES_ON_SD_CARD_WILL_BE_CLOSED",
 346                 "IDS_ST_BODY_THE_DECRYPTION_CANT_BE_CANCELLED_AND_DATA_WILL_BE_LOST_IF_THE_PROCESS_IS_INTERRUPTED_MSG"
 347         };
 348
 349         if (naviframe == NULL) {
 350                 dlog_print(DLOG_ERROR, LOG_TAG, "naviframe is null");
 351                 return;
 352         }
 353
 354         base_layout = ode_create_layout(naviframe, ad->edj_path, "base_layout");
 355         confirm_layout = ode_create_layout(base_layout, ad->edj_path, "encrypt_device_confirm_layout");
 356
 357         snprintf(string, sizeof(string), "%s<br><br>%s%s", __(confirm_text[0]), __(confirm_text[1]), __(confirm_text[2]));
 358         confirm_msg = ode_create_textblock(confirm_layout, string, MSG_TEXT_STYLE);
 359         elm_object_part_content_set(confirm_layout, "msg_content", confirm_msg);
 360
 361         elm_object_part_content_set(base_layout, "content_layout", confirm_layout);
 362         set_confirm_two_btn_layout(base_layout, ad, 2);
 363         elm_naviframe_item_push(naviframe, __(encrypt_header_text[3]), NULL, NULL, base_layout, NULL);
 364 }