*/
#include <setting-storage-main.h>
#include <Ecore_X.h>
-#include <sys/statvfs.h>
-#include <sys/stat.h>
-#include <sys/mount.h>
-#include <dirent.h>
-#include <glib.h>
-#include <glib/gprintf.h>
+#include <package-manager.h>
+#include <ail.h>
static int setting_storage_main_create(void *cb);
static int setting_storage_main_destroy(void *cb);
.cleanup = setting_storage_main_cleanup,
};
-#define SETTING_STORAGE_INTERNAL_STORAGE_STR "Internal storage"
-#define SETTING_STORAGE_PICS_STR "IDS_ST_BODY_PICTURES_VIDEOS"
-#define SETTING_STORAGE_DOWNS_STR "IDS_ST_BODY_DOWNLOADS"
-#define SETTING_STORAGE_MISCES_STR "IDS_ST_BODY_MISCELLANEOUS_FILES"
-#define SETTING_STORAGE_AVAIL_STR "IDS_ST_BODY_AVAILABLE"
-#define SETTING_STORAGE_FORMAT_STR "IDS_ST_BODY_FORMAT_USB_STORAGE"
-#define SETTING_STORAGE_FORMAT_DESC_STR "IDS_ST_BODY_ERASES_ALL_DATA_IN_USB_STORAGE_ABB"
-#define SETTING_STORAGE_MOUNT_STR "IDS_ST_BODY_MOUNT_SD_CARD"
-#define SETTING_STORAGE_INSERT_STR "IDS_ST_BODY_INSERT_SD_CARD"
-
-#define SETTING_STORAGE_APPS_ICON_PATH SETTING_ICON_PATH"/A01-1_icon_color_applications.png"
-#define SETTING_STORAGE_PICS_ICON_PATH SETTING_ICON_PATH"/A01-1_icon_color_pictures.png"
-#define SETTING_STORAGE_DOWNS_ICON_PATH SETTING_ICON_PATH"/A01-1_icon_color_downloads.png"
-#define SETTING_STORAGE_MISCES_ICON_PATH SETTING_ICON_PATH"/A01-1_icon_color_miscellaneous_files.png"
-#define SETTING_STORAGE_AVAIL_ICON_PATH SETTING_ICON_PATH"/A01-1_icon_color_available.png"
-
-#define SETTING_STORAGE_ICON_WIDTH ((int)640 * WIDGET_SCALE_FACTOR)
-#define SETTING_STORAGE_ICON_HEIGHT ((int)16 * WIDGET_SCALE_FACTOR)
-
-#define SETTING_STORAGE_OPT_PATH "/opt"
-#define SETTING_STORAGE_MEDIA_PATH "/opt/media"
-#define SETTING_STORAGE_PICTURES_PATH "/opt/media/Images"
-#define SETTING_STORAGE_VIDEOS_PATH "/opt/media/Videos"
-#define SETTING_STORAGE_DOWNLOADS_PATH "/opt/media/Downloads"
+static Evas_Object *__setting_storage_main_image_add(Evas *evas, char *icon_path, int width, int height)
+{
+ Evas_Object *image = NULL;
+ image = evas_object_image_add(evas);
+ evas_object_size_hint_weight_set(image, 0.0, EVAS_HINT_EXPAND);
+ evas_object_image_load_size_set(image, width, height);
+ evas_object_image_file_set(image, icon_path, NULL);
+ evas_object_image_fill_set(image, 0, 0, width, height);
+ evas_object_size_hint_min_set(image, width, height);
+ evas_object_show(image);
+
+ return image;
+}
static char *__gl_text_get(void *data, Evas_Object *obj, const char *part)
{
int width = SETTING_STORAGE_ICON_WIDTH;
int height = SETTING_STORAGE_ICON_HEIGHT;
+
+ app_device_orientation_e m = elm_win_rotation_get(ad->win_get);
+ if(APP_DEVICE_ORIENTATION_90 == m || APP_DEVICE_ORIENTATION_270 == m) {
+ width = SETTING_STORAGE_ICON_LANDSCAPE_WIDTH;
+ } else {
+ width = SETTING_STORAGE_ICON_WIDTH;
+ }
float temp_size = 0.0;
+ /* use size (applications + picture/videos + audio + miscellaneous + available) as 100% */
+ double total_size = ad->apps_status.dTotal + ad->pics_videos_status.dTotal +
+ + ad->audio_status.dTotal +
+ ad->others_status.dTotal + ad->internal_status.dAvail;
+
if (!safeStrCmp(part, "elm.icon")){
Evas_Object *status_box = NULL;
status_box = elm_box_add(obj);
retvm_if(status_box == NULL, NULL, "Cannot get box");
+ item_data->eo_check = status_box;
elm_box_horizontal_set(status_box, 1);
evas_object_size_hint_align_set(status_box, 0.0, EVAS_HINT_FILL);
evas_object_show(status_box);
/* apps */
unsigned int apps_size = 0;
- temp_size = ((float)ad->apps_status.dTotal / ad->internal_status.dTotal) * width;
+ temp_size = ((float)ad->apps_status.dTotal / total_size) * width;
if (temp_size < 1 && temp_size > 0) {
apps_size = 1;
} else {
apps_size = (unsigned int)temp_size;
}
if (apps_size > 0) {
- Evas_Object *apps = NULL;
- apps = evas_object_image_add(evas);
- evas_object_size_hint_weight_set(apps, 0.0, EVAS_HINT_EXPAND);
- evas_object_image_load_size_set(apps, apps_size, height);
- evas_object_image_file_set(apps, SETTING_STORAGE_APPS_ICON_PATH, NULL);
- evas_object_image_fill_set(apps, 0, 0, apps_size, height);
- evas_object_size_hint_min_set(apps, apps_size, height);
- evas_object_show(apps);
+ Evas_Object *apps = __setting_storage_main_image_add(evas, SETTING_STORAGE_APPS_ICON_PATH, apps_size, height);
elm_box_pack_end(status_box, apps);
}
/* pictures, videos */
unsigned int pics_videos_size = 0;
- temp_size = ((float)ad->pics_videos_status.dTotal / ad->internal_status.dTotal) * width;
+ temp_size = ((float)ad->pics_videos_status.dTotal / total_size) * width;
if (temp_size < 1 && temp_size > 0) {
pics_videos_size = 1;
} else {
pics_videos_size = (unsigned int)temp_size;
}
if (pics_videos_size > 0) {
- Evas_Object *pics = NULL;
- pics = evas_object_image_add(evas);
- evas_object_size_hint_weight_set(pics, 0.0, EVAS_HINT_EXPAND);
- evas_object_image_load_size_set(pics, pics_videos_size, height);
- evas_object_image_file_set(pics, SETTING_STORAGE_PICS_ICON_PATH, NULL);
- evas_object_image_fill_set(pics, 0, 0, pics_videos_size, height);
- evas_object_size_hint_min_set(pics, pics_videos_size, height);
- evas_object_show(pics);
+ Evas_Object *pics = __setting_storage_main_image_add(evas, SETTING_STORAGE_PICS_ICON_PATH, pics_videos_size, height);
elm_box_pack_end(status_box, pics);
}
- /* downloads */
- unsigned int downloads_size = 0;
- temp_size = ((float)ad->downloads_status.dTotal / ad->internal_status.dTotal) * width;
+ /* audio */
+ unsigned int audio_size = 0;
+ temp_size = ((float)ad->audio_status.dTotal / total_size) * width;
if (temp_size < 1 && temp_size > 0) {
- downloads_size = 1;
+ audio_size = 1;
} else {
- downloads_size = (unsigned int)temp_size;
+ audio_size = (unsigned int)temp_size;
}
- if (downloads_size > 0) {
- Evas_Object *downs = NULL;
- downs = evas_object_image_add(evas);
- evas_object_size_hint_weight_set(downs, 0.0, EVAS_HINT_EXPAND);
- evas_object_image_load_size_set(downs, downloads_size, height);
- evas_object_image_file_set(downs, SETTING_STORAGE_DOWNS_ICON_PATH, NULL);
- evas_object_image_fill_set(downs, 0, 0, downloads_size, height);
- evas_object_size_hint_min_set(downs, downloads_size, height);
- evas_object_show(downs);
- elm_box_pack_end(status_box, downs);
+ if (audio_size > 0) {
+ Evas_Object *audio = __setting_storage_main_image_add(evas, SETTING_STORAGE_AUDIO_ICON_PATH, audio_size, height);
+ elm_box_pack_end(status_box, audio);
}
/* Miscellaneous files */
unsigned int others_size = 0;
- temp_size = ((float)ad->others_status.dTotal / ad->internal_status.dTotal) * width;
+ temp_size = ((float)ad->others_status.dTotal / total_size) * width;
if (temp_size < 1 && temp_size > 0) {
others_size = 1;
} else {
others_size = (unsigned int)temp_size;
}
if (others_size > 0) {
- Evas_Object *misc = NULL;
- misc = evas_object_image_add(evas);
- evas_object_size_hint_weight_set(misc, 0.0, EVAS_HINT_EXPAND);
- evas_object_image_load_size_set(misc, others_size, height);
- evas_object_image_file_set(misc, SETTING_STORAGE_MISCES_ICON_PATH, NULL);
- evas_object_image_fill_set(misc, 0, 0, others_size, height);
- evas_object_size_hint_min_set(misc, others_size, height);
- evas_object_show(misc);
+ Evas_Object *misc = __setting_storage_main_image_add(evas, SETTING_STORAGE_MISCES_ICON_PATH, others_size, height);
elm_box_pack_end(status_box, misc);
}
/* available */
unsigned int avail_size = 0;
- temp_size = ((float)ad->internal_status.dAvail / ad->internal_status.dTotal) * width;
+ temp_size = ((float)ad->internal_status.dAvail / total_size) * width;
if (temp_size < 1 && temp_size > 0) {
avail_size = 1;
} else {
avail_size = (unsigned int)temp_size;
+
+ int sum = apps_size + pics_videos_size + audio_size + others_size;
+ if ((sum + avail_size) > width) {
+ avail_size = width - sum;
+ }
}
if (avail_size > 0) {
- Evas_Object *avail = NULL;
- avail = evas_object_image_add(evas);
- evas_object_size_hint_weight_set(avail, 0.0, EVAS_HINT_EXPAND);
- evas_object_image_load_size_set(avail, avail_size, height);
- evas_object_image_file_set(avail, SETTING_STORAGE_AVAIL_ICON_PATH, NULL);
- evas_object_image_fill_set(avail, 0, 0, avail_size, height);
- evas_object_size_hint_min_set(avail, avail_size, height);
- evas_object_show(avail);
+ Evas_Object *avail = __setting_storage_main_image_add(evas, SETTING_STORAGE_AVAIL_ICON_PATH, avail_size, height);
elm_box_pack_end(status_box, avail);
}
return SETTING_RETURN_SUCCESS;
}
-static int __setting_storage_main_file_stat_get(const char *filename, Node_Info **node)
+static int __setting_storage_status_size_transition(double size, char *size_desc)
{
- setting_retvm_if(!filename || !node, SETTING_RETURN_FAIL, "NULL input parameters");
- struct stat statbuf;
- if (stat(filename, &statbuf) == -1) {
- SETTING_TRACE_ERROR("failed to call stat");
- return SETTING_RETURN_FAIL;
- }
-
- if (*node == NULL) {
- SETTING_TRACE_ERROR("node is NULL");
- return SETTING_RETURN_FAIL;
+ //SETTING_TRACE_BEGIN;
+ //SETTING_TRACE("size = %f", size);
+ double tmp_size = 0.0;
+ int ret = 0;
+ if (size < SETTING_STORAGE_MEGABYTE_VALUE) { // size < 1MB: show x.xKB
+ tmp_size = size / SETTING_STORAGE_KILOBYTE_VALUE;
+ ret = snprintf(size_desc, SETTING_STORAGE_MAX_STR_LEN, "%4.2lf%s", tmp_size, "KB");
+ retv_if(ret < 0, SETTING_RETURN_FAIL);
+ } else if (size < SETTING_STORAGE_GIGABYTE_VALUE) { // size < 1GB: show x.xMB
+ tmp_size = size / SETTING_STORAGE_MEGABYTE_VALUE;
+ ret = snprintf(size_desc, SETTING_STORAGE_MAX_STR_LEN, "%4.2lf%s", tmp_size, "MB");
+ retv_if(ret < 0, SETTING_RETURN_FAIL);
+ } else { // 1G <= size: show x.xGB
+ tmp_size = size / SETTING_STORAGE_GIGABYTE_VALUE;
+ ret = snprintf(size_desc, SETTING_STORAGE_MAX_STR_LEN, "%4.2lf%s", tmp_size, "GB");
+ retv_if(ret < 0, SETTING_RETURN_FAIL);
}
- (*node)->size = statbuf.st_size;
-
return SETTING_RETURN_SUCCESS;
}
-static int __setting_storage_main_file_list_get(char *path, Eina_List **dir_list, Eina_List **file_list)
+
+static void __setting_storage_main_internal_storage_status_get(void *data)
{
SETTING_TRACE_BEGIN;
- setting_retvm_if(NULL == path, SETTING_RETURN_FAIL, "path is NULL");
-
- DIR *pDir = NULL;
- struct dirent *ent = NULL;
- char childpath[SETTING_STORAGE_CHILDPATH_LEN] = {0,};
-
- pDir = opendir(path);
- setting_retvm_if(NULL == pDir, SETTING_RETURN_FAIL, "pDir is NULL");
+ setting_retm_if(data == NULL, "Data parameter is NULL");
+ SettingStorageUG *ad = (SettingStorageUG *) data;
- while ((ent = readdir(pDir)) != NULL) {
- if (safeStrCmp(ent->d_name, ".") == 0 || safeStrCmp(ent->d_name, "..") == 0) {
- continue;
- }
- /*only deal with dirs and regular files*/
- if ((ent->d_type & DT_DIR) == 0 && (ent->d_type & DT_REG) == 0) {
- continue;
- }
+ double dTotal = 0.0;
+ double dAvail = 0.0;
+ int ret = SETTING_RETURN_SUCCESS;
+ Setting_Storage_Status internal_status;
- Node_Info *pNode = (Node_Info *)malloc(sizeof(Node_Info));
+ ret = __setting_storage_main_fs_stat(&dTotal, &dAvail, SETTING_STORAGE_OPT_USR_PATH);
+ setting_retm_if(ret == SETTING_RETURN_FAIL, "get opt status failed");
+ internal_status.dTotal = dTotal;
+ internal_status.dAvail = dAvail;
- if (pNode == NULL) {
- continue;
- }
+ ad->internal_status = internal_status;
+}
- memset(pNode, 0, sizeof(Node_Info));
- /*get path*/
- g_strlcpy(pNode->path, path, (gsize) sizeof(pNode->path));
+static bool __setting_storage_main_media_item_cb(media_info_h media, void *data)
+{
+ //SETTING_TRACE_BEGIN;
+ setting_retvm_if(media == NULL, true, "media is NULL");
+ setting_retvm_if(data == NULL, true, "Data parameter is NULL");
+ double *total_size = (double *) data;
- /*get name*/
- g_strlcpy(pNode->name, ent->d_name, (gsize) sizeof(pNode->name));
+ unsigned long long size = 0;
- /*get size*/
- int copiednum = g_sprintf(childpath, "%s/%s", path, ent->d_name);
- if (copiednum < 0) {
- FREE(pNode);
- continue;
- }
- if (__setting_storage_main_file_stat_get(childpath, &pNode) == SETTING_RETURN_FAIL) {
- FREE(pNode);
- continue;
- }
+ char *file_path = NULL;
+ media_info_get_file_path(media, &file_path);
- if (ent->d_type & DT_DIR) {
- *dir_list = eina_list_append(*dir_list, pNode);
- } else {
- *file_list = eina_list_append(*file_list, pNode);
- }
+ if (!ecore_file_exists(file_path)) {
+ FREE(file_path);
+ return true;
}
- closedir(pDir);
+ FREE(file_path);
- return SETTING_RETURN_SUCCESS;
-}
-
-static int __setting_storage_main_list_len_get(const Eina_List *list)
-{
- if (list == NULL)
- return 0;
+ media_info_get_size(media, &size);
+ //SETTING_TRACE("size : [%lld]", size);
+ *total_size += size;
- return eina_list_count(list);
+ return true;
}
-static long __setting_storage_main_folder_size_get(char *path)
+static double __setting_storage_main_pictures_videos_status_get()
{
SETTING_TRACE_BEGIN;
- setting_retvm_if(NULL == path, SETTING_RETURN_FAIL, "path is NULL");
+ double total_size = 0.0;
- unsigned long size = 0;
- Eina_List *file_list = NULL;
- Eina_List *dir_list = NULL;
+ int ret = MEDIA_CONTENT_ERROR_NONE;
+ filter_h filter = NULL;
- if (ecore_file_is_dir(path)) {
- int ret = SETTING_RETURN_FAIL;
- ret = __setting_storage_main_file_list_get(path, &dir_list, &file_list);
+ /*Set Filter*/
+ char *condition = "(MEDIA_TYPE=0 OR MEDIA_TYPE=1) and MEDIA_PATH LIKE \'/opt/usr/%%\'"; /*0-image, 1-video, 2-sound, 3-music, 4-other*/
- if (ret == SETTING_RETURN_SUCCESS) {
- int i = 0;
- int dir_list_len = __setting_storage_main_list_len_get(dir_list);
- int file_list_len = __setting_storage_main_list_len_get(file_list);
- SETTING_TRACE("dir_list_len is [%d] file_list_len is [%d]", dir_list_len, file_list_len);
- for (i = 0; i < file_list_len; i++) {
- Node_Info *pNode = NULL;
- pNode = (Node_Info *)eina_list_nth(file_list, i);
- if (pNode == NULL)
- continue;
- size += pNode->size;
- }
- for (i = 0; i < dir_list_len; i++) {
- Node_Info *pNode = NULL;
- char *full_path = NULL;
- pNode = (Node_Info *)eina_list_nth(dir_list, i);
- if (pNode == NULL)
- continue;
- full_path = g_strconcat(pNode->path, "/", pNode->name, NULL);
- SETTING_TRACE("full_path is [%s]", full_path);
- size += (__setting_storage_main_folder_size_get(full_path));
- FREE(full_path);
- }
- }
+ ret = media_filter_create(&filter);
+ if(ret != MEDIA_CONTENT_ERROR_NONE) {
+ SETTING_TRACE_ERROR("Fail to create filter");
+ return total_size;
}
- if (file_list) {
- eina_list_free(file_list);
- file_list = NULL;
+ ret = media_filter_set_condition(filter, condition, MEDIA_CONTENT_COLLATE_DEFAULT);
+ if(ret != MEDIA_CONTENT_ERROR_NONE) {
+ media_filter_destroy(filter);
+ SETTING_TRACE_ERROR("Fail to set condition");
+ return total_size;
}
- if (dir_list) {
- eina_list_free(dir_list);
- dir_list = NULL;
+ ret = media_info_foreach_media_from_db(filter, __setting_storage_main_media_item_cb, &total_size);
+ if(ret != MEDIA_CONTENT_ERROR_NONE) {
+ media_filter_destroy(filter);
+ SETTING_TRACE_ERROR("Fail to get media");
+ return total_size;
}
- return size;
+ ret = media_filter_destroy(filter);
+ if (ret != MEDIA_CONTENT_ERROR_NONE) {
+ SETTING_TRACE_ERROR("destroy filter failed\n\n");
+ return total_size;
+ }
+
+ return total_size;
}
-static int __setting_storage_status_size_transition(double size, char *size_desc)
+static double __setting_storage_main_audio_status_get()
{
SETTING_TRACE_BEGIN;
- SETTING_TRACE("size = %f", size);
- double tmp_size = 0.0;
- int ret = 0;
- if (size < SETTING_STORAGE_MEGABYTE_VALUE) { // size < 1MB: show x.xKB
- tmp_size = size / SETTING_STORAGE_KILOBYTE_VALUE;
- ret = snprintf(size_desc, SETTING_STORAGE_MAX_STR_LEN, "%4.2lf%s", tmp_size, "KB");
- retv_if(ret < 0, SETTING_RETURN_FAIL);
- } else if (size < SETTING_STORAGE_GIGABYTE_VALUE) { // size < 1GB: show x.xMB
- tmp_size = size / SETTING_STORAGE_MEGABYTE_VALUE;
- ret = snprintf(size_desc, SETTING_STORAGE_MAX_STR_LEN, "%4.2lf%s", tmp_size, "MB");
- retv_if(ret < 0, SETTING_RETURN_FAIL);
- } else { // 1G <= size: show x.xGB
- tmp_size = size / SETTING_STORAGE_GIGABYTE_VALUE;
- ret = snprintf(size_desc, SETTING_STORAGE_MAX_STR_LEN, "%4.2lf%s", tmp_size, "GB");
- retv_if(ret < 0, SETTING_RETURN_FAIL);
- }
- return SETTING_RETURN_SUCCESS;
-}
+ double total_size = 0.0;
+ int ret = MEDIA_CONTENT_ERROR_NONE;
+ filter_h filter = NULL;
-static void __setting_storage_main_internal_storage_status_get(void *data)
-{
- SETTING_TRACE_BEGIN;
- setting_retm_if(data == NULL, "Data parameter is NULL");
- SettingStorageUG *ad = (SettingStorageUG *) data;
+ /*Set Filter*/
+ char *condition = "MEDIA_TYPE=3 and MEDIA_PATH LIKE \'/opt/usr/%%\'"; /*0-image, 1-video, 2-sound, 3-music, 4-other*/
- double dTotal = 0.0;
- double dAvail = 0.0;
- int ret = SETTING_RETURN_SUCCESS;
- Setting_Storage_Status internal_status;
+ ret = media_filter_create(&filter);
+ if(ret != MEDIA_CONTENT_ERROR_NONE) {
+ SETTING_TRACE("Fail to create filter");
+ return total_size;
+ }
- ret = __setting_storage_main_fs_stat(&dTotal, &dAvail, SETTING_STORAGE_OPT_PATH);
- setting_retm_if(ret == SETTING_RETURN_FAIL, "get opt status failed");
- internal_status.dTotal = dTotal;
- internal_status.dAvail = dAvail;
+ ret = media_filter_set_condition(filter, condition, MEDIA_CONTENT_COLLATE_DEFAULT);
+ if(ret != MEDIA_CONTENT_ERROR_NONE) {
+ media_filter_destroy(filter);
+ SETTING_TRACE("Fail to set condition");
+ return total_size;
+ }
- dTotal = 0.0;
- dAvail = 0.0;
- ret = __setting_storage_main_fs_stat(&dTotal, &dAvail, SETTING_STORAGE_MEDIA_PATH);
- setting_retm_if(ret == SETTING_RETURN_FAIL, "get media status failed");
- internal_status.dTotal += dTotal;
- internal_status.dAvail += dAvail;
+ ret = media_info_foreach_media_from_db(filter, __setting_storage_main_media_item_cb, &total_size);
+ if(ret != MEDIA_CONTENT_ERROR_NONE) {
+ media_filter_destroy(filter);
+ SETTING_TRACE("Fail to get media");
+ return total_size;
+ }
- ad->internal_status = internal_status;
+ ret = media_filter_destroy(filter);
+ if (ret != MEDIA_CONTENT_ERROR_NONE) {
+ SETTING_TRACE_ERROR("destroy filter failed\n\n");
+ return total_size;
+ }
+
+ return total_size;
}
-static void __setting_storage_main_pictures_videos_status_get(void *data)
+static bool __setting_storage_main_other_item_cb(media_info_h media, void *data)
{
- SETTING_TRACE_BEGIN;
- setting_retm_if(data == NULL, "Data parameter is NULL");
- SettingStorageUG *ad = (SettingStorageUG *) data;
-
- double dTotal = 0.0;
- int ret = SETTING_RETURN_SUCCESS;
- Setting_Storage_Status pics_videos_status;
+ //SETTING_TRACE_BEGIN;
+ setting_retvm_if(media == NULL, true, "media is NULL");
+ setting_retvm_if(data == NULL, true, "Data parameter is NULL");
+ double *total_size = (double *) data;
- dTotal = __setting_storage_main_folder_size_get(SETTING_STORAGE_PICTURES_PATH);
- setting_retm_if(ret == SETTING_RETURN_FAIL, "get pictures status failed");
- pics_videos_status.dTotal = dTotal;
- //SETTING_TRACE("pics_videos_status = %f", dTotal);
+ unsigned long long size = 0;
- dTotal = 0.0;
- dTotal = __setting_storage_main_folder_size_get(SETTING_STORAGE_VIDEOS_PATH);
- setting_retm_if(ret == SETTING_RETURN_FAIL, "get video status failed");
- //SETTING_TRACE("pics_videos_status = %f", dTotal);
- pics_videos_status.dTotal += dTotal;
+ char *file_path = NULL;
+ media_info_get_file_path(media, &file_path);
- //SETTING_TRACE("pics_videos_status = %f", pics_videos_status.dTotal);
+ if (!ecore_file_exists(file_path)) {
+ FREE(file_path);
+ return true;
+ }
- ad->pics_videos_status = pics_videos_status;
+ if (!safeStrNCmp(file_path, PATH1, sizeof(PATH1)) ||
+ !safeStrNCmp(file_path, PATH2, sizeof(PATH2)) ||
+ !safeStrNCmp(file_path, PATH3, sizeof(PATH3)) ||
+ !safeStrNCmp(file_path, PATH4, sizeof(PATH4)) ||
+ !safeStrNCmp(file_path, PATH5, sizeof(PATH5)) ||
+ !safeStrNCmp(file_path, PATH6, sizeof(PATH6)) ||
+ !safeStrNCmp(file_path, PATH7, sizeof(PATH7)) ||
+ !safeStrNCmp(file_path, PATH8, sizeof(PATH8)) ||
+ !safeStrNCmp(file_path, PATH9, sizeof(PATH9)))
+ {
+ FREE(file_path);
+ return true;
+ }
+
+ media_info_get_size(media, &size);
+ //SETTING_TRACE("size : [%lld]", size);
+ *total_size += size;
+ FREE(file_path);
+ return true;
}
-static void __setting_storage_main_downloads_status_get(void *data)
+/**
+ * Miscellaneous files is all directories files under /opt/usr/media/ except below default directories:
+ * ++++++++++++++++++++++++++++++++++++++++++++++++
+ * -sh-4.1# ls -all
+ * total 56
+ * drwxrwxrwx 11 app app 4096 Jan 4 12:42 .
+ * drwxr-xr-x 20 root root 4096 Jan 7 10:09 ..
+ * drwxr-xr-x 2 root root 4096 Jan 4 08:46 .tmp_download
+ * drwxr-xr-x 2 app app 4096 Jan 4 08:47 .video-hub
+ * drwxrwxrwx 2 app app 4096 Oct 5 2012 Camera
+ * drwxrwxrwx 3 app app 4096 Jan 4 08:46 Downloads
+ * drwxrwxrwx 2 app app 4096 Oct 5 2012 Images
+ * drwxrwxrwx 2 app app 4096 Oct 5 2012 Others
+ * drwxrwxrwx 3 app app 4096 Oct 5 2012 Sounds
+ * drwxrwxrwx 2 app app 4096 Oct 5 2012 Videos
+ * drwxrwxrwx 2 app app 16384 Oct 5 2012 lost+found
+ * ++++++++++++++++++++++++++++++++++++++++++++++++
+ */
+static double __setting_storage_main_miscellaneous_size_get()
{
SETTING_TRACE_BEGIN;
- setting_retm_if(data == NULL, "Data parameter is NULL");
- SettingStorageUG *ad = (SettingStorageUG *) data;
+ double total_size = 0.0;
- double dTotal = 0.0;
- int ret = SETTING_RETURN_SUCCESS;
- Setting_Storage_Status downloads_status;
+ int ret = MEDIA_CONTENT_ERROR_NONE;
+ filter_h filter = NULL;
+
+ /*Set Filter*/
+ char *condition = "(MEDIA_TYPE=4) and MEDIA_PATH LIKE \'/opt/usr/media/%%\'";
+
+ ret = media_filter_create(&filter);
+ if(ret != MEDIA_CONTENT_ERROR_NONE) {
+ SETTING_TRACE_ERROR("Fail to create filter");
+ return total_size;
+ }
+
+ ret = media_filter_set_condition(filter, condition, MEDIA_CONTENT_COLLATE_DEFAULT);
+ if(ret != MEDIA_CONTENT_ERROR_NONE) {
+ media_filter_destroy(filter);
+ SETTING_TRACE_ERROR("Fail to set condition");
+ return total_size;
+ }
- dTotal = __setting_storage_main_folder_size_get(SETTING_STORAGE_DOWNLOADS_PATH);
- setting_retm_if(ret == SETTING_RETURN_FAIL, "get pictures status failed");
- downloads_status.dTotal = dTotal;
+ ret = media_info_foreach_media_from_db(filter, __setting_storage_main_other_item_cb, &total_size);
+ if(ret != MEDIA_CONTENT_ERROR_NONE) {
+ media_filter_destroy(filter);
+ SETTING_TRACE_ERROR("Fail to get media");
+ return total_size;
+ }
- //SETTING_TRACE("downloads_status = %f", dTotal);
+ ret = media_filter_destroy(filter);
+ if (ret != MEDIA_CONTENT_ERROR_NONE) {
+ SETTING_TRACE_ERROR("destroy filter failed");
+ return total_size;
+ }
- ad->downloads_status = downloads_status;
+ return total_size;
}
static void __setting_storage_main_launch_ug_destroy_cb(ui_gadget_h ug, void *priv)
if (back_btn != NULL) {
elm_object_style_set(back_btn, NAVI_BACK_BUTTON_STYLE); /* take into effect */
}
+
+ setting_view_update(&setting_view_storage_main, ad);
}
static void __setting_storage_main_launch_ug_layout_cb(ui_gadget_h ug, enum ug_mode mode, void *priv)
switch (mode) {
case UG_MODE_FULLVIEW:
evas_object_size_hint_weight_set(base, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
- elm_win_resize_object_add(ad->win_get, base);
+ //elm_win_resize_object_add(ad->win_get, base);
evas_object_show(base);
break;
default:
FREE(cbs);
}
+static void __setting_storage_main_app_launch(char *app_name)
+{
+ SETTING_TRACE_BEGIN;
+ setting_retm_if(app_name == NULL, "app_name is NULL");
+
+ app_launcher(app_name);
+}
+
static void __setting_storage_main_Gendial_mouse_up_cb(void *data, Evas_Object *obj, void *event_info)
{
SETTING_TRACE_BEGIN;
SETTING_TRACE("clicking item[%s]", _(list_item->keyStr));
- if (!safeStrCmp("IDS_ST_BODY_APPLICATIONS", list_item->keyStr)) {
- __setting_storage_main_launch_manage_app_ug(ad);
+ if (isEmulBin()) {
+ if (!safeStrCmp(SETTING_STORAGE_DEFAULT_STORAGE_STR, list_item->keyStr)) {
+ setting_view_change(&setting_view_storage_main,
+ &setting_view_storage_default_storage, ad);
+ } else if (!safeStrCmp(SETTING_STORAGE_MISCES_STR, list_item->keyStr)) {
+ setting_view_change(&setting_view_storage_main,
+ &setting_view_storage_miscellaneous_files, ad);
+ } else {
+ // do nothing now
+ }
} else {
- // do nothing now
+ if (!safeStrCmp("IDS_ST_BODY_APPLICATIONS", list_item->keyStr)) {
+ __setting_storage_main_launch_manage_app_ug(ad);
+ } else if (!safeStrCmp(SETTING_STORAGE_DEFAULT_STORAGE_STR, list_item->keyStr)) {
+ setting_view_change(&setting_view_storage_main,
+ &setting_view_storage_default_storage, ad);
+ } else if (!safeStrCmp(SETTING_STORAGE_PICS_STR, list_item->keyStr)) {
+ __setting_storage_main_app_launch("org.tizen.gallery");
+ } else if (!safeStrCmp(SETTING_STORAGE_AUDIO_STR, list_item->keyStr)) {
+ __setting_storage_main_app_launch("org.tizen.music-player");
+ } else if (!safeStrCmp(SETTING_STORAGE_MISCES_STR, list_item->keyStr)) {
+ setting_view_change(&setting_view_storage_main,
+ &setting_view_storage_miscellaneous_files, ad);
+ } else {
+ // do nothing now
+ }
}
}
-/* ***************************************************
- *
- *basic func
- *
- ***************************************************/
-static int setting_storage_main_create(void *cb)
+static int __setting_storage_main_check_mmc_status()
{
- SETTING_TRACE_BEGIN;
- /* error check */
- retv_if(cb == NULL, SETTING_GENERAL_ERR_NULL_DATA_PARAMETER);
+ int ret = 0;
+ struct stat parent_stat, mount_stat;
- SettingStorageUG *ad = (SettingStorageUG *) cb;
+ ret = stat(SETTING_STORAGE_MMC_PATH, &mount_stat);
+ setting_retvm_if(ret != 0, -1, "get stat error : /opt/storage/sdcard");
- retvm_if(ad->win_main_layout == NULL, SETTING_DRAW_ERR_FAIL_LOAD_EDJ,
- "win_main_layout is NULL");
+ ret = stat(SETTING_STORAGE_MMC_PARENT_PATH, &parent_stat);
+ setting_retvm_if(ret != 0, -1, "get stat error : /opt/storage/sdcard/..");
- int ret = SETTING_RETURN_SUCCESS;
+ /* Does not mounted, same st_dev */
+ if(mount_stat.st_dev == parent_stat.st_dev) {
+ return 0;
+ } else { /* MMC mounted, diff st_dev */
+ return 1;
+ }
+}
- ad->ly_main =
- setting_create_layout_navi_bar_genlist(ad->win_main_layout,
- ad->win_get,
- _(KeyStr_Storage),
- _("IDS_COM_BODY_BACK"),
- NULL,
- __setting_storage_main_click_softkey_back_cb,
- NULL,
- ad, &ad->genlist, &ad->navibar);
+static void __setting_storage_main_sd_card_info_get(char* szTotal, char* szAvail)
+{
+ int mmc_status = __setting_storage_main_check_mmc_status();
+ setting_retm_if(mmc_status == -1, "check mmc status failed");
- setting_create_Gendial_field_titleItem(ad->genlist, &(ad->itc_group_item),
- SETTING_STORAGE_INTERNAL_STORAGE_STR,
- NULL);
+ /* Does not mounted, same st_dev */
+ if (mmc_status == 0) {
+ snprintf(szTotal, SETTING_STORAGE_MAX_STR_LEN, "%s", _("IDS_ST_HEADER_UNAVAILABLE"));
+ snprintf(szAvail, SETTING_STORAGE_MAX_STR_LEN, "%s", _("IDS_ST_HEADER_UNAVAILABLE"));
+ }
+ /* MMC mounted, diff st_dev */
+ else {
+ double dTotal = 0.0;
+ double dAvail = 0.0;
- ad->itc_2text_1icon_4.item_style = "dialogue/2text.1icon.4";
- ad->itc_2text_1icon_4.func.text_get = __gl_text_get;
- ad->itc_2text_1icon_4.func.content_get = __gl_content_get;
- ad->itc_2text_1icon_4.func.state_get = NULL;
- ad->itc_2text_1icon_4.func.del = __gl_del;
+ int ret = SETTING_RETURN_SUCCESS;
+ ret = __setting_storage_main_fs_stat(&dTotal, &dAvail, SETTING_STORAGE_MMC_PATH);
+ setting_retm_if(ret == SETTING_RETURN_FAIL, "get sd card size detail failed");
- __setting_storage_main_internal_storage_status_get(ad);
+ ret = __setting_storage_status_size_transition(dTotal, szTotal);
+ setting_retm_if(ret == SETTING_RETURN_FAIL, "__setting_storage_status_size_transition failed");
- __setting_storage_main_pictures_videos_status_get(ad);
+ ret = __setting_storage_status_size_transition(dAvail, szAvail);
+ setting_retm_if(ret == SETTING_RETURN_FAIL, "__setting_storage_status_size_transition failed");
- __setting_storage_main_downloads_status_get(ad);
+ SETTING_TRACE("Total[%s], Avail[%s]", szTotal, szAvail);
+ }
+}
- /* Total space */
- char total_desc[SETTING_STORAGE_MAX_STR_LEN + 1] = {0,};
- ret = __setting_storage_status_size_transition(ad->internal_status.dTotal, total_desc);
- setting_retvm_if(ret == SETTING_RETURN_FAIL, SETTING_RETURN_FAIL, "failed to transform")
+static int __setting_storage_main_mmc_content_init(void *data, setting_storage_mmc_cb cb)
+{
+ SETTING_TRACE_BEGIN;
+ setting_retvm_if(NULL == data, SETTING_RETURN_FAIL, "data is NULL");
+ setting_retvm_if(NULL == cb, SETTING_RETURN_FAIL, "cb is NULL");
+ SettingStorageUG *ad = (SettingStorageUG *)data;
+ if (ad->mmc_content == NULL) {
+ ad->mmc_content = (struct mmc_contents *)calloc(1, sizeof(struct mmc_contents *));
+ if (ad->mmc_content == NULL ) {
+ SETTING_TRACE_ERROR("calloc failed");
+ return SETTING_RETURN_FAIL;
+ }
+ }
+ ad->mmc_content->mmc_cb = cb;
+ ad->mmc_content->user_data = ad;
+ return SETTING_RETURN_SUCCESS;
+}
- /* status */
- ad->internal = (Setting_GenGroupItem_Data *) calloc(1, sizeof(Setting_GenGroupItem_Data));
- setting_retvm_if(!ad->internal, SETTING_RETURN_FAIL, "calloc failed");
+#if SUPPORT_SD_CARD_FORMAT
+static void __setting_storage_status_sd_card_popup_format_response_cb(void *data,
+ Evas_Object *obj, void *event_info)
+{
+ SETTING_TRACE_BEGIN;
+ setting_retm_if(data == NULL, "Data parameter is NULL");
+ SettingStorageUG *ad = (SettingStorageUG *)data;
- if (ad->internal) {
- ad->internal->userdata = ad;
- ad->internal->keyStr = (char *)g_strdup(total_desc);
- ad->internal->item = elm_genlist_item_append(ad->genlist, &(ad->itc_2text_1icon_4), ad->internal, NULL,
- ELM_GENLIST_ITEM_NONE, NULL, NULL);
- elm_genlist_item_select_mode_set(ad->internal->item, ELM_OBJECT_SELECT_MODE_DISPLAY_ONLY);
- } else {
- SETTING_TRACE_ERROR("ad->internal is NULL");
- return SETTING_RETURN_FAIL;
+ if (ad->popup) {
+ evas_object_del(ad->popup);
+ ad->popup = NULL;
}
- /* Applications */
- ad->apps_status.dTotal = 230.45 * 1024 * 1024; /* for test*/
- char apps_desc[SETTING_STORAGE_MAX_STR_LEN + 1] = {0,};
- ret = __setting_storage_status_size_transition(ad->apps_status.dTotal, apps_desc);
- setting_retvm_if(ret == SETTING_RETURN_FAIL, SETTING_RETURN_FAIL, "failed to transform")
+ char sd_total[SETTING_STORAGE_MAX_STR_LEN] = { 0, };
+ char sd_available[SETTING_STORAGE_MAX_STR_LEN] = { 0, };
+ __setting_storage_main_sd_card_info_get(sd_total, sd_available);
- ad->apps = setting_create_Gendial_field_def(ad->genlist, &(ad->itc_2text_1icon_3),
- __setting_storage_main_Gendial_mouse_up_cb,
- ad, SWALLOW_Type_INVALID, SETTING_STORAGE_APPS_ICON_PATH,
- NULL, 0, "IDS_ST_BODY_APPLICATIONS",
- apps_desc, NULL);
- if (ad->apps) {
- ad->apps->userdata = ad;
- } else {
- SETTING_TRACE_ERROR("ad->apps is NULL");
- return SETTING_RETURN_FAIL;
+ if (ad->sd_total) {
+ G_FREE(ad->sd_total->sub_desc);
+ ad->sd_total->sub_desc = (char *)g_strdup(sd_total);
+ elm_object_item_data_set(ad->sd_total->item, ad->sd_total);
+ elm_genlist_item_update(ad->sd_total->item);
}
-
- /* Pictures, Videos */
- char pics_videos_desc[SETTING_STORAGE_MAX_STR_LEN + 1] = {0,};
- ret = __setting_storage_status_size_transition(ad->pics_videos_status.dTotal, pics_videos_desc);
- setting_retvm_if(ret == SETTING_RETURN_FAIL, SETTING_RETURN_FAIL, "failed to transform")
- ad->pics_videos = setting_create_Gendial_field_def(ad->genlist, &(ad->itc_2text_1icon_3), NULL,
- ad, SWALLOW_Type_INVALID, SETTING_STORAGE_PICS_ICON_PATH,
- NULL, 0, SETTING_STORAGE_PICS_STR,
- pics_videos_desc, NULL);
- if (ad->pics_videos) {
- ad->pics_videos->userdata = ad;
- elm_genlist_item_select_mode_set(ad->pics_videos->item, ELM_OBJECT_SELECT_MODE_DISPLAY_ONLY);
- } else {
- SETTING_TRACE_ERROR("ad->pics_videos is NULL");
- return SETTING_RETURN_FAIL;
+ if (ad->sd_available) {
+ G_FREE(ad->sd_available->sub_desc);
+ ad->sd_available->sub_desc = (char *)g_strdup(sd_available);
+ elm_object_item_data_set(ad->sd_available->item, ad->sd_available);
+ elm_genlist_item_update(ad->sd_available->item);
}
+}
+#endif
- /* Downloads */
- char downloads_desc[SETTING_STORAGE_MAX_STR_LEN + 1] = {0,};
- ret = __setting_storage_status_size_transition(ad->downloads_status.dTotal, downloads_desc);
- setting_retvm_if(ret == SETTING_RETURN_FAIL, SETTING_RETURN_FAIL, "failed to transform")
- ad->downloads = setting_create_Gendial_field_def(ad->genlist, &(ad->itc_2text_1icon_3), NULL,
- ad, SWALLOW_Type_INVALID, SETTING_STORAGE_DOWNS_ICON_PATH,
- NULL, 0, SETTING_STORAGE_DOWNS_STR,
- downloads_desc,
- NULL);
- if (ad->downloads) {
- ad->downloads->userdata = ad;
- elm_genlist_item_select_mode_set(ad->downloads->item, ELM_OBJECT_SELECT_MODE_DISPLAY_ONLY);
- } else {
- SETTING_TRACE_ERROR("ad->downloads is NULL");
- return SETTING_RETURN_FAIL;
+static void __setting_storage_status_sd_card_popup_response_cb(void *data,
+ Evas_Object *obj, void *event_info)
+{
+ SETTING_TRACE_BEGIN;
+ setting_retm_if(data == NULL, "Data parameter is NULL");
+ SettingStorageUG *ad = (SettingStorageUG *)data;
+
+ if (ad->popup) {
+ evas_object_del(ad->popup);
+ ad->popup = NULL;
}
+}
- /* Miscellaneous files */
- ad->others_status.dTotal = ad->internal_status.dTotal - ad->internal_status.dAvail
- - ad->apps_status.dTotal - ad->pics_videos_status.dTotal - ad->downloads_status.dTotal;
- ad->others_status.dAvail = 0.0;
- char others_desc[SETTING_STORAGE_MAX_STR_LEN + 1] = {0,};
- ret = __setting_storage_status_size_transition(ad->others_status.dTotal, others_desc);
- setting_retvm_if(ret == SETTING_RETURN_FAIL, SETTING_RETURN_FAIL, "failed to transform")
+static void __setting_storage_main_sd_card_mount_cb(int val, void *data)
+{
+ SETTING_TRACE_BEGIN;
+ setting_retm_if(data == NULL, "Data parameter is NULL");
+ SettingStorageUG *ad = (SettingStorageUG *) data;
- ad->others = setting_create_Gendial_field_def(ad->genlist, &(ad->itc_2text_1icon_3), NULL,
- ad, SWALLOW_Type_INVALID, SETTING_STORAGE_MISCES_ICON_PATH,
- NULL, 0, SETTING_STORAGE_MISCES_STR,
- others_desc, NULL);
- if (ad->others) {
- ad->others->userdata = ad;
- elm_genlist_item_select_mode_set(ad->others->item, ELM_OBJECT_SELECT_MODE_DISPLAY_ONLY);
+ if (ad->popup) {
+ evas_object_del(ad->popup);
+ ad->popup = NULL;
+ }
+
+ char *desc = NULL;
+ if (val == SETTING_STORAGE_SYSMAN_REQUEST_SUCCESS) {
+ /* do nothing */
+ SETTING_TRACE("mount success");
+ return;
+ } else if (val == SETTING_STORAGE_SYSMAN_REQUEST_MOUNT_ALREADY) {
+ desc = _(SETTING_STORAGE_SD_CARD_MOUNT_ALREADY_DESC);
} else {
- SETTING_TRACE_ERROR("ad->others is NULL");
- return SETTING_RETURN_FAIL;
+ desc = _("IDS_COM_POP_FAILED");
}
- /* Available */
- char avail_desc[SETTING_STORAGE_MAX_STR_LEN + 1] = {0,};
- ret = __setting_storage_status_size_transition(ad->internal_status.dAvail, avail_desc);
- setting_retvm_if(ret == SETTING_RETURN_FAIL, SETTING_RETURN_FAIL, "failed to transform")
+ ad->popup = setting_create_popup_without_btn(ad, ad->win_get, NULL, desc,
+ __setting_storage_status_sd_card_popup_response_cb,
+ SETTING_STORAGE_POPUP_TIMER, FALSE, FALSE);
+}
+
+static void __setting_storage_main_sd_card_unmount_cb(int val, void *data)
+{
+ SETTING_TRACE_BEGIN;
+ setting_retm_if(data == NULL, "Data parameter is NULL");
+ SettingStorageUG *ad = (SettingStorageUG *) data;
+
+ if (ad->popup) {
+ evas_object_del(ad->popup);
+ ad->popup = NULL;
+ }
+
+ if (val == SETTING_STORAGE_SYSMAN_REQUEST_SUCCESS) {
+ /* do nothing */
+ SETTING_TRACE("unmount success");
+ return;
+ } else {
+ ad->popup = setting_create_popup_without_btn(ad, ad->win_get, NULL, _("IDS_COM_POP_FAILED"),
+ __setting_storage_status_sd_card_popup_response_cb,
+ SETTING_STORAGE_POPUP_TIMER, FALSE, FALSE);
+ }
+}
+
+static void __setting_storage_main_sd_card_mount_unmount(void *data)
+{
+ SETTING_TRACE_BEGIN;
+ setting_retm_if(data == NULL, "Data parameter is NULL");
+ SettingStorageUG *ad = (SettingStorageUG *)data;
+
+ int mmc_status = __setting_storage_main_check_mmc_status();
+ setting_retm_if(mmc_status == -1, "check mmc status failed");
+
+ if (ad->popup) {
+ evas_object_del(ad->popup);
+ ad->popup = NULL;
+ }
+
+ /* Show progressbar popup */
+ ad->popup = setting_create_popup_with_progressbar(ad, ad->win_get,
+ "pending_list", NULL, NULL,
+ __setting_storage_status_sd_card_popup_response_cb,
+ SETTING_STORAGE_PROGRESSBAR_TIMEOUT, TRUE, TRUE);
+
+ int ret = -1;
+ /* Does not mounted, same st_dev */
+ if (mmc_status == 0) {
+ ret = __setting_storage_main_mmc_content_init(ad, __setting_storage_main_sd_card_mount_cb);
+ if (ret == SETTING_RETURN_FAIL) {
+ SETTING_TRACE_ERROR("__setting_storage_main_mmc_content_init fail");
+ if (ad->popup) {
+ evas_object_del(ad->popup);
+ ad->popup = NULL;
+ }
+ ad->popup = setting_create_popup_without_btn(ad, ad->win_get,
+ NULL, _("IDS_COM_POP_FAILED"),
+ __setting_storage_status_sd_card_popup_response_cb,
+ SETTING_STORAGE_POPUP_TIMER, FALSE, FALSE);
+ return;
+ }
+ ret = sysman_request_mount_mmc(ad->mmc_content);
+ if (ret == -1) {
+ SETTING_TRACE_ERROR("fail to call sysman_request_mount_mmc");
+ }
+ }
+ /* MMC mounted, diff st_dev */
+ else {
+ ret = __setting_storage_main_mmc_content_init(ad, __setting_storage_main_sd_card_unmount_cb);
+ if (ret == SETTING_RETURN_FAIL) {
+ SETTING_TRACE_ERROR("__setting_storage_main_sd_card_unmount_cb fail");
+ if (ad->popup) {
+ evas_object_del(ad->popup);
+ ad->popup = NULL;
+ }
+ ad->popup = setting_create_popup_without_btn(ad, ad->win_get,
+ NULL, _("IDS_COM_POP_FAILED"),
+ __setting_storage_status_sd_card_popup_response_cb,
+ SETTING_STORAGE_POPUP_TIMER, FALSE, FALSE);
+ return;
+ }
+
+ ret = sysman_request_unmount_mmc(ad->mmc_content,
+ MNT_FORCE); /* 1 = MNT_FORCE */
+ if (ret == -1) {
+ SETTING_TRACE_ERROR("fail to call sysman_request_unmount_mmc");
+ }
+ }
+
+ /* if fail, popup failed info */
+ if (ret == -1) {
+ if (ad->popup) {
+ evas_object_del(ad->popup);
+ ad->popup = NULL;
+ }
+ ad->popup = setting_create_popup_without_btn(ad, ad->win_get,
+ NULL, _("IDS_COM_POP_FAILED"),
+ __setting_storage_status_sd_card_popup_response_cb,
+ SETTING_STORAGE_POPUP_TIMER, FALSE, FALSE);
+ }
+}
+
+#if SUPPORT_SD_CARD_FORMAT
+static void __setting_storage_main_sd_card_scan_cb(media_content_error_e err, void *data)
+{
+ SETTING_TRACE_BEGIN;
+ setting_retm_if(data == NULL, "Data parameter is NULL");
+ SettingStorageUG *ad = (SettingStorageUG *) data;
+
+ SETTING_TRACE("scan_cb result = %d", err);
+
+ if (ad->popup) {
+ evas_object_del(ad->popup);
+ ad->popup = NULL;
+ }
+
+ if (err == MEDIA_CONTENT_ERROR_NONE) {
+ ad->popup = setting_create_popup_without_btn(ad, ad->win_get, NULL, _("IDS_COM_POP_SUCCESS"),
+ __setting_storage_status_sd_card_popup_format_response_cb,
+ SETTING_STORAGE_POPUP_TIMER, FALSE, FALSE);
+
+ } else {
+ ad->popup = setting_create_popup_without_btn(ad, ad->win_get, NULL, _("IDS_COM_POP_FAILED"),
+ __setting_storage_status_sd_card_popup_response_cb,
+ SETTING_STORAGE_POPUP_TIMER, FALSE, FALSE);
+ }
+}
+
+static void __setting_storage_main_sd_card_format_cb(int val, void *data)
+{
+ SETTING_TRACE_BEGIN;
+ setting_retm_if(data == NULL, "Data parameter is NULL");
+ SettingStorageUG *ad = (SettingStorageUG *) data;
+
+ if (val == SETTING_STORAGE_SYSMAN_REQUEST_SUCCESS) {
+ int ret = media_content_scan_folder(SETTING_STORAGE_MMC_PATH, __setting_storage_main_sd_card_scan_cb, ad);
+
+ if(ret != MEDIA_CONTENT_ERROR_NONE) {
+ SETTING_TRACE_ERROR("Fail to media_content_scan_file : %d", ret);
+ return;
+ }
+ } else {
+ if (ad->popup) {
+ evas_object_del(ad->popup);
+ ad->popup = NULL;
+ }
+ ad->popup = setting_create_popup_without_btn(ad, ad->win_get, NULL, _("IDS_COM_POP_FAILED"),
+ __setting_storage_status_sd_card_popup_response_cb,
+ SETTING_STORAGE_POPUP_TIMER, FALSE, FALSE);
+ }
+}
+
+static void __setting_storage_main_sd_card_format_popup_yes(void *data)
+{
+ SETTING_TRACE_BEGIN;
+ setting_retm_if(data == NULL, "Data parameter is NULL");
+ SettingStorageUG *ad = (SettingStorageUG *) data;
+
+ if (ad->popup) {
+ evas_object_del(ad->popup);
+ ad->popup = NULL;
+ }
+
+ /* Show Formatting..... popup */
+ ad->popup = setting_create_popup_with_progressbar(ad, ad->win_get,
+ "pending_list", NULL,
+ NULL, NULL,
+ 0, TRUE, TRUE);
+
+ int ret = __setting_storage_main_mmc_content_init(ad, __setting_storage_main_sd_card_format_cb);
+ if (ret == SETTING_RETURN_FAIL) {
+ SETTING_TRACE_ERROR("__setting_storage_main_mmc_content_init fail");
+ if (ad->popup) {
+ evas_object_del(ad->popup);
+ ad->popup = NULL;
+ }
+ ad->popup = setting_create_popup_without_btn(ad, ad->win_get,
+ NULL, _("IDS_COM_POP_FAILED"),
+ __setting_storage_status_sd_card_popup_response_cb,
+ SETTING_STORAGE_POPUP_TIMER, FALSE, FALSE);
+ return;
+ }
+
+ ret = sysman_request_format_mmc(ad->mmc_content);
+ /* if fail, destory popup */
+ if (ret == -1) {
+ SETTING_TRACE_ERROR("fail to call sysman_request_format_mmc");
+ if (ad->popup) {
+ evas_object_del(ad->popup);
+ ad->popup = NULL;
+ }
+ ad->popup = setting_create_popup_without_btn(ad, ad->win_get,
+ NULL, _("IDS_COM_POP_FAILED"),
+ __setting_storage_status_sd_card_popup_response_cb,
+ SETTING_STORAGE_POPUP_TIMER, FALSE, FALSE);
+ }
+}
+
+static void __setting_storage_main_sd_card_format_popup_no(void *data)
+{
+ SETTING_TRACE_BEGIN;
+ setting_retm_if(data == NULL, "Data parameter is NULL");
+ SettingStorageUG *ad = (SettingStorageUG *) data;
+
+ if (ad->popup) {
+ evas_object_del(ad->popup);
+ ad->popup = NULL;
+ }
+}
+
+static void __setting_storage_main_sd_card_ask_format_resp_cb(void *data, Evas_Object *obj, void *event_info)
+{
+ SETTING_TRACE_BEGIN;
+ setting_retm_if(data == NULL, "Data parameter is NULL");
+ int response_type = btn_type(obj);
+ if (POPUP_RESPONSE_OK == response_type) {
+ __setting_storage_main_sd_card_format_popup_yes(data);
+ } else if (POPUP_RESPONSE_CANCEL == response_type) {
+ __setting_storage_main_sd_card_format_popup_no(data);
+ }
+}
+
+static void __setting_storage_main_sd_card_format_popup_create(void *data)
+{
+ SETTING_TRACE_BEGIN;
+ setting_retm_if(data == NULL, "Data parameter is NULL");
+ SettingStorageUG *ad = (SettingStorageUG *) data;
+
+ if (ad->popup) {
+ evas_object_del(ad->popup);
+ ad->popup = NULL;
+ }
+
+ ad->popup = setting_create_popup_with_btn(ad, ad->win_get, NULL,
+ _(SETTING_STORAGE_FORMAT_ASK_MSG),
+ __setting_storage_main_sd_card_ask_format_resp_cb, 0,
+ 2, _("IDS_COM_SK_YES"),_("IDS_COM_SK_NO"));
+}
+#endif
+
+static void __setting_storage_main_mouse_up_Gendial_list_cb(void *data, Evas_Object *obj,
+ void *event_info)
+{
+ SETTING_TRACE_BEGIN;
+ setting_retm_if(data == NULL, "Data parameter is NULL");
+ setting_retm_if(event_info == NULL, "Invalid argument: event info is NULL");
+
+ SettingStorageUG *ad = (SettingStorageUG *) data;
+ Elm_Object_Item *item = (Elm_Object_Item *) event_info;
+ elm_genlist_item_selected_set(item, 0);
+ Setting_GenGroupItem_Data *list_item = (Setting_GenGroupItem_Data *) elm_object_item_data_get(item);
+
+ SETTING_TRACE("clicking item[%s]", _(list_item->keyStr));
+
+ int db_status = 0;
+ int ret = vconf_get_int(VCONFKEY_FILEMANAGER_DB_STATUS, &db_status);
+ setting_retm_if(ret != 0, "fail to get vconf");
+
+ /* if SD card is busy, show popup */
+ if (db_status != VCONFKEY_FILEMANAGER_DB_UPDATED) {
+ if (ad->popup) {
+ evas_object_del(ad->popup);
+ ad->popup = NULL;
+ }
+ ad->popup = setting_create_popup_without_btn(ad, ad->win_get,
+ NULL, _("IDS_ST_BODY_SORRY_YOUR_SD_CARD_IS_BUSY"),
+ __setting_storage_status_sd_card_popup_response_cb,
+ SETTING_STORAGE_POPUP_TIMER, FALSE, FALSE);
+ return;
+ }
+
+ if (list_item == ad->sd_mount) {
+ __setting_storage_main_sd_card_mount_unmount(ad);
+ }
+#if SUPPORT_SD_CARD_FORMAT
+ else if (list_item == ad->sd_format) {
+ __setting_storage_main_sd_card_format_popup_create(ad);
+ }
+#endif
+}
+
+static void __setting_storage_main_sd_card_info_append(void* data)
+{
+ SETTING_TRACE_BEGIN;
+ setting_retm_if(data == NULL, "Data parameter is NULL");
+ SettingStorageUG *ad = (SettingStorageUG *) data;
+
+ /* remove the sd info items */
+ if (ad->sd_mount) {
+ elm_object_item_del(ad->sd_mount->item);
+ ad->sd_mount = NULL;
+ }
+ if (ad->sd_total) {
+ elm_object_item_del(ad->sd_total->item);
+ ad->sd_total = NULL;
+ }
+ if (ad->sd_available) {
+ elm_object_item_del(ad->sd_available->item);
+ ad->sd_available = NULL;
+ }
+#if SUPPORT_SD_CARD_FORMAT
+ if (ad->sd_format) {
+ elm_object_item_del(ad->sd_format->item);
+ ad->sd_format = NULL;
+ }
+#endif
+ int mmc_mode = VCONFKEY_SYSMAN_MMC_REMOVED;
+ int ret = vconf_get_int(VCONFKEY_SYSMAN_MMC_STATUS, &mmc_mode);
+ setting_retm_if(ret != 0, "Get vconf failed");
+
+ if (mmc_mode == VCONFKEY_SYSMAN_MMC_REMOVED) {
+ ad->sd_mount = setting_create_Gendial_field_def(ad->genlist, &(ad->itc_2text_2), NULL,
+ ad, SWALLOW_Type_INVALID, NULL,
+ NULL, 0, SETTING_STORAGE_MOUNT_STR,
+ _(SETTING_STORAGE_INSERT_STR),
+ NULL);
+ if (ad->sd_mount) {
+ setting_disable_genlist_item(ad->sd_mount->item);
+ }
+ } else if (mmc_mode == VCONFKEY_SYSMAN_MMC_INSERTED_NOT_MOUNTED) {
+ ad->sd_mount = setting_create_Gendial_field_def(ad->genlist, &(ad->itc_2text_2),
+ __setting_storage_main_mouse_up_Gendial_list_cb,
+ ad, SWALLOW_Type_INVALID, NULL,
+ NULL, 0, SETTING_STORAGE_MOUNT_STR,
+ _(SETTING_STORAGE_INSERT_STR),
+ NULL);
+ } else if (mmc_mode == VCONFKEY_SYSMAN_MMC_MOUNTED) {
+ char sd_total[SETTING_STORAGE_MAX_STR_LEN] = { 0, };
+ char sd_available[SETTING_STORAGE_MAX_STR_LEN] = { 0, };
+ __setting_storage_main_sd_card_info_get(sd_total, sd_available);
+
+ ad->sd_total = setting_create_Gendial_field_def(ad->genlist, &(ad->itc_2text_2), NULL,
+ ad, SWALLOW_Type_INVALID, NULL,
+ NULL, 0, "IDS_ST_BODY_TOTAL_SPACE",
+ sd_total,
+ NULL);
+ if (ad->sd_total) {
+ ad->sd_total->userdata = ad;
+ elm_genlist_item_select_mode_set(ad->sd_total->item, ELM_OBJECT_SELECT_MODE_DISPLAY_ONLY);
+ } else {
+ SETTING_TRACE_ERROR("ad->sd_total is NULL");
+ }
+
+ ad->sd_available = setting_create_Gendial_field_def(ad->genlist, &(ad->itc_2text_2), NULL,
+ ad, SWALLOW_Type_INVALID, NULL,
+ NULL, 0, "IDS_ST_BODY_AVAILABLE_SPACE",
+ sd_available,
+ NULL);
+ if (ad->sd_available) {
+ ad->sd_available->userdata = ad;
+ elm_genlist_item_select_mode_set(ad->sd_available->item, ELM_OBJECT_SELECT_MODE_DISPLAY_ONLY);
+ } else {
+ SETTING_TRACE_ERROR("ad->sd_available is NULL");
+ }
+
+ ad->sd_mount = setting_create_Gendial_field_def(ad->genlist, &(ad->itc_1text),
+ __setting_storage_main_mouse_up_Gendial_list_cb,
+ ad, SWALLOW_Type_INVALID, NULL,
+ NULL, 0, "IDS_ST_BODY_UNMOUNT_SD_CARD", NULL,
+ NULL);
+ if (ad->sd_mount) {
+ ad->sd_mount->userdata = ad;
+ } else {
+ SETTING_TRACE_ERROR("ad->sd_mount is NULL");
+ }
+
+#if SUPPORT_SD_CARD_FORMAT
+ ad->sd_format = setting_create_Gendial_field_def(ad->genlist, &(ad->itc_1text),
+ __setting_storage_main_mouse_up_Gendial_list_cb,
+ ad, SWALLOW_Type_INVALID, NULL,
+ NULL, 0,
+ "IDS_ST_BODY_FORMAT_SD_CARD",
+ NULL, NULL);
+ if (ad->sd_format) {
+ ad->sd_format->userdata = ad;
+ } else {
+ SETTING_TRACE_ERROR("ad->sd_format is NULL");
+ }
+#endif
+ } else {
+ SETTING_TRACE_ERROR("error status of sd card");
+ }
+
+ Elm_Object_Item *item = NULL;
+ item = elm_genlist_item_append(ad->genlist, &itc_bottom_seperator, NULL, NULL,
+ ELM_GENLIST_ITEM_NONE, NULL, NULL);
+ elm_genlist_item_select_mode_set(item, ELM_OBJECT_SELECT_MODE_DISPLAY_ONLY);
+}
+
+static void __setting_storage_vconf_change_cb(keynode_t *key, void *data)
+{
+ SETTING_TRACE_BEGIN;
+ setting_retm_if(NULL == key, "key is NULL");
+ setting_retm_if(NULL == data, "data is NULL");
+ SettingStorageUG *ad = (SettingStorageUG *)data;
+ int status = vconf_keynode_get_int(key);
+ char *vconf_name = vconf_keynode_get_name(key);
+
+ if (!safeStrCmp(vconf_name, VCONFKEY_SYSMAN_MMC_STATUS)) {
+ SETTING_TRACE("status:%d", status);
+ /* remove last item -> seperator */
+ Elm_Object_Item *last_item = NULL;
+ last_item = elm_genlist_last_item_get(ad->genlist);
+ if (last_item) {
+ elm_object_item_del(last_item);
+ }
+ __setting_storage_main_sd_card_info_append(ad);
+ }
+}
+
+static void __setting_storage_main_genlist_update(Setting_GenGroupItem_Data *data, Setting_Storage_Status status)
+{
+ //SETTING_TRACE_BEGIN;
+ setting_retm_if(data == NULL, "Data parameter is NULL");
+ Setting_GenGroupItem_Data *item_data = (Setting_GenGroupItem_Data *) data;
+
+ char desc[SETTING_STORAGE_MAX_STR_LEN + 1] = {0,};
+ int ret = __setting_storage_status_size_transition(status.dTotal, desc);
+ setting_retm_if(ret == SETTING_RETURN_FAIL, "failed to transform")
+
+ G_FREE(item_data->sub_desc);
+ item_data->sub_desc = (char *)g_strdup(desc);
+ elm_object_item_data_set(item_data->item, item_data);
+ elm_genlist_item_update(item_data->item);
+}
+
+static ail_cb_ret_e __setting_storage_main_appinfo_func_cb(const ail_appinfo_h ail_info, void *data)
+{
+ Eina_List **apps_list = (Eina_List **) data;
+
+ char *pkg_name = NULL;
+ char *pkg_type = NULL;
+
+ ail_appinfo_get_str(ail_info, AIL_PROP_PACKAGE_STR, &pkg_name);
+ setting_retvm_if(pkg_name == NULL, AIL_CB_RET_CONTINUE, "get pkg_name failed");
+
+ ail_appinfo_get_str(ail_info, AIL_PROP_X_SLP_PACKAGETYPE_STR, &pkg_type);
+ setting_retvm_if(pkg_type == NULL, AIL_CB_RET_CONTINUE, "get pkg_type failed");
+
+ App_Info *app_info = (App_Info*)calloc(1, sizeof(App_Info));
+ setting_retvm_if(app_info == NULL, AIL_CB_RET_CONTINUE, "failed to calloc");
+
+ app_info->pkg_name = (char *)g_strdup(pkg_name);
+ app_info->pkg_type = (char *)g_strdup(pkg_type);
+ *apps_list = eina_list_append(*apps_list, app_info);
+ return AIL_CB_RET_CONTINUE;
+}
+
+static void __setting_storage_main_applications_list_get(Eina_List **apps_list)
+{
+ SETTING_TRACE_BEGIN;
+ /* get app_info from AIL */
+ ail_filter_h filter_rpm = NULL;
+ ail_filter_h filter_wrt = NULL;
+ ail_filter_h filter_tpk = NULL;
+
+ ail_filter_new(&filter_rpm);
+ ail_filter_new(&filter_wrt);
+ ail_filter_new(&filter_tpk);
+
+ ail_filter_add_str(filter_rpm, AIL_PROP_X_SLP_PACKAGETYPE_STR, RPM_PREFIX);
+ ail_filter_add_str(filter_wrt, AIL_PROP_X_SLP_PACKAGETYPE_STR, WRT_PREFIX);
+ ail_filter_add_str(filter_tpk, AIL_PROP_X_SLP_PACKAGETYPE_STR, TPK_PREFIX);
+
+ ail_filter_list_appinfo_foreach(filter_rpm, __setting_storage_main_appinfo_func_cb, (void*)apps_list);
+ ail_filter_list_appinfo_foreach(filter_wrt, __setting_storage_main_appinfo_func_cb, (void*)apps_list);
+ ail_filter_list_appinfo_foreach(filter_tpk, __setting_storage_main_appinfo_func_cb, (void*)apps_list);
+
+ ail_filter_destroy(filter_rpm);
+ ail_filter_destroy(filter_wrt);
+ ail_filter_destroy(filter_tpk);
+}
+
+static double __setting_storage_main_applications_status_get(void *data)
+{
+ SETTING_TRACE_BEGIN;
+ setting_retvm_if(data == NULL, 0.0, "Data parameter is NULL");
+ SettingStorageUG *ad = (SettingStorageUG *)data;
+
+ Eina_List *apps_list = NULL;
+ __setting_storage_main_applications_list_get(&apps_list);
+
+ SETTING_TRACE("count = %d", eina_list_count(apps_list));
+
+ double total_size = 0.0;
+
+ Eina_List *l = NULL;
+ App_Info *app_info = NULL;
+ EINA_LIST_FOREACH (apps_list, l, app_info)
+ {
+ int exit_flag = 0;
+ pthread_mutex_lock(&ad->exit_mutex);
+ exit_flag = ad->exit_flag;
+ pthread_mutex_unlock(&ad->exit_mutex);
+
+ if (exit_flag == 1) {
+ SETTING_TRACE("exit_flag is 1");
+ break;
+ }
+
+ //SETTING_TRACE("pkg_name: %s ", app_info->pkg_name);
+ //SETTING_TRACE("pkg_type: %s", app_info->pkg_type);
+ pkgmgr_info *pkg_info = pkgmgr_info_new(app_info->pkg_type, app_info->pkg_name);
+ if (!pkg_info) {
+ //SETTING_TRACE("pkg_info is null, couldn't get the sizes");
+ app_info->total_size = 0;
+ } else {
+ char *buf = NULL;
+ buf = pkgmgr_info_get_string(pkg_info, STR_INSTALLED_SIZE);
+ if (buf) {
+ //SETTING_TRACE("size : %s", buf);
+ app_info->total_size = atoi(buf);
+ G_FREE(buf);
+ } else {
+ app_info->total_size = 0;
+ }
+ pkgmgr_info_free(pkg_info);
+ }
+
+ total_size += app_info->total_size;
+ }
+
+ /* free the list */
+ Eina_List *tmp = NULL;
+ app_info = NULL;
+ EINA_LIST_FOREACH(apps_list, tmp, app_info)
+ {
+ G_FREE(app_info->pkg_name);
+ G_FREE(app_info->pkg_type);
+ FREE(app_info);
+ }
+ eina_list_free(apps_list);
+ apps_list = NULL;
+
+ return total_size;
+}
+
+void __setting_storage_main_pipe_cb(void *data, void *buffer, unsigned int nbyte)
+{
+ SETTING_TRACE_BEGIN;
+ setting_retm_if(data == NULL, "Data parameter is NULL");
+ setting_retm_if(buffer == NULL, "buffer parameter is NULL");
+ SettingStorageUG *ad = (SettingStorageUG *)data;
+
+ Update_Info *update_info = (Update_Info *) buffer;
+
+ SETTING_TRACE("update_info : %d", update_info->type);
+
+ switch (update_info->type) {
+ case SETTING_STORAGE_APPLICATIONS:
+ {
+ ad->apps_status.dTotal = update_info->total_size;
+ __setting_storage_main_genlist_update(ad->apps, ad->apps_status);
+ }
+ break;
+ case SETTING_STORAGE_PICTURES_VIDEO:
+ {
+ ad->pics_videos_status.dTotal = update_info->total_size;
+ __setting_storage_main_genlist_update(ad->pics_videos, ad->pics_videos_status);
+ }
+ break;
+ case SETTING_STORAGE_AUDIO:
+ {
+ ad->audio_status.dTotal = update_info->total_size;
+ __setting_storage_main_genlist_update(ad->audio, ad->audio_status);
+ }
+ break;
+ case SETTING_STORAGE_MISCELLANEOUS:
+ {
+ ad->others_status.dTotal = update_info->total_size;
+ __setting_storage_main_genlist_update(ad->others, ad->others_status);
+ }
+ break;
+ default:
+ /* do nothing*/
+ SETTING_TRACE_ERROR("wrong update type");
+ break;
+ }
+
+ __setting_storage_main_genlist_update(ad->internal, ad->internal_status);
+
+ SETTING_TRACE_END;
+}
+
+static void *__setting_storage_main_thread_start_routine(void *data)
+{
+ SETTING_TRACE("==== sub thread id = %d =====", (int)pthread_self());
+ SETTING_TRACE_BEGIN;
+ setting_retvm_if(data == NULL, NULL, "Data parameter is NULL");
+ SettingStorageUG *ad = (SettingStorageUG *)data;
+
+ //Ecore_Pipe *pipe = ad->pipe;
+ update_type type = SETTING_STORAGE_PICTURES_VIDEO;
+ while (1) {
+ pthread_mutex_lock(&ad->update_mutex);
+ while (ad->type == SETTING_STORAGE_SLEEP) {
+ /* wait to be waked up*/
+ pthread_cond_wait(&ad->wait_cond, &ad->update_mutex);
+ }
+ type = ad->type;
+ pthread_mutex_unlock(&ad->update_mutex);
+
+ SETTING_TRACE("thread start to work, update type = %d", type);
+
+ int exit_flag = 0;
+
+ pthread_mutex_lock(&ad->exit_mutex);
+ exit_flag = ad->exit_flag;
+ pthread_mutex_unlock(&ad->exit_mutex);
+
+ if (exit_flag == 1) {
+ SETTING_TRACE("exit_flag is 1");
+ break;
+ }
+
+ if (type >= SETTING_STORAGE_MAX) {
+ SETTING_TRACE("work is done, thread will sleep");
+ pthread_mutex_lock(&ad->update_mutex);
+ ad->type = SETTING_STORAGE_SLEEP;
+ pthread_mutex_unlock(&ad->update_mutex);
+ continue;
+ }
+
+ switch (type) {
+ case SETTING_STORAGE_PICTURES_VIDEO:
+ {
+ /* get pictures and videos info */
+ double pics_videos_size = __setting_storage_main_pictures_videos_status_get();
+ SETTING_TRACE("pics_videos_size = %f", pics_videos_size);
+
+ Update_Info pics_videos_info;
+ memset(&pics_videos_info, 0, sizeof(Update_Info));
+ pics_videos_info.type = SETTING_STORAGE_PICTURES_VIDEO;
+ pics_videos_info.total_size = pics_videos_size;
+ if (ad->pipe)
+ ecore_pipe_write(ad->pipe, &pics_videos_info, sizeof(pics_videos_info));
+ }
+ break;
+ case SETTING_STORAGE_AUDIO:
+ {
+ /* get audio info */
+ double audio_size = __setting_storage_main_audio_status_get();
+ SETTING_TRACE("audio_size = %f", audio_size);
+
+ Update_Info audio_info;
+ memset(&audio_info, 0, sizeof(Update_Info));
+ audio_info.type = SETTING_STORAGE_AUDIO;
+ audio_info.total_size = audio_size;
+ if (ad->pipe)
+ ecore_pipe_write(ad->pipe, &audio_info, sizeof(audio_info));
+ }
+ break;
+ case SETTING_STORAGE_MISCELLANEOUS:
+ {
+ /* get miscellaneous files info */
+ double misc_size = __setting_storage_main_miscellaneous_size_get();
+ SETTING_TRACE("misc_size = %f", misc_size);
+
+ Update_Info misc_info;
+ memset(&misc_info, 0, sizeof(Update_Info));
+ misc_info.type = SETTING_STORAGE_MISCELLANEOUS;
+ misc_info.total_size = misc_size;
+ if (ad->pipe)
+ ecore_pipe_write(ad->pipe, &misc_info, sizeof(misc_info));
+ }
+ break;
+ case SETTING_STORAGE_APPLICATIONS:
+ {
+ /* get apps info */
+ double apps_size = __setting_storage_main_applications_status_get(ad);
+ SETTING_TRACE("apps_size = %f", apps_size);
+
+ Update_Info apps_info;
+ memset(&apps_info, 0, sizeof(Update_Info));
+ apps_info.type = SETTING_STORAGE_APPLICATIONS;
+ apps_info.total_size = apps_size;
+ if (ad->pipe)
+ ecore_pipe_write(ad->pipe, &apps_info, sizeof(apps_info));
+ }
+ break;
+ default:
+ {
+ SETTING_TRACE("type = %d", type);
+ break;
+ }
+ }
+
+ pthread_mutex_lock(&ad->update_mutex);
+ ad->type++;
+ SETTING_TRACE("ad->type = %d", ad->type);
+ pthread_mutex_unlock(&ad->update_mutex);
+ }
+ SETTING_TRACE_END;
+ pthread_exit((void *) 0);
+ ad->tid = 0;
+}
+
+static void __setting_storage_main_init(void *data)
+{
+ SETTING_TRACE_BEGIN;
+ setting_retm_if(data == NULL, "Data parameter is NULL");
+ SettingStorageUG *ad = (SettingStorageUG *)data;
+
+ pthread_mutex_init(&ad->exit_mutex, NULL);
+ pthread_mutex_init(&ad->update_mutex, NULL);
+ pthread_cond_init(&ad->wait_cond, NULL);
+
+ ad->exit_flag = EINA_FALSE;
+ ad->type = SETTING_STORAGE_PICTURES_VIDEO;
+
+ ad->internal_status.dAvail = 0.0;
+ ad->internal_status.dTotal= 0.0;
+
+ ad->apps_status.dAvail = 0.0;
+ ad->apps_status.dTotal= 0.0;
+
+ ad->pics_videos_status.dAvail = 0.0;
+ ad->pics_videos_status.dTotal= 0.0;
+
+ ad->audio_status.dAvail = 0.0;
+ ad->audio_status.dTotal= 0.0;
+
+ ad->others_status.dAvail = 0.0;
+ ad->others_status.dTotal= 0.0;
+}
+
+/* ***************************************************
+ *
+ *basic func
+ *
+ ***************************************************/
+static int setting_storage_main_create(void *cb)
+{
+ SETTING_TRACE_BEGIN;
+ /* error check */
+ retv_if(cb == NULL, SETTING_GENERAL_ERR_NULL_DATA_PARAMETER);
+
+ SettingStorageUG *ad = (SettingStorageUG *) cb;
+
+ __setting_storage_main_init(ad);
+
+ int ret = SETTING_RETURN_SUCCESS;
+
+ retvm_if(ad->win_main_layout == NULL, SETTING_DRAW_ERR_FAIL_LOAD_EDJ,
+ "win_main_layout is NULL");
+
+ ad->ly_main =
+ setting_create_layout_navi_bar_genlist(ad->win_main_layout,
+ ad->win_get,
+ _(KeyStr_Storage),
+ _("IDS_COM_BODY_BACK"),
+ NULL,
+ __setting_storage_main_click_softkey_back_cb,
+ NULL,
+ ad, &ad->genlist, &ad->navibar);
+
+ ad->itc_2text_1icon_4.item_style = "dialogue/2text.1icon.4";
+ ad->itc_2text_1icon_4.func.text_get = __gl_text_get;
+ ad->itc_2text_1icon_4.func.content_get = __gl_content_get;
+ ad->itc_2text_1icon_4.func.state_get = NULL;
+ ad->itc_2text_1icon_4.func.del = __gl_del;
+
+ __setting_storage_main_internal_storage_status_get(ad);
+
+ Elm_Object_Item *item = NULL;
+
+ bool is_emulator = isEmulBin();
+
+ if (!is_emulator) {
+ item = elm_genlist_item_append(ad->genlist, &itc_seperator, NULL, NULL,
+ ELM_GENLIST_ITEM_NONE, NULL, NULL);
+ elm_genlist_item_select_mode_set(item, ELM_OBJECT_SELECT_MODE_DISPLAY_ONLY);
+
+ /* Default storage */
+ setting_create_Gendial_field_def(ad->genlist, &(ad->itc_1text),
+ __setting_storage_main_Gendial_mouse_up_cb,
+ ad, SWALLOW_Type_INVALID, NULL, NULL,
+ 0, SETTING_STORAGE_DEFAULT_STORAGE_STR,
+ NULL, NULL);
+ }
+
+ setting_create_Gendial_field_titleItem(ad->genlist, &(ad->itc_group_item),
+ SETTING_STORAGE_INTERNAL_STORAGE_STR,
+ NULL);
+
+ /* Total space */
+ char total_desc[SETTING_STORAGE_MAX_STR_LEN + 1] = {0,};
+ ret = __setting_storage_status_size_transition(ad->internal_status.dTotal, total_desc);
+ setting_retvm_if(ret == SETTING_RETURN_FAIL, SETTING_RETURN_FAIL, "failed to transform")
+
+ /* status */
+ ad->internal = (Setting_GenGroupItem_Data *) calloc(1, sizeof(Setting_GenGroupItem_Data));
+ setting_retvm_if(!ad->internal, SETTING_RETURN_FAIL, "calloc failed");
+
+ if (ad->internal) {
+ ad->internal->userdata = ad;
+ ad->internal->keyStr = (char *)g_strdup(total_desc);
+ ad->internal->item = elm_genlist_item_append(ad->genlist, &(ad->itc_2text_1icon_4), ad->internal, NULL,
+ ELM_GENLIST_ITEM_NONE, NULL, NULL);
+ elm_genlist_item_select_mode_set(ad->internal->item, ELM_OBJECT_SELECT_MODE_DISPLAY_ONLY);
+ } else {
+ SETTING_TRACE_ERROR("ad->internal is NULL");
+ return SETTING_RETURN_FAIL;
+ }
+
+ /* Applications */
+ ad->apps = setting_create_Gendial_field_def(ad->genlist, &(ad->itc_2text_1icon_3),
+ __setting_storage_main_Gendial_mouse_up_cb,
+ ad, SWALLOW_Type_INVALID, SETTING_STORAGE_APPS_ICON_PATH,
+ NULL, 0, "IDS_ST_BODY_APPLICATIONS",
+ _("IDS_ST_HEADER_PLEASE_WAIT"), NULL);
+ if (ad->apps) {
+ ad->apps->userdata = ad;
+ if (is_emulator) {
+ elm_genlist_item_select_mode_set(ad->apps->item, ELM_OBJECT_SELECT_MODE_DISPLAY_ONLY);
+ }
+ } else {
+ SETTING_TRACE_ERROR("ad->apps is NULL");
+ return SETTING_RETURN_FAIL;
+ }
+
+ /* Pictures, Videos */
+ ad->pics_videos = setting_create_Gendial_field_def(ad->genlist, &(ad->itc_2text_1icon_3),
+ __setting_storage_main_Gendial_mouse_up_cb,
+ ad, SWALLOW_Type_INVALID, SETTING_STORAGE_PICS_ICON_PATH,
+ NULL, 0, SETTING_STORAGE_PICS_STR,
+ _("IDS_ST_HEADER_PLEASE_WAIT"), NULL);
+ if (ad->pics_videos) {
+ ad->pics_videos->userdata = ad;
+ if (is_emulator) {
+ elm_genlist_item_select_mode_set(ad->pics_videos->item, ELM_OBJECT_SELECT_MODE_DISPLAY_ONLY);
+ }
+ } else {
+ SETTING_TRACE_ERROR("ad->pics_videos is NULL");
+ return SETTING_RETURN_FAIL;
+ }
+
+ /* Audio */
+ ad->audio = setting_create_Gendial_field_def(ad->genlist, &(ad->itc_2text_1icon_3),
+ __setting_storage_main_Gendial_mouse_up_cb,
+ ad, SWALLOW_Type_INVALID, SETTING_STORAGE_AUDIO_ICON_PATH,
+ NULL, 0, SETTING_STORAGE_AUDIO_STR,
+ _("IDS_ST_HEADER_PLEASE_WAIT"), NULL);
+ if (ad->audio) {
+ ad->audio->userdata = ad;
+
+ if (is_emulator) {
+ elm_genlist_item_select_mode_set(ad->audio->item, ELM_OBJECT_SELECT_MODE_DISPLAY_ONLY);
+ }
+ } else {
+ SETTING_TRACE_ERROR("ad->audio is NULL");
+ return SETTING_RETURN_FAIL;
+ }
+
+ /* Miscellaneous files */
+ ad->others = setting_create_Gendial_field_def(ad->genlist, &(ad->itc_2text_1icon_3),
+ __setting_storage_main_Gendial_mouse_up_cb,
+ ad, SWALLOW_Type_INVALID, SETTING_STORAGE_MISCES_ICON_PATH,
+ NULL, 0, SETTING_STORAGE_MISCES_STR,
+ _("IDS_ST_HEADER_PLEASE_WAIT"), NULL);
+ if (ad->others) {
+ ad->others->userdata = ad;
+ } else {
+ SETTING_TRACE_ERROR("ad->others is NULL");
+ return SETTING_RETURN_FAIL;
+ }
+
+ /* Available */
+ char avail_desc[SETTING_STORAGE_MAX_STR_LEN + 1] = {0,};
+ ret = __setting_storage_status_size_transition(ad->internal_status.dAvail, avail_desc);
+ setting_retvm_if(ret == SETTING_RETURN_FAIL, SETTING_RETURN_FAIL, "failed to transform")
ad->avail = setting_create_Gendial_field_def(ad->genlist, &(ad->itc_2text_1icon_3), NULL,
ad, SWALLOW_Type_INVALID, SETTING_STORAGE_AVAIL_ICON_PATH,
return SETTING_RETURN_FAIL;
}
- /* Format USB storage */
- setting_create_Gendial_field_def(ad->genlist, &(ad->itc_1text), NULL,
- ad, SWALLOW_Type_INVALID, NULL,
- NULL, 0,
- SETTING_STORAGE_FORMAT_STR,
- NULL, NULL);
-
- setting_create_Gendial_field_def(ad->genlist, &(ad->itc_bg_1icon), NULL,
- ad, SWALLOW_Type_LAYOUT_SPECIALIZTION_X,
- NULL, NULL, 0, SETTING_STORAGE_FORMAT_DESC_STR, NULL,
- NULL);
-
- setting_create_Gendial_field_titleItem(ad->genlist, &(ad->itc_group_item),
- "IDS_ST_BODY_SD_CARD",
- NULL);
+ if (!is_emulator) {
+#if DISABLED_CODE
+ /* Format USB storage */
+ setting_create_Gendial_field_def(ad->genlist, &(ad->itc_1text), NULL,
+ ad, SWALLOW_Type_INVALID, NULL,
+ NULL, 0,
+ SETTING_STORAGE_FORMAT_STR,
+ NULL, NULL);
+
+ setting_create_Gendial_field_def(ad->genlist, &(ad->itc_bg_1icon), NULL,
+ ad, SWALLOW_Type_LAYOUT_SPECIALIZTION_X,
+ NULL, NULL, 0, SETTING_STORAGE_FORMAT_DESC_STR, NULL,
+ NULL);
+#endif
+
+ /* SD card info */
+ setting_create_Gendial_field_titleItem(ad->genlist, &(ad->itc_group_item),
+ "IDS_ST_BODY_SD_CARD", NULL);
+ __setting_storage_main_sd_card_info_append(ad);
+
+ ret = vconf_notify_key_changed(VCONFKEY_SYSMAN_MMC_STATUS,
+ __setting_storage_vconf_change_cb, ad);
+ if (ret != 0) {
+ SETTING_TRACE_ERROR("call vconf_notify_key_changed failed");
+ }
+ } else {
+ item = elm_genlist_item_append(ad->genlist, &itc_bottom_seperator, NULL, NULL,
+ ELM_GENLIST_ITEM_NONE, NULL, NULL);
+ elm_genlist_item_select_mode_set(item, ELM_OBJECT_SELECT_MODE_DISPLAY_ONLY);
+ }
- /* Mound SD card */
- setting_create_Gendial_field_def(ad->genlist, &(ad->itc_2text_2), NULL,
- ad, SWALLOW_Type_INVALID, NULL,
- NULL, 0, SETTING_STORAGE_MOUNT_STR,
- _(SETTING_STORAGE_INSERT_STR),
- NULL);
+ setting_view_storage_main.is_create = 1;
- Elm_Object_Item *item = NULL;
- item = elm_genlist_item_append(ad->genlist, &itc_bottom_seperator, NULL, NULL,
- ELM_GENLIST_ITEM_NONE, NULL, NULL);
- elm_genlist_item_select_mode_set(item, ELM_OBJECT_SELECT_MODE_DISPLAY_ONLY);
+ if (ad->pipe) {
+ ecore_pipe_del(ad->pipe);
+ ad->pipe = NULL;
+ }
+ ad->pipe = ecore_pipe_add(__setting_storage_main_pipe_cb, ad);
+ if (ad->pipe)
+ {
+ ret = pthread_create(&ad->tid, NULL, __setting_storage_main_thread_start_routine, ad);
+ if (ret != 0) {
+ SETTING_TRACE_ERROR("fail to pthread_create");
+ }
+ SETTING_TRACE("thread id = %d", ad->tid);
+ }
+ else
+ {
+ SETTING_TRACE_ERROR("fail to ecore_pipe_add");
+ }
- setting_view_storage_main.is_create = 1;
return SETTING_RETURN_SUCCESS;
}
SettingStorageUG *ad = (SettingStorageUG *) cb;
+ int ret = 0;
+
+ pthread_mutex_lock(&ad->exit_mutex);
+ ad->exit_flag = 1;
+ pthread_mutex_unlock(&ad->exit_mutex);
+
+ /* wake up thread */
+ pthread_mutex_lock(&ad->update_mutex);
+ ad->type = SETTING_STORAGE_REUPDATE;
+ pthread_cond_signal(&ad->wait_cond);
+ pthread_mutex_unlock(&ad->update_mutex);
+
+ if (ad->tid > 0)
+ {
+ void *thread_ret = NULL;
+ ret = pthread_join(ad->tid, &thread_ret);
+ if(ret != 0) {
+ SETTING_TRACE_ERROR("fail to join with thread");
+ }
+ SETTING_TRACE("thread exit code %d", (int)thread_ret);
+ }
+
+ pthread_mutex_destroy(&ad->exit_mutex);
+ pthread_mutex_destroy(&ad->update_mutex);
+ pthread_cond_destroy(&ad->wait_cond);
+
+ if (ad->pipe) {
+ ecore_pipe_del(ad->pipe);
+ ad->pipe = NULL;
+ }
+
+ if (!isEmulBin()) {
+ ret = vconf_ignore_key_changed(VCONFKEY_SYSMAN_MMC_STATUS,
+ __setting_storage_vconf_change_cb);
+ if (ret != 0) {
+ SETTING_TRACE_ERROR("call vconf_ignore_key_changed failed");
+ }
+ }
+
if (ad->popup) {
evas_object_del(ad->popup);
ad->popup = NULL;
SETTING_TRACE_BEGIN;
/* error check */
retv_if(cb == NULL, SETTING_GENERAL_ERR_NULL_DATA_PARAMETER);
-
SettingStorageUG *ad = (SettingStorageUG *) cb;
+ int ret = 0;
+
+ __setting_storage_main_internal_storage_status_get(ad);
+
+ /* update internal total size */
+ char total_desc[SETTING_STORAGE_MAX_STR_LEN + 1] = {0,};
+ ret = __setting_storage_status_size_transition(ad->internal_status.dTotal, total_desc);
+ setting_retvm_if(ret == SETTING_RETURN_FAIL, SETTING_RETURN_FAIL, "failed to transform")
+
+ G_FREE(ad->internal->keyStr);
+ ad->internal->keyStr = (char *)g_strdup(total_desc);
+ elm_object_item_data_set(ad->internal->item, ad->internal);
+ elm_genlist_item_update(ad->internal->item);
+
+ /* update internal available size */
+ char avail_desc[SETTING_STORAGE_MAX_STR_LEN + 1] = {0,};
+ ret = __setting_storage_status_size_transition(ad->internal_status.dAvail, avail_desc);
+ setting_retvm_if(ret == SETTING_RETURN_FAIL, SETTING_RETURN_FAIL, "failed to transform")
+
+ G_FREE(ad->avail->sub_desc);
+ ad->avail->sub_desc = (char *)g_strdup(avail_desc);
+ elm_object_item_data_set(ad->avail->item, ad->avail);
+ elm_genlist_item_update(ad->avail->item);
+
+ /* update miscellaneous */
+ if (ad->back_from_misc) {
+ double misc_size = __setting_storage_main_miscellaneous_size_get();
+
+ ad->others_status.dTotal = misc_size;
+ __setting_storage_main_genlist_update(ad->others, ad->others_status);
+ }
+
+ /* wake up thread */
+ pthread_mutex_lock(&ad->update_mutex);
+ ad->type = SETTING_STORAGE_REUPDATE;
+ pthread_cond_signal(&ad->wait_cond);
+ pthread_mutex_unlock(&ad->update_mutex);
+
if (ad->ly_main != NULL) {
evas_object_show(ad->ly_main);
}
projects / apps / core / preloaded / settings.git / blobdiff