setting-storage: refactor USB storage

Use storage API instead of deviced API.
Remove mount,unmount,format functionalities as
they seems not to work.

Change-Id: Ia49a5427677b281441d8eb0e7e52ca3b428f82de

diff --git a/setting-storage/inc/setting-storage-USB.h b/setting-storage/inc/setting-storage-USB.h
index c6ae27eb66dee3a0adb2ae2b8a4c6fc32d853b2d..5fced37df7e0a09ab0f6084681db240769548eca 100644 (file)
--- a/setting-storage/inc/setting-storage-USB.h
+++ b/setting-storage/inc/setting-storage-USB.h
@@ -21,12 +21,6 @@
 
 #include "setting-storage.h"
 
-enum {
-       SETTING_STORAGE_USB_OTG_REMOVE = 0,
-       SETTING_STORAGE_USB_OTG_UNMOUNT,
-       SETTING_STORAGE_USB_OTG_MOUNT
-};
-
 void storage_init_USB(SettingStorage *ad);
 void storage_deinit_USB();
 

diff --git a/setting-storage/inc/setting-storage.h b/setting-storage/inc/setting-storage.h
index e8b445e5008e53de55028515d95c578e4d8f0548..af356c1913e5cdd2d40ad55d614d0333cb24c6fe 100644 (file)
--- a/setting-storage/inc/setting-storage.h
+++ b/setting-storage/inc/setting-storage.h
@@ -96,15 +96,8 @@ typedef struct _SettingStorage {
 
        /* usb otg storage */
        Setting_GenGroupItem_Data *usb_card;
-       Setting_GenGroupItem_Data *usb_mount;
        Setting_GenGroupItem_Data *usb_total;
        Setting_GenGroupItem_Data *usb_available;
-       Setting_GenGroupItem_Data *usb_unmount;
-       Setting_GenGroupItem_Data *usb_format;
-
-       int usb_otg_status;
-       int usb_request;
-       char *usb_otg_path;
 
        void *size_worker;
 

diff --git a/setting-storage/src/setting-storage-USB.c b/setting-storage/src/setting-storage-USB.c
index aebeb3c194cf435b82b50374c8bce5798721c74f..5cc9d3daf930e6cdbbd87799087eb279f22b168d 100644 (file)
--- a/setting-storage/src/setting-storage-USB.c
+++ b/setting-storage/src/setting-storage-USB.c
@@ -17,181 +17,21 @@
  *
  */
 #include <linux/limits.h>
-#include <dd-usbhost.h>
 
 #include "setting-storage-utils.h"
 #include "setting-storage-USB.h"
 
-enum {
-       STORAGE_USB_REQ_NONE,
-       STORAGE_USB_REQ_MOUNT,
-       STORAGE_USB_REQ_UNMOUNT,
-       STORAGE_USB_REQ_UNMOUNT_BEFORE_FORMAT,
-       STORAGE_USB_REQ_FORMAT
+struct storage_stats {
+       unsigned long long total; // in bytes
+       unsigned long long available; // in bytes
 };
 
-static inline void storage_USB_unmount(SettingStorage *ad)
-{
-       int ret;
-       ret = unmount_usb_storage(ad->usb_otg_path);
-       if (ret < 0) {
-               SETTING_TRACE_ERROR("unmount_usb_storage(%s) Fail(%d)",
-                               ad->usb_otg_path, ret);
-               storage_fail_popup(ad);
-               ad->usb_request = STORAGE_USB_REQ_NONE;
-       } else {
-               ad->popup = setting_create_popup_with_progressbar(ad, ad->md.window,
-                               PROGRESSBAR_STYLE,
-                               NULL, STORAGE_STR_UNMOUNTING,
-                               storage_popup_del, 0, TRUE, TRUE, 0);
-       }
-}
-
-static inline void storage_USB_mount(SettingStorage *ad)
-{
-       int ret;
-
-       ret = mount_usb_storage(ad->usb_otg_path);
-       if (ret < 0) {
-               SETTING_TRACE_ERROR("mount_usb_storage(%s) Fail(%d)",
-                               ad->usb_otg_path, ret);
-               storage_fail_popup(ad);
-               ad->usb_request = STORAGE_USB_REQ_NONE;
-       } else {
-               ad->popup = setting_create_popup_with_progressbar(ad, ad->md.window,
-                               PROGRESSBAR_STYLE,
-                               NULL, NULL, storage_popup_del, 2, TRUE, TRUE,
-                               0);
-               ad->usb_request = STORAGE_USB_REQ_MOUNT;
-       }
-}
-
-static inline int storage_USB_format(SettingStorage *ad)
-{
-       int ret;
-
-       ret = format_usb_storage(ad->usb_otg_path);
-       if (ret < 0) {
-               SETTING_TRACE_ERROR("format_usb_storage(%s) Fail(%d)",
-                               ad->usb_otg_path, ret);
-               storage_fail_popup(ad);
-               return SETTING_RETURN_FAIL;
-       } else {
-               ad->popup = setting_create_popup_with_progressbar(ad, ad->md.window,
-                               PROGRESSBAR_STYLE,
-                               NULL, STORAGE_STR_FORMATTING,
-                               storage_popup_del, 0, TRUE, TRUE, 0);
-       }
-       return SETTING_RETURN_SUCCESS;
-}
-
-static void storage_USB_unmount_resp(void *data, Evas_Object *obj,
-               void *event_info)
-{
-       int response_type;
-       SettingStorage *ad = data;
-
-       ret_if(data == NULL);
-
-       response_type = btn_type(obj);
-
-       evas_object_del(ad->popup);
-       ad->popup = NULL;
-
-       if (POPUP_RESPONSE_OK == response_type) {
-               ad->usb_request = STORAGE_USB_REQ_UNMOUNT;
-               storage_USB_unmount(ad);
-       }
-}
-
-static void storage_USB_format_se_confirm(void *data, Evas_Object *obj,
-               void *event_info)
-{
-       int response_type;
-       SettingStorage *ad = data;
-
-       ret_if(data == NULL);
-
-       response_type = btn_type(obj);
-
-       evas_object_del(ad->popup);
-       ad->popup = NULL;
-
-       if (POPUP_RESPONSE_OK == response_type) {
-               ad->usb_request = STORAGE_USB_REQ_UNMOUNT_BEFORE_FORMAT;
-               storage_USB_unmount(ad);
-       }
-}
-
-static void storage_USB_format_first_confirm(void *data, Evas_Object *obj,
-               void *event_info)
-{
-       int response_type;
-       SettingStorage *ad = data;
-
-       ret_if(data == NULL);
-
-       response_type = btn_type(obj);
-       evas_object_del(ad->popup);
-       ad->popup = NULL;
-
-       if (POPUP_RESPONSE_OK == response_type) {
-               evas_object_del(ad->popup);
-
-               ad->popup = setting_create_popup(ad, ad->md.window, NULL,
-               STORAGE_STR_USB_FORMAT_SECOND_Q,
-                               storage_USB_format_se_confirm, 0, FALSE,
-                               FALSE, 2, STORAGE_STR_OK,
-                               STORAGE_STR_CANCEL);
-       }
-
-}
-
-static void storage_main_USB_sel(void *data, Evas_Object *obj,
-               void *event_info)
-{
-       SettingStorage *ad = data;
-       Elm_Object_Item *item = event_info;
-       Setting_GenGroupItem_Data *list_item;
-
-       ret_if(NULL == data);
-       ret_if(NULL == event_info);
-
-       elm_genlist_item_selected_set(item, 0);
-       list_item = elm_object_item_data_get(item);
-       setting_retm_if(NULL == list_item, "list_item is NULL");
-
-       SETTING_TRACE("clicking item[%s]", list_item->keyStr);
-
-       evas_object_del(ad->popup);
-       ad->popup = NULL;
-
-       if (list_item == ad->usb_mount) {
-               storage_USB_mount(ad);
-       } else if (list_item == ad->usb_unmount) {
-               ad->popup = setting_create_popup(ad, ad->md.window, NULL,
-               STORAGE_STR_USB_UNMOUNT_POPUP_MSG, storage_USB_unmount_resp,
-                               0, FALSE, FALSE, 2, STORAGE_STR_OK,
-                               STORAGE_STR_CANCEL);
-
-       } else if (list_item == ad->usb_format) {
-               ad->popup = setting_create_popup(ad, ad->md.window, NULL,
-               STORAGE_STR_USB_FORMAT_Q, storage_USB_format_first_confirm,
-                               0, FALSE, FALSE, 2, STORAGE_STR_OK,
-                               STORAGE_STR_CANCEL);
-       }
-}
-
-static inline void storage_USB_remove_info(SettingStorage *ad)
+static void storage_clear_ui(SettingStorage *ad)
 {
        if (ad->usb_card) {
                elm_object_item_del(ad->usb_card->item);
                ad->usb_card = NULL;
        }
-       if (ad->usb_mount) {
-               elm_object_item_del(ad->usb_mount->item);
-               ad->usb_mount = NULL;
-       }
        if (ad->usb_total) {
                elm_object_item_del(ad->usb_total->item);
                ad->usb_total = NULL;
@@ -200,27 +40,22 @@ static inline void storage_USB_remove_info(SettingStorage *ad)
                elm_object_item_del(ad->usb_available->item);
                ad->usb_available = NULL;
        }
-       if (ad->usb_unmount) {
-               elm_object_item_del(ad->usb_unmount->item);
-               ad->usb_unmount = NULL;
-       }
-       if (ad->usb_format) {
-               elm_object_item_del(ad->usb_format->item);
-               ad->usb_format = NULL;
-       }
 }
 
-static inline void storage_USB_append_mounted_info(SettingStorage *ad)
+static void storage_create_ui(SettingStorage *ad, struct storage_stats *stats)
 {
-       double total = 0.0;
-       double avail = 0.0;
+       double total = stats->total;
+       double avail = stats->available;
        char total_str[STORAGE_MAX_STR_LEN] = { 0 };
        char avail_str[STORAGE_MAX_STR_LEN] = { 0 };
 
-       storage_get_external_storage_status(ad->usb_otg_path, &total, &avail);
        storage_size_to_str(total, total_str, sizeof(total_str));
        storage_size_to_str(avail, avail_str, sizeof(avail_str));
 
+       /* USB OTG storage */
+       ad->usb_card = setting_create_Gendial_field_titleItem(ad->md.genlist,
+                       &(ad->itc_group_item), STORAGE_STR_USB, NULL);
+
        /* Total space */
        ad->usb_total = setting_create_Gendial_field_def(ad->md.genlist,
                        &(ad->itc_2text_2),
@@ -246,131 +81,86 @@ static inline void storage_USB_append_mounted_info(SettingStorage *ad)
        } else {
                SETTING_TRACE_ERROR("ad->usb_available is NULL");
        }
-
-       /* Usb Unmount*/
-       ad->usb_unmount = setting_create_Gendial_field_def(ad->md.genlist,
-                       &(ad->itc_1text), storage_main_USB_sel, ad,
-                       SWALLOW_Type_INVALID, NULL, NULL, 0,
-                       STORAGE_STR_UNMOUNT_USB, NULL, NULL);
-       if (ad->usb_unmount)
-               ad->usb_unmount->userdata = ad;
-       else
-               SETTING_TRACE_ERROR("ad->usb_unmount is NULL");
-
-       /* Usb Format*/
-       ad->usb_format = setting_create_Gendial_field_def(ad->md.genlist,
-                       &(ad->itc_1text), storage_main_USB_sel, ad,
-                       SWALLOW_Type_INVALID, NULL, NULL, 0,
-                       STORAGE_STR_FORMAT_USB, NULL, NULL);
-       if (ad->usb_format)
-               ad->usb_format->userdata = ad;
-       else
-               SETTING_TRACE_ERROR("ad->usb_format is NULL");
 }
 
-static inline void storage_main_append_USB_info(SettingStorage *ad)
+static bool storage_foreach_supported_cb(int storage_id, storage_type_e type, storage_state_e state, const char *path, void *user_data)
 {
-       ret_if(NULL == ad);
+       struct storage_stats *stats = user_data;
+       unsigned long long total, available;
+       int err;
 
-       if (ad->usb_card)
-               storage_USB_remove_info(ad);
+       if (type != STORAGE_TYPE_EXTERNAL)
+               return true;
 
-       if (ad->usb_otg_status == SETTING_STORAGE_USB_OTG_REMOVE)
-               return;
+       if ((state != STORAGE_STATE_MOUNTED) && (state != STORAGE_STATE_MOUNTED_READ_ONLY))
+               return true;
 
-       /* USB OTG storage */
-       ad->usb_card = setting_create_Gendial_field_titleItem(ad->md.genlist,
-                       &(ad->itc_group_item), STORAGE_STR_USB, NULL);
+       err = storage_get_total_space(storage_id, &total);
+       retvm_if(err != 0, err, "storage_get_total_space() Fail(%d)", err);
 
-       if (SETTING_STORAGE_USB_OTG_MOUNT == ad->usb_otg_status) {
-               storage_USB_append_mounted_info(ad);
-       } else {
-               /* Usb Mount*/
-               ad->usb_mount = setting_create_Gendial_field_def(ad->md.genlist,
-                               &(ad->itc_1text), storage_main_USB_sel, ad,
-                               SWALLOW_Type_INVALID, NULL, NULL, 0,
-                               STORAGE_STR_MOUNT_USB, NULL, NULL);
-               if (ad->usb_mount)
-                       ad->usb_mount->userdata = ad;
-               else
-                       SETTING_TRACE_ERROR("ad->usb_mount is NULL");
-       }
+       err = storage_get_available_space(storage_id, &available);
+       retvm_if(err != 0, true, "storage_get_available_space() Fail(%d)", err);
+
+       stats->total += total;
+       stats->available += available;
+
+       return true;
 }
 
-static void storage_USB_cb(char *type, char *path, int mount, void *data)
+static void storage_load_stats(struct storage_stats *stats)
 {
-       int ret;
-       SettingStorage *ad = data;
-
-       ret_if(NULL == type);
-       ret_if(NULL == path);
-       ret_if(NULL == data);
+       stats->total = 0;
+       stats->available = 0;
 
-       SETTING_TRACE_DEBUG("path:%s type:%s", path, type);
+       int ret = storage_foreach_device_supported(storage_foreach_supported_cb, stats);
+       retm_if(ret != STORAGE_ERROR_NONE, "storage_foreach_device_supported () Fail(%d)", ret);
+}
 
-       FREE(ad->usb_otg_path);
-       ad->usb_otg_path = SAFE_STRDUP(path);
+static void storage_refresh_ui(SettingStorage *ad, struct storage_stats *stats)
+{
+       storage_clear_ui(ad);
 
-       evas_object_del(ad->popup);
-       ad->popup = NULL;
+       if (stats->total == 0)
+               return;
 
-       if (!strcmp(type, "storage_remove")) {
-               ad->usb_otg_status = SETTING_STORAGE_USB_OTG_REMOVE;
-       } else if (!strcmp(type, "storage_mount")) {
-               ad->usb_otg_status = SETTING_STORAGE_USB_OTG_MOUNT;
-               if (STORAGE_USB_REQ_UNMOUNT == ad->usb_request) {
-                       SETTING_TRACE_ERROR("unmount_usb_storage() Fail");
-                       storage_fail_popup(ad);
-               }
-       } else if (!strcmp(type, "storage_unmount")) {
-               ad->usb_otg_status = SETTING_STORAGE_USB_OTG_UNMOUNT;
-               if (STORAGE_USB_REQ_UNMOUNT_BEFORE_FORMAT == ad->usb_request) {
-                       ret = storage_USB_format(ad);
-                       if (SETTING_RETURN_SUCCESS == ret) {
-                               ad->usb_request = STORAGE_USB_REQ_FORMAT;
-                       } else {
-                               ad->usb_request = STORAGE_USB_REQ_NONE;
-                               storage_USB_mount(ad);
-                       }
-                       return;
-               } else if (STORAGE_USB_REQ_FORMAT == ad->usb_request) {
-                       SETTING_TRACE_ERROR("format_usb_storage() Fail");
-                       storage_fail_popup(ad);
-               } else if (STORAGE_USB_REQ_MOUNT == ad->usb_request) {
-                       SETTING_TRACE_ERROR("mount_usb_storage() Fail");
-                       storage_fail_popup(ad);
-               }
-       } else if (!strcmp(type, "storage_updated")) {
-               if (mount == 0)
-                       ad->usb_otg_status = SETTING_STORAGE_USB_OTG_UNMOUNT;
-               else
-                       ad->usb_otg_status = SETTING_STORAGE_USB_OTG_MOUNT;
-       }
-       ad->usb_request = STORAGE_USB_REQ_NONE;
-       storage_main_append_USB_info(ad);
+       storage_create_ui(ad, stats);
 }
 
-void storage_init_USB(SettingStorage *ad)
+static void storage_refresh(SettingStorage *ad)
 {
-       int ret;
+       struct storage_stats stats;
 
-       ret = init_usbhost_signal();
-       retm_if(ret < 0, "init_usbhost_signal() Fail(%d)", ret);
+       storage_load_stats(&stats);
+       storage_refresh_ui(ad, &stats);
+}
+
+static void storage_storage_changed_cb(int storage_id, storage_dev_e dev, storage_state_e state, const char *fstype, const char *fsuuid, const char *mountpath, bool primary, int flags, void *user_data)
+{
+       SettingStorage *ad = user_data;
 
-       ret = register_usb_storage_change_handler(storage_USB_cb, ad);
-       if (ret < 0) {
-               SETTING_TRACE_ERROR(
-                               "register_usb_storage_change_handler() Fail(%d)",
-                               ret);
-               deinit_usbhost_signal();
+       if (dev != STORAGE_DEV_EXT_USB_MASS_STORAGE)
                return;
+
+       switch (state) {
+               case STORAGE_STATE_UNMOUNTABLE:
+                       break;
+               case STORAGE_STATE_REMOVED:
+               case STORAGE_STATE_MOUNTED:
+               case STORAGE_STATE_MOUNTED_READ_ONLY:
+                       storage_refresh(ad);
+                       break;
        }
+}
+
+void storage_init_USB(SettingStorage *ad)
+{
+       int ret = storage_set_changed_cb(STORAGE_TYPE_EXTERNAL, storage_storage_changed_cb, ad);
+       retm_if(ret != STORAGE_ERROR_NONE, "storage_set_changed_cb() Fail(%d)", ret);
 
-       ret = request_usb_storage_info();
-       warn_if(ret < 0, "request_usb_storage_info() Fail(%d)", ret);
+       storage_refresh(ad);
 }
 
 void storage_deinit_USB()
 {
-       deinit_usbhost_signal();
+       storage_unset_changed_cb(STORAGE_TYPE_EXTERNAL, storage_storage_changed_cb);
 }

diff --git a/setting-storage/src/setting-storage-main.c b/setting-storage/src/setting-storage-main.c
index 435fc55c93dbe9a592d75603111ff233bf1258a7..3ae32f610ed3ff75d565b4313d10ea6e4ea17fad 100644 (file)
--- a/setting-storage/src/setting-storage-main.c
+++ b/setting-storage/src/setting-storage-main.c
@@ -200,7 +200,6 @@ Evas_Object *storage_main_graph_get(void *data, Evas_Object *obj,
 Evas_Object *storage_color_item_content_get(void *data, Evas_Object *obj,
                const char *part)
 {
-       Eina_Bool result;
        setting_retvm_if(data == NULL, NULL, "data is NULL");
        Setting_GenGroupItem_Data *list_item = data;
        int color = list_item->color;
@@ -553,9 +552,6 @@ static int _view_create(void *data)
        }
 #endif
 
-       /* usb otg storage*/
-       ad->usb_otg_status = SETTING_STORAGE_USB_OTG_REMOVE;
-
        storage_init_USB(ad);
 
        setting_view_storage_main.is_create = 1;

diff --git a/setting-storage/src/setting-storage.c b/setting-storage/src/setting-storage.c
index 56b2722be864f944558a1da785b028d5b9db006b..fbd9e067067401179514337c115983bec1fe60e9 100644 (file)
--- a/setting-storage/src/setting-storage.c
+++ b/setting-storage/src/setting-storage.c
@@ -210,8 +210,6 @@ static void _setting_storage_app_terminate(void *data)
 
        retm_if(NULL == data, "data=%p is Invalid", data);
 
-       FREE(ad->usb_otg_path);
-
        _storage_ignore_vconf();
 
        ret = media_content_disconnect();