setting-storage/src/setting-storage-SD.c

   1 /*
   2  * setting
   3  *
   4  * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd.
   5  *
   6  * Licensed under the Apache License, Version 2.0 (the "License");
   7  * you may not use this file except in compliance with the License.
   8  * You may obtain a copy of the License at
   9  *
  10  * http://www.apache.org/licenses/LICENSE-2.0
  11  *
  12  * Unless required by applicable law or agreed to in writing, software
  13  * distributed under the License is distributed on an "AS IS" BASIS,
  14  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  15  * See the License for the specific language governing permissions and
  16  * limitations under the License.
  17  *
  18  */
  19 #include <glib.h>
  20 #include <sys/mount.h>
  21 #if SUPPORT_ENCRYPTION
  22 #include <ode.h>
  23 #endif
  24 #include "setting-storage-utils.h"
  25 #include "setting-storage-SD.h"
  26
  27 typedef void (*storageUg_mmc_cb)(int result, void *data);
  28
  29 enum {
  30     STORAGEUG_SD_REQ_NONE,
  31     STORAGEUG_SD_REQ_MOUNT,
  32     STORAGEUG_SD_REQ_UNMOUNT,
  33     STORAGEUG_SD_REQ_FORMAT
  34 };
  35
  36 static void storageUg_SD_finish_progress(int result, void *data)
  37 {
  38         SettingStorageUG *ad = data;
  39
  40         ret_if(data == NULL);
  41
  42         if (ad->popup) {
  43                 evas_object_del(ad->popup);
  44                 ad->popup = NULL;
  45         }
  46
  47         if (result < 0) {
  48                 SETTING_TRACE_ERROR("result(%d) Invalid", result);
  49                 storageUg_fail_popup(ad);
  50         }
  51         ad->sd_request = STORAGEUG_SD_REQ_NONE;
  52 }
  53
  54 static void storageUg_SD_unmount(SettingStorageUG *ad, storageUg_mmc_cb cb)
  55 {
  56         int ret;
  57
  58         ret_if(ad == NULL);
  59
  60         ad->popup = setting_create_popup_with_progressbar(ad, ad->win, PROGRESSBAR_STYLE,
  61                                                           NULL, STORAGEUG_STR_UNMOUNTING_SD, storageUg_popup_del, 0, TRUE, TRUE, 0);
  62
  63         ad->mmc_content.mmc_cb = cb;
  64         ad->mmc_content.user_data = ad;
  65         ret = deviced_request_unmount_mmc(&ad->mmc_content, MNT_FORCE);
  66         if (ret == -1) {
  67                 SETTING_TRACE_ERROR("deviced_request_unmount_mmc() Fail");
  68                 storageUg_fail_popup(ad);
  69         }
  70         ad->sd_request = STORAGEUG_SD_REQ_UNMOUNT;
  71 }
  72
  73 static void storageUg_SD_unmount_resp(void *data, Evas_Object *obj,
  74                                       void *event_info)
  75 {
  76         int response_type;
  77         SettingStorageUG *ad = data;
  78
  79         ret_if(data == NULL);
  80
  81         response_type = btn_type(obj);
  82         if (ad->popup) {
  83                 evas_object_del(ad->popup);
  84                 ad->popup = NULL;
  85         }
  86
  87         if (POPUP_RESPONSE_OK == response_type)
  88                 storageUg_SD_unmount(ad, storageUg_SD_finish_progress);
  89 }
  90
  91 static void storageUg_SD_handle_mount_unmount(void *data)
  92 {
  93         SettingStorageUG *ad = data;
  94
  95         ret_if(data == NULL);
  96
  97         SETTING_TRACE("mmc_status = %d", ad->mmc_status);
  98
  99         if (ad->popup) {
 100                 evas_object_del(ad->popup);
 101                 ad->popup = NULL;
 102         }
 103
 104         if (VCONFKEY_SYSMAN_MMC_MOUNTED == ad->mmc_status) {
 105                 ad->popup = setting_create_popup(ad, ad->win, STORAGEUG_STR_UNMOUNT_SD,
 106                                                                                  STORAGEUG_STR_SD_UNMOUNT_POPUP_MSG, storageUg_SD_unmount_resp,
 107                                                                                  0, FALSE, FALSE,
 108                                                                                  2, STORAGEUG_STR_OK, STORAGEUG_STR_CANCEL);
 109         } else {
 110                 int ret;
 111
 112                 ad->popup = setting_create_popup_with_progressbar(ad, ad->win,
 113                                                                   PROGRESSBAR_STYLE, NULL, "IDS_ST_POP_MOUNTING_SD_CARD_ING", storageUg_popup_del, 0, TRUE, TRUE, 0);
 114
 115                 ad->mmc_content.mmc_cb = storageUg_SD_finish_progress;
 116                 ad->mmc_content.user_data = ad;
 117                 ret = deviced_request_mount_mmc(&ad->mmc_content);
 118                 /*  if fail, popup failed info */
 119                 if (ret == -1) {
 120                         SETTING_TRACE_ERROR("deviced_request_mount_mmc() Fail");
 121                         storageUg_fail_popup(ad);
 122                         return;
 123                 }
 124                 ad->sd_request = STORAGEUG_SD_REQ_MOUNT;
 125         }
 126 }
 127
 128 static void storageUg_SD_finish_format(int result, void *data)
 129 {
 130         SettingStorageUG *ad = data;
 131
 132         ret_if(data == NULL);
 133
 134         if (ad->popup) {
 135                 evas_object_del(ad->popup);
 136                 ad->popup = NULL;
 137         }
 138
 139         ad->sd_request = STORAGEUG_SD_REQ_NONE;
 140
 141         if (result < 0) {
 142                 SETTING_TRACE_ERROR("result(%d) Invalid", result);
 143                 storageUg_fail_popup(ad);
 144                 return;
 145         }
 146 }
 147
 148 static void storageUg_SD_format(int result, void *data)
 149 {
 150         int ret;
 151         SettingStorageUG *ad = data;
 152
 153         ret_if(data == NULL);
 154
 155         if (ad->popup) {
 156                 evas_object_del(ad->popup);
 157                 ad->popup = NULL;
 158         }
 159
 160         if (result < 0) {
 161                 SETTING_TRACE_ERROR("result(%d) Invalid", result);
 162                 storageUg_fail_popup(ad);
 163                 ad->sd_request = STORAGEUG_SD_REQ_NONE;
 164                 return;
 165         }
 166
 167         ad->popup = setting_create_popup_with_progressbar(ad, ad->win, "default",
 168                                                           NULL, STORAGEUG_STR_FORMATTING_SD, NULL, 0, TRUE, TRUE, 0);
 169
 170         ad->mmc_content.mmc_cb = storageUg_SD_finish_format;
 171         ad->mmc_content.user_data = ad;
 172         ret = deviced_request_format_mmc(&ad->mmc_content);
 173         if (ret == -1) {
 174                 SETTING_TRACE_ERROR("fail to call deviced_request_format_mmc");
 175                 storageUg_fail_popup(ad);
 176         }
 177         ad->sd_request = STORAGEUG_SD_REQ_FORMAT;
 178 }
 179
 180
 181 static void storageUg_SD_format_se_confirm_resp(void *data, Evas_Object *obj,
 182                                                 void *event_info)
 183 {
 184         int response_type;
 185         SettingStorageUG *ad = data;
 186
 187         ret_if(data == NULL);
 188
 189         response_type = btn_type(obj);
 190         if (ad->popup) {
 191                 evas_object_del(ad->popup);
 192                 ad->popup = NULL;
 193         }
 194
 195         if (POPUP_RESPONSE_OK == response_type)
 196                 storageUg_SD_unmount(ad, storageUg_SD_format);
 197 }
 198
 199
 200 static void storageUg_SD_format_se_confirm(SettingStorageUG *ad)
 201 {
 202         if (ad->popup)
 203                 evas_object_del(ad->popup);
 204
 205         ad->popup = setting_create_popup(ad, ad->win, NULL,
 206                                                                          STORAGEUG_STR_FORMAT_SECOND_Q, storageUg_SD_format_se_confirm_resp,
 207                                                                          0, FALSE, FALSE,
 208                                                                          2, STORAGEUG_STR_OK, STORAGEUG_STR_CANCEL);
 209
 210 }
 211
 212 static void storageUg_passwd_ug_result_cb(ui_gadget_h ug, app_control_h service,
 213                                           void *priv)
 214 {
 215         char *result = NULL;
 216         SettingStorageUG *ad = priv;
 217
 218         ret_if(NULL == priv);
 219
 220         app_control_get_extra_data(service, "result", &result);
 221         if (safeStrCmp(result, "SETTING_PW_TYPE_ENTER_LOCK_TYPE") == 0)
 222                 storageUg_SD_format_se_confirm(ad);
 223         else
 224                 storageUg_fail_popup(ad);
 225
 226         FREE(result);
 227
 228         elm_object_tree_focus_allow_set(ad->lo_main, EINA_TRUE);
 229         setting_ug_destroy(ug);
 230 }
 231
 232 static inline void storageUg_passwd_ug(SettingStorageUG *ad)
 233 {
 234         app_control_h svc;
 235         ui_gadget_h ug;
 236         struct ug_cbs cbs;
 237
 238         ret_if(NULL == ad);
 239
 240         if (app_control_create(&svc))
 241                 return;
 242
 243         app_control_add_extra_data(svc, "viewtype", "SETTING_PW_TYPE_ENTER_LOCK_TYPE");
 244
 245         memset(&cbs, 0, sizeof(struct ug_cbs));
 246         cbs.layout_cb = storageUg_ug_layout_cb;
 247         cbs.result_cb = storageUg_passwd_ug_result_cb;
 248         cbs.destroy_cb = storageUg_ug_destroy_cb;
 249         cbs.priv = (void *)ad;
 250
 251         elm_object_tree_focus_allow_set(ad->lo_main, EINA_FALSE);
 252         ug = setting_ug_create(ad->ug, "setting-password-efl", UG_MODE_FULLVIEW, svc, &cbs);
 253         warn_if(NULL == ug, "setting_ug_create() Fail");
 254
 255         app_control_destroy(svc);
 256 }
 257
 258 static inline int storageUg_checkencrypt()
 259 {
 260         int sde_status = 1;
 261 #if SUPPORT_ENCRYPTION
 262         if (ode_init() == 0) {
 263                 sde_status = sde_checkencrypt();
 264                 ode_deinit();
 265         }
 266 #endif
 267         return !sde_status;
 268 }
 269
 270 static inline void storageUg_SD_prepare_format(SettingStorageUG *ad)
 271 {
 272         int is_encrypt;
 273
 274         is_encrypt = storageUg_checkencrypt();
 275         if (is_encrypt)
 276                 storageUg_passwd_ug(ad);
 277         else
 278                 storageUg_SD_format_se_confirm(ad);
 279 }
 280
 281 static void storageUg_SD_format_first_confirm_resp(void *data,
 282                                                    Evas_Object *obj, void *event_info)
 283 {
 284         int response_type;
 285         SettingStorageUG *ad = data;
 286
 287         ret_if(data == NULL);
 288
 289         response_type = btn_type(obj);
 290         if (ad->popup) {
 291                 evas_object_del(ad->popup);
 292                 ad->popup = NULL;
 293         }
 294
 295         if (POPUP_RESPONSE_OK == response_type) {
 296                 storageUg_SD_prepare_format(ad);
 297         }
 298
 299 }
 300
 301
 302 static inline void storageUg_SD_handle_format(SettingStorageUG *ad)
 303 {
 304         char *popup_msg;
 305
 306         if (ad->popup) {
 307                 evas_object_del(ad->popup);
 308                 ad->popup = NULL;
 309         }
 310
 311         popup_msg = STORAGEUG_STR_FORMAT_USE_MSG;
 312
 313         ad->popup = setting_create_popup(ad, ad->win, NULL, popup_msg,
 314                                                                          storageUg_SD_format_first_confirm_resp,
 315                                                                          0, FALSE, FALSE,
 316                                                                          2, STORAGEUG_STR_OK, STORAGEUG_STR_CANCEL);
 317 }
 318
 319 static void storageUg_SD_sel(void *data, Evas_Object *obj, void *event_info)
 320 {
 321         SettingStorageUG *ad = data;
 322         Elm_Object_Item *item = event_info;
 323
 324         ret_if(NULL == data);
 325         ret_if(NULL == event_info);
 326
 327         elm_genlist_item_selected_set(item, 0);
 328
 329         if (item == ad->sd_mount->item)
 330                 storageUg_SD_handle_mount_unmount(ad);
 331         else if (item == ad->sd_format->item)
 332                 storageUg_SD_handle_format(ad);
 333         else
 334                 SETTING_TRACE_ERROR("item(%p) Invalid", item);
 335 }
 336
 337 static Setting_GenGroupItem_Data *storageUg_SD_gl_insert_after(
 338     Evas_Object *genlist,
 339     const Elm_Genlist_Item_Class *itc,
 340     Elm_Object_Item *before,
 341     setting_call_back_func gl_sel,
 342     void *sel_data,
 343     const char *keyStr,
 344     char *sub_desc,
 345     SettingStorageUG *ad)
 346 {
 347         Setting_GenGroupItem_Data *it_data = calloc(1, sizeof(Setting_GenGroupItem_Data));
 348         retvm_if(NULL == it_data, NULL, "calloc failed");
 349
 350         it_data->keyStr = (char *)g_strdup(keyStr);
 351         it_data->sub_desc = (char *)g_strdup(sub_desc);
 352         it_data->swallow_type = SWALLOW_Type_INVALID;
 353         it_data->userdata = ad;
 354
 355         it_data->item = elm_genlist_item_insert_after(genlist, itc, it_data, NULL, before,
 356                                                       ELM_GENLIST_ITEM_NONE, gl_sel, sel_data);
 357
 358         return it_data;
 359 }
 360
 361 static inline void storageUg_SD_info_removed(SettingStorageUG *ad)
 362 {
 363
 364         ad->sd_mount = storageUg_SD_gl_insert_after(ad->gl_main, &itc_2text_2,
 365                                                     ad->sd_card->item, NULL, NULL, STORAGEUG_STR_MOUNT_SD, STORAGEUG_STR_INSERT,
 366                                                      NULL);
 367         if (ad->sd_mount) {
 368                 elm_object_item_disabled_set(ad->sd_mount->item, EINA_TRUE);
 369         } else {
 370                 SETTING_TRACE_ERROR("ad->sd_mount is NULL");
 371         }
 372 }
 373
 374 static inline void storageUg_SD_info_inserted_not_mounted(SettingStorageUG *ad)
 375 {
 376         ad->sd_mount = storageUg_SD_gl_insert_after(ad->gl_main, &itc_1text,
 377                                                     ad->sd_card->item, storageUg_SD_sel, ad, STORAGEUG_STR_MOUNT_SD, NULL,
 378                                                     ad);
 379         warn_if(NULL == ad->sd_mount, "ad->sd_mount is NULL");
 380
 381         if (ad->sd_format) {
 382                 int status = -1;
 383
 384                 vconf_get_int(VCONFKEY_SYSMAN_MMC_MOUNT, &status);
 385                 if (VCONFKEY_SYSMAN_MMC_MOUNT_COMPLETED == status
 386                     || VCONFKEY_SYSMAN_MMC_MOUNT_ALREADY == status) {
 387                         setting_disable_genlist_item(ad->sd_format->item);
 388                 }
 389         } else {
 390                 SETTING_TRACE_ERROR("ad->sd_format is NULL");
 391         }
 392 }
 393
 394 static inline void storageUg_SD_info_mounted(SettingStorageUG *ad)
 395 {
 396         double total = 0.0;
 397         double avail = 0.0;
 398         char total_str[STORAGEUG_MAX_STR_LEN] = {0};
 399         char avail_str[STORAGEUG_MAX_STR_LEN] = {0};
 400         const char *MMC_path = "/opt/storage/sdcard";
 401
 402         storageUg_get_external_storage_status(MMC_path, &total, &avail);
 403         storageUg_size_to_str(total, total_str, sizeof(total_str));
 404         storageUg_size_to_str(avail, avail_str, sizeof(avail_str));
 405
 406         ad->sd_total = storageUg_SD_gl_insert_after(ad->gl_main, &itc_2text_2,
 407                                                     ad->sd_card->item, NULL, ad, STORAGEUG_STR_TOTAL, total_str,
 408                                                     ad);
 409         if (ad->sd_total) {
 410                 elm_genlist_item_select_mode_set(ad->sd_total->item,
 411                                                  ELM_OBJECT_SELECT_MODE_DISPLAY_ONLY);
 412                 ad->sd_avail = storageUg_SD_gl_insert_after(ad->gl_main, &itc_2text_2,
 413                                                             ad->sd_total->item, NULL, ad, STORAGEUG_STR_AVAIL_SPACE, avail_str,
 414                                                             ad);
 415                 if (ad->sd_avail) {
 416                         elm_genlist_item_select_mode_set(ad->sd_avail->item,
 417                                                          ELM_OBJECT_SELECT_MODE_DISPLAY_ONLY);
 418                         ad->sd_mount = storageUg_SD_gl_insert_after(ad->gl_main, &itc_1text,
 419                                                                     ad->sd_avail->item, storageUg_SD_sel, ad, STORAGEUG_STR_UNMOUNT_SD, NULL,
 420                                                                     ad);
 421                         warn_if(NULL == ad->sd_mount, "ad->sd_mount is NULL");
 422                 } else {
 423                         SETTING_TRACE_ERROR("ad->sd_avail is NULL");
 424                 }
 425                 ad->sd_format = storageUg_SD_gl_insert_after(ad->gl_main, &itc_1text,
 426                                                              ad->sd_mount->item, storageUg_SD_sel, ad, STORAGEUG_STR_FORMAT_SD, NULL,
 427                                                              ad);
 428                 warn_if(NULL == ad->sd_format, "ad->sd_format is NULL");
 429
 430         } else {
 431                 SETTING_TRACE_ERROR("ad->sd_total is NULL");
 432         }
 433 }
 434
 435 static inline void storageUg_SD_remove_info(SettingStorageUG *ad)
 436 {
 437         if (ad->sd_mount) {
 438                 elm_object_item_del(ad->sd_mount->item);
 439                 ad->sd_mount = NULL;
 440         }
 441         if (ad->sd_total) {
 442                 elm_object_item_del(ad->sd_total->item);
 443                 ad->sd_total = NULL;
 444         }
 445         if (ad->sd_avail) {
 446                 elm_object_item_del(ad->sd_avail->item);
 447                 ad->sd_avail = NULL;
 448         }
 449         if (ad->sd_format) {
 450                 elm_object_item_del(ad->sd_format->item);
 451                 ad->sd_format = NULL;
 452         }
 453 }
 454
 455 void storageUg_main_append_SD_info(SettingStorageUG *ad)
 456 {
 457         char *str;
 458         int mmc_mode;
 459
 460         ret_if(ad == NULL);
 461
 462         mmc_mode = ad->mmc_status;
 463
 464         SETTING_TRACE_DEBUG("mmc_mode: %d", mmc_mode);
 465
 466         storageUg_SD_remove_info(ad);
 467
 468         if (-1 == mmc_mode)
 469                 mmc_mode = VCONFKEY_SYSMAN_MMC_REMOVED;
 470
 471         if (VCONFKEY_SYSMAN_MMC_REMOVED == mmc_mode)
 472                 storageUg_SD_info_removed(ad);
 473         else if (VCONFKEY_SYSMAN_MMC_INSERTED_NOT_MOUNTED == mmc_mode)
 474                 storageUg_SD_info_inserted_not_mounted(ad);
 475         else if (VCONFKEY_SYSMAN_MMC_MOUNTED == mmc_mode)
 476                 storageUg_SD_info_mounted(ad);
 477         else
 478                 SETTING_TRACE_ERROR("mmc_mode(%d) Invalid", mmc_mode);
 479
 480 #if 0
 481         str = vconf_get_str(storageUg_ENCRYPT_stat);
 482         warn_if(NULL == str, "vconf_get_str(%s) Fail", storageUg_ENCRYPT_stat);
 483         if (!safeStrCmp(str, "encryption_start") || !safeStrCmp(str, "decryption_start")) {
 484                 if (ad->sd_mount) setting_disable_genlist_item(ad->sd_mount->item);
 485                 if (ad->sd_format) setting_disable_genlist_item(ad->sd_format->item);
 486         }
 487 #endif
 488 }
 489
 490 void storageUg_SD_change_cb(keynode_t *node, void *user_data)
 491 {
 492         SettingStorageUG *ad = user_data;
 493
 494         ret_if(NULL == user_data);
 495
 496         ad->mmc_status = vconf_keynode_get_int(node);
 497
 498         storageUg_main_append_SD_info(ad);
 499 }