3 * Copyright (c) 2012 Samsung Electronics Co., Ltd.
5 * Licensed under the Flora License, Version 1.1 (the License);
6 * you may not use this file except in compliance with the License.
7 * You may obtain a copy of the License at
9 * http://floralicense.org/license/
11 * Unless required by applicable law or agreed to in writing, software
12 * distributed under the License is distributed on an AS IS BASIS,
13 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 * See the License for the specific language governing permissions and
15 * limitations under the License.
17 #include <setting-storage-main.h>
19 #include <package-manager.h>
20 #include <pkgmgr-info.h>
23 static int setting_storage_main_create(void *cb);
24 static int setting_storage_main_destroy(void *cb);
25 static int setting_storage_main_update(void *cb);
26 static int setting_storage_main_cleanup(void *cb);
28 static void __setting_storage_main_click_softkey_back_cb(void *data, Evas_Object *obj,
31 setting_view setting_view_storage_main = {
32 .create = setting_storage_main_create,
33 .destroy = setting_storage_main_destroy,
34 .update = setting_storage_main_update,
35 .cleanup = setting_storage_main_cleanup,
38 static Evas_Object *__setting_storage_main_image_add(Evas *evas, char *icon_path, int width, int height)
40 Evas_Object *image = NULL;
41 image = evas_object_image_add(evas);
42 evas_object_size_hint_weight_set(image, 0.0, EVAS_HINT_EXPAND);
43 evas_object_image_load_size_set(image, width, height);
44 evas_object_image_file_set(image, icon_path, NULL);
45 evas_object_image_fill_set(image, 0, 0, width, height);
46 evas_object_size_hint_min_set(image, width, height);
47 evas_object_show(image);
52 static char *__gl_text_get(void *data, Evas_Object *obj, const char *part)
55 Setting_GenGroupItem_Data *item_data = data;
57 if (!safeStrCmp(part, "elm.text.1")) {
58 return (char *)g_strdup(item_data->keyStr);
63 static Evas_Object *__gl_content_get(void *data, Evas_Object *obj, const char *part)
66 Setting_GenGroupItem_Data *item_data = data;
67 SettingStorageUG *ad = (SettingStorageUG *) item_data->userdata;
69 int width = SETTING_STORAGE_ICON_WIDTH;
70 int height = SETTING_STORAGE_ICON_HEIGHT;
72 app_device_orientation_e m = elm_win_rotation_get(ad->win_get);
73 if(APP_DEVICE_ORIENTATION_90 == m || APP_DEVICE_ORIENTATION_270 == m) {
74 width = SETTING_STORAGE_ICON_LANDSCAPE_WIDTH;
76 width = SETTING_STORAGE_ICON_WIDTH;
78 float temp_size = 0.0;
80 /* use size (applications + picture/videos + audio + miscellaneous + available) as 100% */
81 double total_size = ad->apps_status.dTotal + ad->pics_videos_status.dTotal +
82 + ad->audio_status.dTotal +
83 ad->others_status.dTotal + ad->internal_status.dAvail;
85 if (!safeStrCmp(part, "elm.icon")){
86 Evas_Object *status_box = NULL;
87 status_box = elm_box_add(obj);
88 retvm_if(status_box == NULL, NULL, "Cannot get box");
89 item_data->eo_check = status_box;
90 elm_box_horizontal_set(status_box, 1);
91 evas_object_size_hint_align_set(status_box, 0.0, EVAS_HINT_FILL);
92 evas_object_show(status_box);
94 Evas *evas = evas_object_evas_get(obj);
97 unsigned int apps_size = 0;
98 temp_size = ((float)ad->apps_status.dTotal / total_size) * width;
99 if (temp_size < 1 && temp_size > 0) {
102 apps_size = (unsigned int)temp_size;
105 Evas_Object *apps = __setting_storage_main_image_add(evas, SETTING_STORAGE_APPS_ICON_PATH, apps_size, height);
106 elm_box_pack_end(status_box, apps);
109 /* pictures, videos */
110 unsigned int pics_videos_size = 0;
111 temp_size = ((float)ad->pics_videos_status.dTotal / total_size) * width;
112 if (temp_size < 1 && temp_size > 0) {
113 pics_videos_size = 1;
115 pics_videos_size = (unsigned int)temp_size;
117 if (pics_videos_size > 0) {
118 Evas_Object *pics = __setting_storage_main_image_add(evas, SETTING_STORAGE_PICS_ICON_PATH, pics_videos_size, height);
119 elm_box_pack_end(status_box, pics);
123 unsigned int audio_size = 0;
124 temp_size = ((float)ad->audio_status.dTotal / total_size) * width;
125 if (temp_size < 1 && temp_size > 0) {
128 audio_size = (unsigned int)temp_size;
130 if (audio_size > 0) {
131 Evas_Object *audio = __setting_storage_main_image_add(evas, SETTING_STORAGE_AUDIO_ICON_PATH, audio_size, height);
132 elm_box_pack_end(status_box, audio);
135 /* Miscellaneous files */
136 unsigned int others_size = 0;
137 temp_size = ((float)ad->others_status.dTotal / total_size) * width;
138 if (temp_size < 1 && temp_size > 0) {
141 others_size = (unsigned int)temp_size;
143 if (others_size > 0) {
144 Evas_Object *misc = __setting_storage_main_image_add(evas, SETTING_STORAGE_MISCES_ICON_PATH, others_size, height);
145 elm_box_pack_end(status_box, misc);
149 unsigned int avail_size = 0;
150 temp_size = ((float)ad->internal_status.dAvail / total_size) * width;
151 if (temp_size < 1 && temp_size > 0) {
154 avail_size = (unsigned int)temp_size;
156 int sum = apps_size + pics_videos_size + audio_size + others_size;
157 if ((sum + avail_size) > width) {
158 avail_size = width - sum;
161 if (avail_size > 0) {
162 Evas_Object *avail = __setting_storage_main_image_add(evas, SETTING_STORAGE_AVAIL_ICON_PATH, avail_size, height);
163 elm_box_pack_end(status_box, avail);
171 static void __gl_del(void *data, Evas_Object *obj)
173 /* SETTING_TRACE_BEGIN; */
174 Setting_GenGroupItem_Data *item_data = (Setting_GenGroupItem_Data *) data;
176 G_FREE(item_data->keyStr);
181 static int __setting_storage_main_fs_stat(double *total, double *avail, const char *path)
184 setting_retvm_if(NULL == total || NULL == avail, SETTING_RETURN_FAIL, "Null output parameters");
188 if (!statvfs(path, &s)) {
189 SETTING_TRACE("f_bsize = %ld f_blocks = %ld f_bavail = %ld f_frsize = %ld",
190 s.f_bsize, s.f_blocks, s.f_bavail, s.f_frsize);
191 *total = (double)s.f_frsize * s.f_blocks;
192 *avail = (double)s.f_bsize * s.f_bavail;
194 return SETTING_RETURN_FAIL;
197 return SETTING_RETURN_SUCCESS;
200 static int __setting_storage_status_size_transition(double size, char *size_desc)
202 //SETTING_TRACE_BEGIN;
203 //SETTING_TRACE("size = %f", size);
204 double tmp_size = 0.0;
206 if (size < SETTING_STORAGE_MEGABYTE_VALUE) { // size < 1MB: show x.xKB
207 tmp_size = size / SETTING_STORAGE_KILOBYTE_VALUE;
208 ret = snprintf(size_desc, SETTING_STORAGE_MAX_STR_LEN, "%4.2lf%s", tmp_size, "KB");
209 retv_if(ret < 0, SETTING_RETURN_FAIL);
210 } else if (size < SETTING_STORAGE_GIGABYTE_VALUE) { // size < 1GB: show x.xMB
211 tmp_size = size / SETTING_STORAGE_MEGABYTE_VALUE;
212 ret = snprintf(size_desc, SETTING_STORAGE_MAX_STR_LEN, "%4.2lf%s", tmp_size, "MB");
213 retv_if(ret < 0, SETTING_RETURN_FAIL);
214 } else { // 1G <= size: show x.xGB
215 tmp_size = size / SETTING_STORAGE_GIGABYTE_VALUE;
216 ret = snprintf(size_desc, SETTING_STORAGE_MAX_STR_LEN, "%4.2lf%s", tmp_size, "GB");
217 retv_if(ret < 0, SETTING_RETURN_FAIL);
220 return SETTING_RETURN_SUCCESS;
224 static void __setting_storage_main_internal_storage_status_get(void *data)
227 setting_retm_if(data == NULL, "Data parameter is NULL");
228 SettingStorageUG *ad = (SettingStorageUG *) data;
232 int ret = SETTING_RETURN_SUCCESS;
233 Setting_Storage_Status internal_status;
235 ret = __setting_storage_main_fs_stat(&dTotal, &dAvail, SETTING_STORAGE_OPT_USR_PATH);
236 setting_retm_if(ret == SETTING_RETURN_FAIL, "get opt status failed");
237 internal_status.dTotal = dTotal;
238 internal_status.dAvail = dAvail;
240 ad->internal_status = internal_status;
243 static bool __setting_storage_main_media_item_cb(media_info_h media, void *data)
245 //SETTING_TRACE_BEGIN;
246 setting_retvm_if(media == NULL, true, "media is NULL");
247 setting_retvm_if(data == NULL, true, "Data parameter is NULL");
248 double *total_size = (double *) data;
250 unsigned long long size = 0;
252 char *file_path = NULL;
253 media_info_get_file_path(media, &file_path);
255 if (!ecore_file_exists(file_path)) {
261 media_info_get_size(media, &size);
262 //SETTING_TRACE("size : [%lld]", size);
268 static double __setting_storage_main_pictures_videos_status_get()
271 double total_size = 0.0;
273 int ret = MEDIA_CONTENT_ERROR_NONE;
274 filter_h filter = NULL;
277 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*/
279 ret = media_filter_create(&filter);
280 if(ret != MEDIA_CONTENT_ERROR_NONE) {
281 SETTING_TRACE_ERROR("Fail to create filter");
285 ret = media_filter_set_condition(filter, condition, MEDIA_CONTENT_COLLATE_DEFAULT);
286 if(ret != MEDIA_CONTENT_ERROR_NONE) {
287 media_filter_destroy(filter);
288 SETTING_TRACE_ERROR("Fail to set condition");
292 ret = media_info_foreach_media_from_db(filter, __setting_storage_main_media_item_cb, &total_size);
293 if(ret != MEDIA_CONTENT_ERROR_NONE) {
294 media_filter_destroy(filter);
295 SETTING_TRACE_ERROR("Fail to get media");
299 ret = media_filter_destroy(filter);
300 if (ret != MEDIA_CONTENT_ERROR_NONE) {
301 SETTING_TRACE_ERROR("destroy filter failed\n\n");
308 static double __setting_storage_main_audio_status_get()
312 double total_size = 0.0;
314 int ret = MEDIA_CONTENT_ERROR_NONE;
315 filter_h filter = NULL;
318 char *condition = "MEDIA_TYPE=3 and MEDIA_PATH LIKE \'/opt/usr/%%\'"; /*0-image, 1-video, 2-sound, 3-music, 4-other*/
320 ret = media_filter_create(&filter);
321 if(ret != MEDIA_CONTENT_ERROR_NONE) {
322 SETTING_TRACE("Fail to create filter");
326 ret = media_filter_set_condition(filter, condition, MEDIA_CONTENT_COLLATE_DEFAULT);
327 if(ret != MEDIA_CONTENT_ERROR_NONE) {
328 media_filter_destroy(filter);
329 SETTING_TRACE("Fail to set condition");
333 ret = media_info_foreach_media_from_db(filter, __setting_storage_main_media_item_cb, &total_size);
334 if(ret != MEDIA_CONTENT_ERROR_NONE) {
335 media_filter_destroy(filter);
336 SETTING_TRACE("Fail to get media");
340 ret = media_filter_destroy(filter);
341 if (ret != MEDIA_CONTENT_ERROR_NONE) {
342 SETTING_TRACE_ERROR("destroy filter failed\n\n");
349 static bool __setting_storage_main_other_item_cb(media_info_h media, void *data)
351 //SETTING_TRACE_BEGIN;
352 setting_retvm_if(media == NULL, true, "media is NULL");
353 setting_retvm_if(data == NULL, true, "Data parameter is NULL");
354 double *total_size = (double *) data;
356 unsigned long long size = 0;
358 char *file_path = NULL;
359 media_info_get_file_path(media, &file_path);
361 if (!ecore_file_exists(file_path)) {
366 if (!safeStrNCmp(file_path, PATH1, sizeof(PATH1)) ||
367 !safeStrNCmp(file_path, PATH2, sizeof(PATH2)) ||
368 !safeStrNCmp(file_path, PATH3, sizeof(PATH3)) ||
369 !safeStrNCmp(file_path, PATH4, sizeof(PATH4)) ||
370 !safeStrNCmp(file_path, PATH5, sizeof(PATH5)) ||
371 !safeStrNCmp(file_path, PATH6, sizeof(PATH6)) ||
372 !safeStrNCmp(file_path, PATH7, sizeof(PATH7)) ||
373 !safeStrNCmp(file_path, PATH8, sizeof(PATH8)) ||
374 !safeStrNCmp(file_path, PATH9, sizeof(PATH9)))
380 media_info_get_size(media, &size);
381 //SETTING_TRACE("size : [%lld]", size);
388 * Miscellaneous files is all directories files under /opt/usr/media/ except below default directories:
389 * ++++++++++++++++++++++++++++++++++++++++++++++++
392 * drwxrwxrwx 11 app app 4096 Jan 4 12:42 .
393 * drwxr-xr-x 20 root root 4096 Jan 7 10:09 ..
394 * drwxr-xr-x 2 root root 4096 Jan 4 08:46 .tmp_download
395 * drwxr-xr-x 2 app app 4096 Jan 4 08:47 .video-hub
396 * drwxrwxrwx 2 app app 4096 Oct 5 2012 Camera
397 * drwxrwxrwx 3 app app 4096 Jan 4 08:46 Downloads
398 * drwxrwxrwx 2 app app 4096 Oct 5 2012 Images
399 * drwxrwxrwx 2 app app 4096 Oct 5 2012 Others
400 * drwxrwxrwx 3 app app 4096 Oct 5 2012 Sounds
401 * drwxrwxrwx 2 app app 4096 Oct 5 2012 Videos
402 * drwxrwxrwx 2 app app 16384 Oct 5 2012 lost+found
403 * ++++++++++++++++++++++++++++++++++++++++++++++++
405 static double __setting_storage_main_miscellaneous_size_get()
408 double total_size = 0.0;
410 int ret = MEDIA_CONTENT_ERROR_NONE;
411 filter_h filter = NULL;
414 char *condition = "(MEDIA_TYPE=4) and MEDIA_PATH LIKE \'/opt/usr/media/%%\'";
416 ret = media_filter_create(&filter);
417 if(ret != MEDIA_CONTENT_ERROR_NONE) {
418 SETTING_TRACE_ERROR("Fail to create filter");
422 ret = media_filter_set_condition(filter, condition, MEDIA_CONTENT_COLLATE_DEFAULT);
423 if(ret != MEDIA_CONTENT_ERROR_NONE) {
424 media_filter_destroy(filter);
425 SETTING_TRACE_ERROR("Fail to set condition");
429 ret = media_info_foreach_media_from_db(filter, __setting_storage_main_other_item_cb, &total_size);
430 if(ret != MEDIA_CONTENT_ERROR_NONE) {
431 media_filter_destroy(filter);
432 SETTING_TRACE_ERROR("Fail to get media");
436 ret = media_filter_destroy(filter);
437 if (ret != MEDIA_CONTENT_ERROR_NONE) {
438 SETTING_TRACE_ERROR("destroy filter failed");
445 static void __setting_storage_main_launch_ug_destroy_cb(ui_gadget_h ug, void *priv)
448 /* restore the '<-' button on the navigate bar */
449 retm_if(priv == NULL, "priv is NULL");
450 SettingStorageUG *ad = (SettingStorageUG *) priv;
454 Elm_Object_Item *navi_it = elm_naviframe_top_item_get(ad->navibar);
455 retm_if(navi_it == NULL, "navi_it is NULL");
456 Evas_Object *back_btn = elm_object_item_part_content_get(navi_it, "prev_btn");
458 if (back_btn != NULL) {
459 elm_object_style_set(back_btn, NAVI_BACK_BUTTON_STYLE); /* take into effect */
462 setting_view_update(&setting_view_storage_main, ad);
465 static void __setting_storage_main_launch_ug_layout_cb(ui_gadget_h ug, enum ug_mode mode, void *priv)
468 retm_if(priv == NULL, "priv is NULL");
469 SettingStorageUG *ad = (SettingStorageUG *) priv;
470 Evas_Object *base = NULL;
471 base = (Evas_Object *) ug_get_layout(ug);
472 retm_if(base == NULL, "base is NULL");
475 case UG_MODE_FULLVIEW:
476 evas_object_size_hint_weight_set(base, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
477 //elm_win_resize_object_add(ad->win_get, base);
478 evas_object_show(base);
486 static void __setting_storage_main_launch_manage_app_ug(void *data)
490 retm_if(data == NULL, "Data parameter is NULL");
492 SettingStorageUG *ad = (SettingStorageUG *) data;
495 if (service_create(&svc)) {
499 service_add_extra_data(svc, "viewtype", "manage-applications");
501 struct ug_cbs *cbs = (struct ug_cbs *)calloc(1, sizeof(struct ug_cbs));
503 SETTING_TRACE_ERROR("calloc failed");
504 service_destroy(svc);
507 cbs->layout_cb = __setting_storage_main_launch_ug_layout_cb;
508 cbs->result_cb = NULL;
509 cbs->destroy_cb = __setting_storage_main_launch_ug_destroy_cb;
510 cbs->priv = (void *)ad;
512 ui_gadget_h ug = ug_create(ad->ug, "setting-manage-applications-efl", UG_MODE_FULLVIEW, svc, cbs);
513 if (NULL == ug) { /* error handling */
514 SETTING_TRACE_ERROR("NULL == ug");
518 service_destroy(svc);
522 static void __setting_storage_main_app_launch(char *app_name)
525 setting_retm_if(app_name == NULL, "app_name is NULL");
527 app_launcher(app_name);
530 static void __setting_storage_main_Gendial_mouse_up_cb(void *data, Evas_Object *obj, void *event_info)
534 setting_retm_if(data == NULL, "Data parameter is NULL");
535 Elm_Object_Item *item = (Elm_Object_Item *) event_info;
536 elm_genlist_item_selected_set(item, 0);
537 Setting_GenGroupItem_Data *list_item = (Setting_GenGroupItem_Data *) elm_object_item_data_get(item);
539 SettingStorageUG *ad = (SettingStorageUG *) data;
541 SETTING_TRACE("clicking item[%s]", _(list_item->keyStr));
544 if (!safeStrCmp(SETTING_STORAGE_DEFAULT_STORAGE_STR, list_item->keyStr)) {
545 setting_view_change(&setting_view_storage_main,
546 &setting_view_storage_default_storage, ad);
547 } else if (!safeStrCmp(SETTING_STORAGE_MISCES_STR, list_item->keyStr)) {
548 setting_view_change(&setting_view_storage_main,
549 &setting_view_storage_miscellaneous_files, ad);
554 if (!safeStrCmp("IDS_ST_BODY_APPLICATIONS", list_item->keyStr)) {
555 __setting_storage_main_launch_manage_app_ug(ad);
556 } else if (!safeStrCmp(SETTING_STORAGE_DEFAULT_STORAGE_STR, list_item->keyStr)) {
557 setting_view_change(&setting_view_storage_main,
558 &setting_view_storage_default_storage, ad);
559 } else if (!safeStrCmp(SETTING_STORAGE_PICS_STR, list_item->keyStr)) {
560 __setting_storage_main_app_launch("org.tizen.gallery");
561 } else if (!safeStrCmp(SETTING_STORAGE_AUDIO_STR, list_item->keyStr)) {
562 __setting_storage_main_app_launch("org.tizen.music-player");
563 } else if (!safeStrCmp(SETTING_STORAGE_MISCES_STR, list_item->keyStr)) {
564 setting_view_change(&setting_view_storage_main,
565 &setting_view_storage_miscellaneous_files, ad);
572 static int __setting_storage_main_check_mmc_status()
575 struct stat parent_stat, mount_stat;
577 ret = stat(SETTING_STORAGE_MMC_PATH, &mount_stat);
578 setting_retvm_if(ret != 0, -1, "get stat error : /opt/storage/sdcard");
580 ret = stat(SETTING_STORAGE_MMC_PARENT_PATH, &parent_stat);
581 setting_retvm_if(ret != 0, -1, "get stat error : /opt/storage/sdcard/..");
583 /* Does not mounted, same st_dev */
584 if(mount_stat.st_dev == parent_stat.st_dev) {
586 } else { /* MMC mounted, diff st_dev */
591 static void __setting_storage_main_sd_card_info_get(char* szTotal, char* szAvail)
593 int mmc_status = __setting_storage_main_check_mmc_status();
594 setting_retm_if(mmc_status == -1, "check mmc status failed");
596 /* Does not mounted, same st_dev */
597 if (mmc_status == 0) {
598 snprintf(szTotal, SETTING_STORAGE_MAX_STR_LEN, "%s", _("IDS_ST_HEADER_UNAVAILABLE"));
599 snprintf(szAvail, SETTING_STORAGE_MAX_STR_LEN, "%s", _("IDS_ST_HEADER_UNAVAILABLE"));
601 /* MMC mounted, diff st_dev */
606 int ret = SETTING_RETURN_SUCCESS;
607 ret = __setting_storage_main_fs_stat(&dTotal, &dAvail, SETTING_STORAGE_MMC_PATH);
608 setting_retm_if(ret == SETTING_RETURN_FAIL, "get sd card size detail failed");
610 ret = __setting_storage_status_size_transition(dTotal, szTotal);
611 setting_retm_if(ret == SETTING_RETURN_FAIL, "__setting_storage_status_size_transition failed");
613 ret = __setting_storage_status_size_transition(dAvail, szAvail);
614 setting_retm_if(ret == SETTING_RETURN_FAIL, "__setting_storage_status_size_transition failed");
616 SETTING_TRACE("Total[%s], Avail[%s]", szTotal, szAvail);
620 static int __setting_storage_main_mmc_content_init(void *data, setting_storage_mmc_cb cb)
623 setting_retvm_if(NULL == data, SETTING_RETURN_FAIL, "data is NULL");
624 setting_retvm_if(NULL == cb, SETTING_RETURN_FAIL, "cb is NULL");
625 SettingStorageUG *ad = (SettingStorageUG *)data;
626 if (ad->mmc_content == NULL) {
627 ad->mmc_content = (struct mmc_contents *)calloc(1, sizeof(struct mmc_contents));
628 if (ad->mmc_content == NULL ) {
629 SETTING_TRACE_ERROR("calloc failed");
630 return SETTING_RETURN_FAIL;
633 ad->mmc_content->mmc_cb = cb;
634 ad->mmc_content->user_data = ad;
635 return SETTING_RETURN_SUCCESS;
638 #if SUPPORT_SD_CARD_FORMAT
639 static void __setting_storage_status_sd_card_popup_format_response_cb(void *data,
640 Evas_Object *obj, void *event_info)
643 setting_retm_if(data == NULL, "Data parameter is NULL");
644 SettingStorageUG *ad = (SettingStorageUG *)data;
647 evas_object_del(ad->popup);
651 char sd_total[SETTING_STORAGE_MAX_STR_LEN] = { 0, };
652 char sd_available[SETTING_STORAGE_MAX_STR_LEN] = { 0, };
653 __setting_storage_main_sd_card_info_get(sd_total, sd_available);
656 G_FREE(ad->sd_total->sub_desc);
657 ad->sd_total->sub_desc = (char *)g_strdup(sd_total);
658 elm_object_item_data_set(ad->sd_total->item, ad->sd_total);
659 elm_genlist_item_update(ad->sd_total->item);
661 if (ad->sd_available) {
662 G_FREE(ad->sd_available->sub_desc);
663 ad->sd_available->sub_desc = (char *)g_strdup(sd_available);
664 elm_object_item_data_set(ad->sd_available->item, ad->sd_available);
665 elm_genlist_item_update(ad->sd_available->item);
670 static void __setting_storage_status_sd_card_popup_response_cb(void *data,
671 Evas_Object *obj, void *event_info)
674 setting_retm_if(data == NULL, "Data parameter is NULL");
675 SettingStorageUG *ad = (SettingStorageUG *)data;
678 evas_object_del(ad->popup);
683 static void __setting_storage_main_sd_card_mount_cb(int val, void *data)
686 setting_retm_if(data == NULL, "Data parameter is NULL");
687 SettingStorageUG *ad = (SettingStorageUG *) data;
690 evas_object_del(ad->popup);
695 if (val == SETTING_STORAGE_SYSMAN_REQUEST_SUCCESS) {
697 SETTING_TRACE("mount success");
699 } else if (val == SETTING_STORAGE_SYSMAN_REQUEST_MOUNT_ALREADY) {
700 desc = _(SETTING_STORAGE_SD_CARD_MOUNT_ALREADY_DESC);
702 desc = _("IDS_COM_POP_FAILED");
705 ad->popup = setting_create_popup_without_btn(ad, ad->win_get, NULL, desc,
706 __setting_storage_status_sd_card_popup_response_cb,
707 SETTING_STORAGE_POPUP_TIMER, FALSE, FALSE);
710 static void __setting_storage_main_sd_card_unmount_cb(int val, void *data)
713 setting_retm_if(data == NULL, "Data parameter is NULL");
714 SettingStorageUG *ad = (SettingStorageUG *) data;
717 evas_object_del(ad->popup);
721 if (val == SETTING_STORAGE_SYSMAN_REQUEST_SUCCESS) {
723 SETTING_TRACE("unmount success");
726 ad->popup = setting_create_popup_without_btn(ad, ad->win_get, NULL, _("IDS_COM_POP_FAILED"),
727 __setting_storage_status_sd_card_popup_response_cb,
728 SETTING_STORAGE_POPUP_TIMER, FALSE, FALSE);
732 static void __setting_storage_main_sd_card_mount_unmount(void *data)
735 setting_retm_if(data == NULL, "Data parameter is NULL");
736 SettingStorageUG *ad = (SettingStorageUG *)data;
738 int mmc_status = __setting_storage_main_check_mmc_status();
739 setting_retm_if(mmc_status == -1, "check mmc status failed");
742 evas_object_del(ad->popup);
746 /* Show progressbar popup */
747 ad->popup = setting_create_popup_with_progressbar(ad, ad->win_get,
748 "pending_list", NULL, NULL,
749 __setting_storage_status_sd_card_popup_response_cb,
750 SETTING_STORAGE_PROGRESSBAR_TIMEOUT, TRUE, TRUE);
753 /* Does not mounted, same st_dev */
754 if (mmc_status == 0) {
755 ret = __setting_storage_main_mmc_content_init(ad, __setting_storage_main_sd_card_mount_cb);
756 if (ret == SETTING_RETURN_FAIL) {
757 SETTING_TRACE_ERROR("__setting_storage_main_mmc_content_init fail");
759 evas_object_del(ad->popup);
762 ad->popup = setting_create_popup_without_btn(ad, ad->win_get,
763 NULL, _("IDS_COM_POP_FAILED"),
764 __setting_storage_status_sd_card_popup_response_cb,
765 SETTING_STORAGE_POPUP_TIMER, FALSE, FALSE);
768 ret = sysman_request_mount_mmc(ad->mmc_content);
770 SETTING_TRACE_ERROR("fail to call sysman_request_mount_mmc");
773 /* MMC mounted, diff st_dev */
775 ret = __setting_storage_main_mmc_content_init(ad, __setting_storage_main_sd_card_unmount_cb);
776 if (ret == SETTING_RETURN_FAIL) {
777 SETTING_TRACE_ERROR("__setting_storage_main_sd_card_unmount_cb fail");
779 evas_object_del(ad->popup);
782 ad->popup = setting_create_popup_without_btn(ad, ad->win_get,
783 NULL, _("IDS_COM_POP_FAILED"),
784 __setting_storage_status_sd_card_popup_response_cb,
785 SETTING_STORAGE_POPUP_TIMER, FALSE, FALSE);
789 ret = sysman_request_unmount_mmc(ad->mmc_content,
790 MNT_FORCE); /* 1 = MNT_FORCE */
792 SETTING_TRACE_ERROR("fail to call sysman_request_unmount_mmc");
796 /* if fail, popup failed info */
799 evas_object_del(ad->popup);
802 ad->popup = setting_create_popup_without_btn(ad, ad->win_get,
803 NULL, _("IDS_COM_POP_FAILED"),
804 __setting_storage_status_sd_card_popup_response_cb,
805 SETTING_STORAGE_POPUP_TIMER, FALSE, FALSE);
809 #if SUPPORT_SD_CARD_FORMAT
810 static void __setting_storage_main_sd_card_scan_cb(media_content_error_e err, void *data)
813 setting_retm_if(data == NULL, "Data parameter is NULL");
814 SettingStorageUG *ad = (SettingStorageUG *) data;
816 SETTING_TRACE("scan_cb result = %d", err);
819 evas_object_del(ad->popup);
823 if (err == MEDIA_CONTENT_ERROR_NONE) {
824 ad->popup = setting_create_popup_without_btn(ad, ad->win_get, NULL, _("IDS_COM_POP_SUCCESS"),
825 __setting_storage_status_sd_card_popup_format_response_cb,
826 SETTING_STORAGE_POPUP_TIMER, FALSE, FALSE);
829 ad->popup = setting_create_popup_without_btn(ad, ad->win_get, NULL, _("IDS_COM_POP_FAILED"),
830 __setting_storage_status_sd_card_popup_response_cb,
831 SETTING_STORAGE_POPUP_TIMER, FALSE, FALSE);
835 static void __setting_storage_main_sd_card_format_cb(int val, void *data)
838 setting_retm_if(data == NULL, "Data parameter is NULL");
839 SettingStorageUG *ad = (SettingStorageUG *) data;
841 if (val == SETTING_STORAGE_SYSMAN_REQUEST_SUCCESS) {
842 int ret = media_content_scan_folder(SETTING_STORAGE_MMC_PATH, true, __setting_storage_main_sd_card_scan_cb, ad);
844 if(ret != MEDIA_CONTENT_ERROR_NONE) {
845 SETTING_TRACE_ERROR("Fail to media_content_scan_file : %d", ret);
850 evas_object_del(ad->popup);
853 ad->popup = setting_create_popup_without_btn(ad, ad->win_get, NULL, _("IDS_COM_POP_FAILED"),
854 __setting_storage_status_sd_card_popup_response_cb,
855 SETTING_STORAGE_POPUP_TIMER, FALSE, FALSE);
859 static void __setting_storage_main_sd_card_format_popup_yes(void *data)
862 setting_retm_if(data == NULL, "Data parameter is NULL");
863 SettingStorageUG *ad = (SettingStorageUG *) data;
866 evas_object_del(ad->popup);
870 /* Show Formatting..... popup */
871 ad->popup = setting_create_popup_with_progressbar(ad, ad->win_get,
872 "pending_list", NULL,
876 int ret = __setting_storage_main_mmc_content_init(ad, __setting_storage_main_sd_card_format_cb);
877 if (ret == SETTING_RETURN_FAIL) {
878 SETTING_TRACE_ERROR("__setting_storage_main_mmc_content_init fail");
880 evas_object_del(ad->popup);
883 ad->popup = setting_create_popup_without_btn(ad, ad->win_get,
884 NULL, _("IDS_COM_POP_FAILED"),
885 __setting_storage_status_sd_card_popup_response_cb,
886 SETTING_STORAGE_POPUP_TIMER, FALSE, FALSE);
890 ret = sysman_request_format_mmc(ad->mmc_content);
891 /* if fail, destory popup */
893 SETTING_TRACE_ERROR("fail to call sysman_request_format_mmc");
895 evas_object_del(ad->popup);
898 ad->popup = setting_create_popup_without_btn(ad, ad->win_get,
899 NULL, _("IDS_COM_POP_FAILED"),
900 __setting_storage_status_sd_card_popup_response_cb,
901 SETTING_STORAGE_POPUP_TIMER, FALSE, FALSE);
905 static void __setting_storage_main_sd_card_format_popup_no(void *data)
908 setting_retm_if(data == NULL, "Data parameter is NULL");
909 SettingStorageUG *ad = (SettingStorageUG *) data;
912 evas_object_del(ad->popup);
917 static void __setting_storage_main_sd_card_ask_format_resp_cb(void *data, Evas_Object *obj, void *event_info)
920 setting_retm_if(data == NULL, "Data parameter is NULL");
921 int response_type = btn_type(obj);
922 if (POPUP_RESPONSE_OK == response_type) {
923 __setting_storage_main_sd_card_format_popup_yes(data);
924 } else if (POPUP_RESPONSE_CANCEL == response_type) {
925 __setting_storage_main_sd_card_format_popup_no(data);
929 static void __setting_storage_main_sd_card_format_popup_create(void *data)
932 setting_retm_if(data == NULL, "Data parameter is NULL");
933 SettingStorageUG *ad = (SettingStorageUG *) data;
936 evas_object_del(ad->popup);
940 ad->popup = setting_create_popup_with_btn(ad, ad->win_get, NULL,
941 _(SETTING_STORAGE_FORMAT_ASK_MSG),
942 __setting_storage_main_sd_card_ask_format_resp_cb, 0,
943 2, _("IDS_COM_SK_YES"),_("IDS_COM_SK_NO"));
947 static void __setting_storage_main_mouse_up_Gendial_list_cb(void *data, Evas_Object *obj,
951 setting_retm_if(data == NULL, "Data parameter is NULL");
952 setting_retm_if(event_info == NULL, "Invalid argument: event info is NULL");
954 SettingStorageUG *ad = (SettingStorageUG *) data;
955 Elm_Object_Item *item = (Elm_Object_Item *) event_info;
956 elm_genlist_item_selected_set(item, 0);
957 Setting_GenGroupItem_Data *list_item = (Setting_GenGroupItem_Data *) elm_object_item_data_get(item);
959 SETTING_TRACE("clicking item[%s]", _(list_item->keyStr));
962 int ret = vconf_get_int(VCONFKEY_FILEMANAGER_DB_STATUS, &db_status);
963 setting_retm_if(ret != 0, "fail to get vconf");
965 /* if SD card is busy, show popup */
966 if (db_status != VCONFKEY_FILEMANAGER_DB_UPDATED) {
968 evas_object_del(ad->popup);
971 ad->popup = setting_create_popup_without_btn(ad, ad->win_get,
972 NULL, _("IDS_ST_BODY_SORRY_YOUR_SD_CARD_IS_BUSY"),
973 __setting_storage_status_sd_card_popup_response_cb,
974 SETTING_STORAGE_POPUP_TIMER, FALSE, FALSE);
978 if (list_item == ad->sd_mount) {
979 __setting_storage_main_sd_card_mount_unmount(ad);
981 #if SUPPORT_SD_CARD_FORMAT
982 else if (list_item == ad->sd_format) {
983 __setting_storage_main_sd_card_format_popup_create(ad);
988 static void __setting_storage_main_sd_card_info_append(void* data)
991 setting_retm_if(data == NULL, "Data parameter is NULL");
992 SettingStorageUG *ad = (SettingStorageUG *) data;
994 /* remove the sd info items */
996 elm_object_item_del(ad->sd_mount->item);
1000 elm_object_item_del(ad->sd_total->item);
1001 ad->sd_total = NULL;
1003 if (ad->sd_available) {
1004 elm_object_item_del(ad->sd_available->item);
1005 ad->sd_available = NULL;
1007 #if SUPPORT_SD_CARD_FORMAT
1008 if (ad->sd_format) {
1009 elm_object_item_del(ad->sd_format->item);
1010 ad->sd_format = NULL;
1013 int mmc_mode = VCONFKEY_SYSMAN_MMC_REMOVED;
1014 int ret = vconf_get_int(VCONFKEY_SYSMAN_MMC_STATUS, &mmc_mode);
1015 setting_retm_if(ret != 0, "Get vconf failed");
1017 if (mmc_mode == VCONFKEY_SYSMAN_MMC_REMOVED) {
1018 ad->sd_mount = setting_create_Gendial_field_def(ad->genlist, &(ad->itc_2text_2), NULL,
1019 ad, SWALLOW_Type_INVALID, NULL,
1020 NULL, 0, SETTING_STORAGE_MOUNT_STR,
1021 _(SETTING_STORAGE_INSERT_STR),
1024 setting_disable_genlist_item(ad->sd_mount->item);
1026 } else if (mmc_mode == VCONFKEY_SYSMAN_MMC_INSERTED_NOT_MOUNTED) {
1027 ad->sd_mount = setting_create_Gendial_field_def(ad->genlist, &(ad->itc_2text_2),
1028 __setting_storage_main_mouse_up_Gendial_list_cb,
1029 ad, SWALLOW_Type_INVALID, NULL,
1030 NULL, 0, SETTING_STORAGE_MOUNT_STR,
1031 _(SETTING_STORAGE_INSERT_STR),
1033 } else if (mmc_mode == VCONFKEY_SYSMAN_MMC_MOUNTED) {
1034 char sd_total[SETTING_STORAGE_MAX_STR_LEN] = { 0, };
1035 char sd_available[SETTING_STORAGE_MAX_STR_LEN] = { 0, };
1036 __setting_storage_main_sd_card_info_get(sd_total, sd_available);
1038 ad->sd_total = setting_create_Gendial_field_def(ad->genlist, &(ad->itc_2text_2), NULL,
1039 ad, SWALLOW_Type_INVALID, NULL,
1040 NULL, 0, "IDS_ST_BODY_TOTAL_SPACE",
1044 ad->sd_total->userdata = ad;
1045 elm_genlist_item_select_mode_set(ad->sd_total->item, ELM_OBJECT_SELECT_MODE_DISPLAY_ONLY);
1047 SETTING_TRACE_ERROR("ad->sd_total is NULL");
1050 ad->sd_available = setting_create_Gendial_field_def(ad->genlist, &(ad->itc_2text_2), NULL,
1051 ad, SWALLOW_Type_INVALID, NULL,
1052 NULL, 0, "IDS_ST_BODY_AVAILABLE_SPACE",
1055 if (ad->sd_available) {
1056 ad->sd_available->userdata = ad;
1057 elm_genlist_item_select_mode_set(ad->sd_available->item, ELM_OBJECT_SELECT_MODE_DISPLAY_ONLY);
1059 SETTING_TRACE_ERROR("ad->sd_available is NULL");
1062 ad->sd_mount = setting_create_Gendial_field_def(ad->genlist, &(ad->itc_1text),
1063 __setting_storage_main_mouse_up_Gendial_list_cb,
1064 ad, SWALLOW_Type_INVALID, NULL,
1065 NULL, 0, "IDS_ST_BODY_UNMOUNT_SD_CARD", NULL,
1068 ad->sd_mount->userdata = ad;
1070 SETTING_TRACE_ERROR("ad->sd_mount is NULL");
1073 #if SUPPORT_SD_CARD_FORMAT
1074 ad->sd_format = setting_create_Gendial_field_def(ad->genlist, &(ad->itc_1text),
1075 __setting_storage_main_mouse_up_Gendial_list_cb,
1076 ad, SWALLOW_Type_INVALID, NULL,
1078 "IDS_ST_BODY_FORMAT_SD_CARD",
1080 if (ad->sd_format) {
1081 ad->sd_format->userdata = ad;
1083 SETTING_TRACE_ERROR("ad->sd_format is NULL");
1087 SETTING_TRACE_ERROR("error status of sd card");
1090 Elm_Object_Item *item = NULL;
1091 item = elm_genlist_item_append(ad->genlist, &itc_bottom_seperator, NULL, NULL,
1092 ELM_GENLIST_ITEM_NONE, NULL, NULL);
1093 elm_genlist_item_select_mode_set(item, ELM_OBJECT_SELECT_MODE_DISPLAY_ONLY);
1096 static void __setting_storage_vconf_change_cb(keynode_t *key, void *data)
1098 SETTING_TRACE_BEGIN;
1099 setting_retm_if(NULL == key, "key is NULL");
1100 setting_retm_if(NULL == data, "data is NULL");
1101 SettingStorageUG *ad = (SettingStorageUG *)data;
1102 int status = vconf_keynode_get_int(key);
1103 char *vconf_name = vconf_keynode_get_name(key);
1105 if (!safeStrCmp(vconf_name, VCONFKEY_SYSMAN_MMC_STATUS)) {
1106 SETTING_TRACE("status:%d", status);
1107 /* remove last item -> seperator */
1108 Elm_Object_Item *last_item = NULL;
1109 last_item = elm_genlist_last_item_get(ad->genlist);
1111 elm_object_item_del(last_item);
1113 __setting_storage_main_sd_card_info_append(ad);
1117 static void __setting_storage_main_genlist_update(Setting_GenGroupItem_Data *data, Setting_Storage_Status status)
1119 //SETTING_TRACE_BEGIN;
1120 setting_retm_if(data == NULL, "Data parameter is NULL");
1121 Setting_GenGroupItem_Data *item_data = (Setting_GenGroupItem_Data *) data;
1123 char desc[SETTING_STORAGE_MAX_STR_LEN + 1] = {0,};
1124 int ret = __setting_storage_status_size_transition(status.dTotal, desc);
1125 setting_retm_if(ret == SETTING_RETURN_FAIL, "failed to transform")
1127 G_FREE(item_data->sub_desc);
1128 item_data->sub_desc = (char *)g_strdup(desc);
1129 elm_object_item_data_set(item_data->item, item_data);
1130 elm_genlist_item_update(item_data->item);
1133 static ail_cb_ret_e __setting_storage_main_appinfo_func_cb(const ail_appinfo_h ail_info, void *data)
1135 Eina_List **apps_list = (Eina_List **) data;
1137 char *pkg_name = NULL;
1138 char *pkg_type = NULL;
1140 ail_appinfo_get_str(ail_info, AIL_PROP_PACKAGE_STR, &pkg_name);
1141 setting_retvm_if(pkg_name == NULL, AIL_CB_RET_CONTINUE, "get pkg_name failed");
1143 ail_appinfo_get_str(ail_info, AIL_PROP_X_SLP_PACKAGETYPE_STR, &pkg_type);
1144 setting_retvm_if(pkg_type == NULL, AIL_CB_RET_CONTINUE, "get pkg_type failed");
1146 App_Info *app_info = (App_Info*)calloc(1, sizeof(App_Info));
1147 setting_retvm_if(app_info == NULL, AIL_CB_RET_CONTINUE, "failed to calloc");
1149 app_info->pkg_name = (char *)g_strdup(pkg_name);
1150 app_info->pkg_type = (char *)g_strdup(pkg_type);
1151 *apps_list = eina_list_append(*apps_list, app_info);
1152 return AIL_CB_RET_CONTINUE;
1155 void __setting_storage_pkg_list_cb (const pkgmgrinfo_pkginfo_h handle, void *data)
1157 SETTING_TRACE_BEGIN;
1158 setting_retvm_if(data == NULL, 0.0, "Data parameter is NULL");
1159 SettingStorageUG *ad = (SettingStorageUG *)data;
1164 ret = pkgmgrinfo_pkginfo_get_pkgid(handle, &pkgid);
1166 SETTING_TRACE_ERROR("pkgmgrinfo_pkginfo_get_pkgid() failed");
1169 ret = pkgmgrinfo_pkginfo_get_total_size(handle, &size);
1171 SETTING_TRACE_ERROR("pkgmgrinfo_pkginfo_get_total_size() failed");
1174 SETTING_TRACE("pkg id = %s", pkgid);
1175 SETTING_TRACE("app size = %d", size);
1176 ad->total_size += size;
1179 static double __setting_storage_main_applications_status_get(void *data)
1181 SETTING_TRACE_BEGIN;
1182 setting_retvm_if(data == NULL, 0.0, "Data parameter is NULL");
1183 SettingStorageUG *ad = (SettingStorageUG *)data;
1185 ad->total_size = 0.0;
1187 ret = pkgmgrinfo_pkginfo_get_list(__setting_storage_pkg_list_cb, data);
1189 SETTING_TRACE_ERROR("pkgmgrinfo_pkginfo_get_list() failed");
1192 SETTING_TRACE("ad->total_size = %f", ad->total_size);
1193 return ad->total_size;
1196 void __setting_storage_main_pipe_cb(void *data, void *buffer, unsigned int nbyte)
1198 SETTING_TRACE_BEGIN;
1199 setting_retm_if(data == NULL, "Data parameter is NULL");
1200 setting_retm_if(buffer == NULL, "buffer parameter is NULL");
1201 SettingStorageUG *ad = (SettingStorageUG *)data;
1203 Update_Info *update_info = (Update_Info *) buffer;
1205 SETTING_TRACE("update_info : %d", update_info->type);
1207 switch (update_info->type) {
1208 case SETTING_STORAGE_APPLICATIONS:
1210 ad->apps_status.dTotal = update_info->total_size;
1211 __setting_storage_main_genlist_update(ad->apps, ad->apps_status);
1214 case SETTING_STORAGE_PICTURES_VIDEO:
1216 ad->pics_videos_status.dTotal = update_info->total_size;
1217 __setting_storage_main_genlist_update(ad->pics_videos, ad->pics_videos_status);
1220 case SETTING_STORAGE_AUDIO:
1222 ad->audio_status.dTotal = update_info->total_size;
1223 __setting_storage_main_genlist_update(ad->audio, ad->audio_status);
1226 case SETTING_STORAGE_MISCELLANEOUS:
1228 ad->others_status.dTotal = update_info->total_size;
1229 __setting_storage_main_genlist_update(ad->others, ad->others_status);
1234 SETTING_TRACE_ERROR("wrong update type");
1238 __setting_storage_main_genlist_update(ad->internal, ad->internal_status);
1243 static void *__setting_storage_main_thread_start_routine(void *data)
1245 SETTING_TRACE("==== sub thread id = %d =====", (int)pthread_self());
1246 SETTING_TRACE_BEGIN;
1247 setting_retvm_if(data == NULL, NULL, "Data parameter is NULL");
1248 SettingStorageUG *ad = (SettingStorageUG *)data;
1250 //Ecore_Pipe *pipe = ad->pipe;
1251 update_type type = SETTING_STORAGE_PICTURES_VIDEO;
1253 pthread_mutex_lock(&ad->update_mutex);
1254 while (ad->type == SETTING_STORAGE_SLEEP) {
1255 /* wait to be waked up*/
1256 pthread_cond_wait(&ad->wait_cond, &ad->update_mutex);
1259 pthread_mutex_unlock(&ad->update_mutex);
1261 SETTING_TRACE("thread start to work, update type = %d", type);
1265 pthread_mutex_lock(&ad->exit_mutex);
1266 exit_flag = ad->exit_flag;
1267 pthread_mutex_unlock(&ad->exit_mutex);
1269 if (exit_flag == 1) {
1270 SETTING_TRACE("exit_flag is 1");
1274 if (type >= SETTING_STORAGE_MAX) {
1275 SETTING_TRACE("work is done, thread will sleep");
1276 pthread_mutex_lock(&ad->update_mutex);
1277 ad->type = SETTING_STORAGE_SLEEP;
1278 pthread_mutex_unlock(&ad->update_mutex);
1283 case SETTING_STORAGE_PICTURES_VIDEO:
1285 /* get pictures and videos info */
1286 double pics_videos_size = __setting_storage_main_pictures_videos_status_get();
1287 SETTING_TRACE("pics_videos_size = %f", pics_videos_size);
1289 Update_Info pics_videos_info;
1290 memset(&pics_videos_info, 0, sizeof(Update_Info));
1291 pics_videos_info.type = SETTING_STORAGE_PICTURES_VIDEO;
1292 pics_videos_info.total_size = pics_videos_size;
1294 ecore_pipe_write(ad->pipe, &pics_videos_info, sizeof(pics_videos_info));
1297 case SETTING_STORAGE_AUDIO:
1299 /* get audio info */
1300 double audio_size = __setting_storage_main_audio_status_get();
1301 SETTING_TRACE("audio_size = %f", audio_size);
1303 Update_Info audio_info;
1304 memset(&audio_info, 0, sizeof(Update_Info));
1305 audio_info.type = SETTING_STORAGE_AUDIO;
1306 audio_info.total_size = audio_size;
1308 ecore_pipe_write(ad->pipe, &audio_info, sizeof(audio_info));
1311 case SETTING_STORAGE_MISCELLANEOUS:
1313 /* get miscellaneous files info */
1314 double misc_size = __setting_storage_main_miscellaneous_size_get();
1315 SETTING_TRACE("misc_size = %f", misc_size);
1317 Update_Info misc_info;
1318 memset(&misc_info, 0, sizeof(Update_Info));
1319 misc_info.type = SETTING_STORAGE_MISCELLANEOUS;
1320 misc_info.total_size = misc_size;
1322 ecore_pipe_write(ad->pipe, &misc_info, sizeof(misc_info));
1325 case SETTING_STORAGE_APPLICATIONS:
1328 double apps_size = __setting_storage_main_applications_status_get(ad);
1329 SETTING_TRACE("apps_size = %f", apps_size);
1331 Update_Info apps_info;
1332 memset(&apps_info, 0, sizeof(Update_Info));
1333 apps_info.type = SETTING_STORAGE_APPLICATIONS;
1334 apps_info.total_size = apps_size;
1336 ecore_pipe_write(ad->pipe, &apps_info, sizeof(apps_info));
1341 SETTING_TRACE("type = %d", type);
1346 pthread_mutex_lock(&ad->update_mutex);
1348 SETTING_TRACE("ad->type = %d", ad->type);
1349 pthread_mutex_unlock(&ad->update_mutex);
1352 pthread_exit((void *) 0);
1356 static void __setting_storage_main_init(void *data)
1358 SETTING_TRACE_BEGIN;
1359 setting_retm_if(data == NULL, "Data parameter is NULL");
1360 SettingStorageUG *ad = (SettingStorageUG *)data;
1362 pthread_mutex_init(&ad->exit_mutex, NULL);
1363 pthread_mutex_init(&ad->update_mutex, NULL);
1364 pthread_cond_init(&ad->wait_cond, NULL);
1366 pthread_mutex_lock(&ad->exit_mutex);
1367 ad->exit_flag = EINA_FALSE;
1368 pthread_mutex_unlock(&ad->exit_mutex);
1370 pthread_mutex_lock(&ad->update_mutex);
1371 ad->type = SETTING_STORAGE_PICTURES_VIDEO;
1372 pthread_mutex_unlock(&ad->update_mutex);
1374 ad->internal_status.dAvail = 0.0;
1375 ad->internal_status.dTotal= 0.0;
1377 ad->apps_status.dAvail = 0.0;
1378 ad->apps_status.dTotal= 0.0;
1380 ad->pics_videos_status.dAvail = 0.0;
1381 ad->pics_videos_status.dTotal= 0.0;
1383 ad->audio_status.dAvail = 0.0;
1384 ad->audio_status.dTotal= 0.0;
1386 ad->others_status.dAvail = 0.0;
1387 ad->others_status.dTotal= 0.0;
1390 /* ***************************************************
1394 ***************************************************/
1395 static int setting_storage_main_create(void *cb)
1397 SETTING_TRACE_BEGIN;
1399 retv_if(cb == NULL, SETTING_GENERAL_ERR_NULL_DATA_PARAMETER);
1401 SettingStorageUG *ad = (SettingStorageUG *) cb;
1403 __setting_storage_main_init(ad);
1405 int ret = SETTING_RETURN_SUCCESS;
1407 retvm_if(ad->win_main_layout == NULL, SETTING_DRAW_ERR_FAIL_LOAD_EDJ,
1408 "win_main_layout is NULL");
1411 setting_create_layout_navi_bar_genlist(ad->win_main_layout,
1414 _("IDS_COM_BODY_BACK"),
1416 __setting_storage_main_click_softkey_back_cb,
1418 ad, &ad->genlist, &ad->navibar);
1420 ad->itc_2text_1icon_4.item_style = "dialogue/2text.1icon.4";
1421 ad->itc_2text_1icon_4.func.text_get = __gl_text_get;
1422 ad->itc_2text_1icon_4.func.content_get = __gl_content_get;
1423 ad->itc_2text_1icon_4.func.state_get = NULL;
1424 ad->itc_2text_1icon_4.func.del = __gl_del;
1426 __setting_storage_main_internal_storage_status_get(ad);
1428 Elm_Object_Item *item = NULL;
1430 bool is_emulator = isEmulBin();
1433 item = elm_genlist_item_append(ad->genlist, &itc_seperator, NULL, NULL,
1434 ELM_GENLIST_ITEM_NONE, NULL, NULL);
1435 elm_genlist_item_select_mode_set(item, ELM_OBJECT_SELECT_MODE_DISPLAY_ONLY);
1437 /* Default storage */
1438 setting_create_Gendial_field_def(ad->genlist, &(ad->itc_1text),
1439 __setting_storage_main_Gendial_mouse_up_cb,
1440 ad, SWALLOW_Type_INVALID, NULL, NULL,
1441 0, SETTING_STORAGE_DEFAULT_STORAGE_STR,
1445 setting_create_Gendial_field_titleItem(ad->genlist, &(ad->itc_group_item),
1446 SETTING_STORAGE_INTERNAL_STORAGE_STR,
1450 char total_desc[SETTING_STORAGE_MAX_STR_LEN + 1] = {0,};
1451 ret = __setting_storage_status_size_transition(ad->internal_status.dTotal, total_desc);
1452 setting_retvm_if(ret == SETTING_RETURN_FAIL, SETTING_RETURN_FAIL, "failed to transform")
1455 ad->internal = (Setting_GenGroupItem_Data *) calloc(1, sizeof(Setting_GenGroupItem_Data));
1456 setting_retvm_if(!ad->internal, SETTING_RETURN_FAIL, "calloc failed");
1459 ad->internal->userdata = ad;
1460 ad->internal->keyStr = (char *)g_strdup(total_desc);
1461 ad->internal->item = elm_genlist_item_append(ad->genlist, &(ad->itc_2text_1icon_4), ad->internal, NULL,
1462 ELM_GENLIST_ITEM_NONE, NULL, NULL);
1463 elm_genlist_item_select_mode_set(ad->internal->item, ELM_OBJECT_SELECT_MODE_DISPLAY_ONLY);
1465 SETTING_TRACE_ERROR("ad->internal is NULL");
1466 return SETTING_RETURN_FAIL;
1470 ad->apps = setting_create_Gendial_field_def(ad->genlist, &(ad->itc_2text_1icon_3),
1471 __setting_storage_main_Gendial_mouse_up_cb,
1472 ad, SWALLOW_Type_INVALID, SETTING_STORAGE_APPS_ICON_PATH,
1473 NULL, 0, "IDS_ST_BODY_APPLICATIONS",
1474 _("IDS_ST_HEADER_PLEASE_WAIT"), NULL);
1476 ad->apps->userdata = ad;
1478 elm_genlist_item_select_mode_set(ad->apps->item, ELM_OBJECT_SELECT_MODE_DISPLAY_ONLY);
1481 SETTING_TRACE_ERROR("ad->apps is NULL");
1482 return SETTING_RETURN_FAIL;
1485 /* Pictures, Videos */
1486 ad->pics_videos = setting_create_Gendial_field_def(ad->genlist, &(ad->itc_2text_1icon_3),
1487 __setting_storage_main_Gendial_mouse_up_cb,
1488 ad, SWALLOW_Type_INVALID, SETTING_STORAGE_PICS_ICON_PATH,
1489 NULL, 0, SETTING_STORAGE_PICS_STR,
1490 _("IDS_ST_HEADER_PLEASE_WAIT"), NULL);
1491 if (ad->pics_videos) {
1492 ad->pics_videos->userdata = ad;
1494 elm_genlist_item_select_mode_set(ad->pics_videos->item, ELM_OBJECT_SELECT_MODE_DISPLAY_ONLY);
1497 SETTING_TRACE_ERROR("ad->pics_videos is NULL");
1498 return SETTING_RETURN_FAIL;
1502 ad->audio = setting_create_Gendial_field_def(ad->genlist, &(ad->itc_2text_1icon_3),
1503 __setting_storage_main_Gendial_mouse_up_cb,
1504 ad, SWALLOW_Type_INVALID, SETTING_STORAGE_AUDIO_ICON_PATH,
1505 NULL, 0, SETTING_STORAGE_AUDIO_STR,
1506 _("IDS_ST_HEADER_PLEASE_WAIT"), NULL);
1508 ad->audio->userdata = ad;
1511 elm_genlist_item_select_mode_set(ad->audio->item, ELM_OBJECT_SELECT_MODE_DISPLAY_ONLY);
1514 SETTING_TRACE_ERROR("ad->audio is NULL");
1515 return SETTING_RETURN_FAIL;
1518 /* Miscellaneous files */
1519 ad->others = setting_create_Gendial_field_def(ad->genlist, &(ad->itc_2text_1icon_3),
1520 __setting_storage_main_Gendial_mouse_up_cb,
1521 ad, SWALLOW_Type_INVALID, SETTING_STORAGE_MISCES_ICON_PATH,
1522 NULL, 0, SETTING_STORAGE_MISCES_STR,
1523 _("IDS_ST_HEADER_PLEASE_WAIT"), NULL);
1525 ad->others->userdata = ad;
1527 SETTING_TRACE_ERROR("ad->others is NULL");
1528 return SETTING_RETURN_FAIL;
1532 char avail_desc[SETTING_STORAGE_MAX_STR_LEN + 1] = {0,};
1533 ret = __setting_storage_status_size_transition(ad->internal_status.dAvail, avail_desc);
1534 setting_retvm_if(ret == SETTING_RETURN_FAIL, SETTING_RETURN_FAIL, "failed to transform")
1536 ad->avail = setting_create_Gendial_field_def(ad->genlist, &(ad->itc_2text_1icon_3), NULL,
1537 ad, SWALLOW_Type_INVALID, SETTING_STORAGE_AVAIL_ICON_PATH,
1538 NULL, 0, SETTING_STORAGE_AVAIL_STR,
1541 ad->avail->userdata = ad;
1542 elm_genlist_item_select_mode_set(ad->avail->item, ELM_OBJECT_SELECT_MODE_DISPLAY_ONLY);
1544 SETTING_TRACE_ERROR("ad->avail is NULL");
1545 return SETTING_RETURN_FAIL;
1550 /* Format USB storage */
1551 setting_create_Gendial_field_def(ad->genlist, &(ad->itc_1text), NULL,
1552 ad, SWALLOW_Type_INVALID, NULL,
1554 SETTING_STORAGE_FORMAT_STR,
1557 setting_create_Gendial_field_def(ad->genlist, &(ad->itc_bg_1icon), NULL,
1558 ad, SWALLOW_Type_LAYOUT_SPECIALIZTION_X,
1559 NULL, NULL, 0, SETTING_STORAGE_FORMAT_DESC_STR, NULL,
1564 setting_create_Gendial_field_titleItem(ad->genlist, &(ad->itc_group_item),
1565 "IDS_ST_BODY_SD_CARD", NULL);
1566 __setting_storage_main_sd_card_info_append(ad);
1568 ret = vconf_notify_key_changed(VCONFKEY_SYSMAN_MMC_STATUS,
1569 __setting_storage_vconf_change_cb, ad);
1571 SETTING_TRACE_ERROR("call vconf_notify_key_changed failed");
1574 item = elm_genlist_item_append(ad->genlist, &itc_bottom_seperator, NULL, NULL,
1575 ELM_GENLIST_ITEM_NONE, NULL, NULL);
1576 elm_genlist_item_select_mode_set(item, ELM_OBJECT_SELECT_MODE_DISPLAY_ONLY);
1579 setting_view_storage_main.is_create = 1;
1582 ecore_pipe_del(ad->pipe);
1585 ad->pipe = ecore_pipe_add(__setting_storage_main_pipe_cb, ad);
1588 ret = pthread_create(&ad->tid, NULL, __setting_storage_main_thread_start_routine, ad);
1590 SETTING_TRACE_ERROR("fail to pthread_create");
1592 SETTING_TRACE("thread id = %d", ad->tid);
1596 SETTING_TRACE_ERROR("fail to ecore_pipe_add");
1599 return SETTING_RETURN_SUCCESS;
1602 static int setting_storage_main_destroy(void *cb)
1605 retv_if(cb == NULL, SETTING_GENERAL_ERR_NULL_DATA_PARAMETER);
1607 SettingStorageUG *ad = (SettingStorageUG *) cb;
1611 pthread_mutex_lock(&ad->exit_mutex);
1613 pthread_mutex_unlock(&ad->exit_mutex);
1615 /* wake up thread */
1616 pthread_mutex_lock(&ad->update_mutex);
1617 ad->type = SETTING_STORAGE_REUPDATE;
1618 pthread_cond_signal(&ad->wait_cond);
1619 pthread_mutex_unlock(&ad->update_mutex);
1623 void *thread_ret = NULL;
1624 ret = pthread_join(ad->tid, &thread_ret);
1626 SETTING_TRACE_ERROR("fail to join with thread");
1628 SETTING_TRACE("thread exit code %d", (int)thread_ret);
1631 pthread_mutex_destroy(&ad->exit_mutex);
1632 pthread_mutex_destroy(&ad->update_mutex);
1633 pthread_cond_destroy(&ad->wait_cond);
1636 ecore_pipe_del(ad->pipe);
1641 ret = vconf_ignore_key_changed(VCONFKEY_SYSMAN_MMC_STATUS,
1642 __setting_storage_vconf_change_cb);
1644 SETTING_TRACE_ERROR("call vconf_ignore_key_changed failed");
1649 evas_object_del(ad->popup);
1653 if (ad->ly_main != NULL) {
1654 evas_object_del(ad->ly_main);
1655 setting_view_storage_main.is_create = 0;
1658 return SETTING_RETURN_SUCCESS;
1661 static int setting_storage_main_update(void *cb)
1663 SETTING_TRACE_BEGIN;
1665 retv_if(cb == NULL, SETTING_GENERAL_ERR_NULL_DATA_PARAMETER);
1666 SettingStorageUG *ad = (SettingStorageUG *) cb;
1670 __setting_storage_main_internal_storage_status_get(ad);
1672 /* update internal total size */
1673 char total_desc[SETTING_STORAGE_MAX_STR_LEN + 1] = {0,};
1674 ret = __setting_storage_status_size_transition(ad->internal_status.dTotal, total_desc);
1675 setting_retvm_if(ret == SETTING_RETURN_FAIL, SETTING_RETURN_FAIL, "failed to transform")
1677 G_FREE(ad->internal->keyStr);
1678 ad->internal->keyStr = (char *)g_strdup(total_desc);
1679 elm_object_item_data_set(ad->internal->item, ad->internal);
1680 elm_genlist_item_update(ad->internal->item);
1682 /* update internal available size */
1683 char avail_desc[SETTING_STORAGE_MAX_STR_LEN + 1] = {0,};
1684 ret = __setting_storage_status_size_transition(ad->internal_status.dAvail, avail_desc);
1685 setting_retvm_if(ret == SETTING_RETURN_FAIL, SETTING_RETURN_FAIL, "failed to transform")
1687 G_FREE(ad->avail->sub_desc);
1688 ad->avail->sub_desc = (char *)g_strdup(avail_desc);
1689 elm_object_item_data_set(ad->avail->item, ad->avail);
1690 elm_genlist_item_update(ad->avail->item);
1692 /* update miscellaneous */
1693 if (ad->back_from_misc) {
1694 double misc_size = __setting_storage_main_miscellaneous_size_get();
1696 ad->others_status.dTotal = misc_size;
1697 __setting_storage_main_genlist_update(ad->others, ad->others_status);
1700 /* wake up thread */
1701 pthread_mutex_lock(&ad->update_mutex);
1702 ad->type = SETTING_STORAGE_REUPDATE;
1703 pthread_cond_signal(&ad->wait_cond);
1704 pthread_mutex_unlock(&ad->update_mutex);
1706 if (ad->ly_main != NULL) {
1707 evas_object_show(ad->ly_main);
1710 return SETTING_RETURN_SUCCESS;
1713 static int setting_storage_main_cleanup(void *cb)
1716 retv_if(cb == NULL, SETTING_GENERAL_ERR_NULL_DATA_PARAMETER);
1718 SettingStorageUG *ad = (SettingStorageUG *) cb;
1720 if (ad->ly_main != NULL) {
1721 evas_object_hide(ad->ly_main);
1724 return SETTING_RETURN_SUCCESS;
1727 /* ***************************************************
1731 ***************************************************/
1733 static void __setting_storage_main_click_softkey_back_cb(void *data, Evas_Object *obj,
1737 ret_if(data == NULL);
1739 SettingStorageUG *ad = (SettingStorageUG *) data;
1740 /* Send destroy request */
1741 ug_destroy_me(ad->ug);