4 * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd.
6 * Contact: MyoungJune Park <mj2004.park@samsung.com>
8 * Licensed under the Apache License, Version 2.0 (the "License");
9 * you may not use this file except in compliance with the License.
10 * You may obtain a copy of the License at
12 * http://www.apache.org/licenses/LICENSE-2.0
14 * Unless required by applicable law or agreed to in writing, software
15 * distributed under the License is distributed on an "AS IS" BASIS,
16 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
17 * See the License for the specific language governing permissions and
18 * limitations under the License.
21 #include <setting-storage-main.h>
23 #include <package-manager.h>
26 static int setting_storage_main_create(void *cb);
27 static int setting_storage_main_destroy(void *cb);
28 static int setting_storage_main_update(void *cb);
29 static int setting_storage_main_cleanup(void *cb);
31 static void __setting_storage_main_click_softkey_back_cb(void *data, Evas_Object *obj,
34 setting_view setting_view_storage_main = {
35 .create = setting_storage_main_create,
36 .destroy = setting_storage_main_destroy,
37 .update = setting_storage_main_update,
38 .cleanup = setting_storage_main_cleanup,
41 static Evas_Object *__setting_storage_main_image_add(Evas *evas, char *icon_path, int width, int height)
43 Evas_Object *image = NULL;
44 image = evas_object_image_add(evas);
45 evas_object_size_hint_weight_set(image, 0.0, EVAS_HINT_EXPAND);
46 evas_object_image_load_size_set(image, width, height);
47 evas_object_image_file_set(image, icon_path, NULL);
48 evas_object_image_fill_set(image, 0, 0, width, height);
49 evas_object_size_hint_min_set(image, width, height);
50 evas_object_show(image);
55 static char *__gl_text_get(void *data, Evas_Object *obj, const char *part)
58 Setting_GenGroupItem_Data *item_data = data;
60 if (!safeStrCmp(part, "elm.text.1")) {
61 return (char *)g_strdup(item_data->keyStr);
66 static Evas_Object *__gl_content_get(void *data, Evas_Object *obj, const char *part)
69 Setting_GenGroupItem_Data *item_data = data;
70 SettingStorageUG *ad = (SettingStorageUG *) item_data->userdata;
72 int width = SETTING_STORAGE_ICON_WIDTH;
73 int height = SETTING_STORAGE_ICON_HEIGHT;
75 app_device_orientation_e m = elm_win_rotation_get(ad->win_get);
76 if(APP_DEVICE_ORIENTATION_90 == m || APP_DEVICE_ORIENTATION_270 == m) {
77 width = SETTING_STORAGE_ICON_LANDSCAPE_WIDTH;
79 width = SETTING_STORAGE_ICON_WIDTH;
81 float temp_size = 0.0;
83 /* use size (applications + picture/videos + audio + miscellaneous + available) as 100% */
84 double total_size = ad->apps_status.dTotal + ad->pics_videos_status.dTotal +
85 + ad->audio_status.dTotal +
86 ad->others_status.dTotal + ad->internal_status.dAvail;
88 if (!safeStrCmp(part, "elm.icon")){
89 Evas_Object *status_box = NULL;
90 status_box = elm_box_add(obj);
91 retvm_if(status_box == NULL, NULL, "Cannot get box");
92 item_data->eo_check = status_box;
93 elm_box_horizontal_set(status_box, 1);
94 evas_object_size_hint_align_set(status_box, 0.0, EVAS_HINT_FILL);
95 evas_object_show(status_box);
97 Evas *evas = evas_object_evas_get(obj);
100 unsigned int apps_size = 0;
101 temp_size = ((float)ad->apps_status.dTotal / total_size) * width;
102 if (temp_size < 1 && temp_size > 0) {
105 apps_size = (unsigned int)temp_size;
108 Evas_Object *apps = __setting_storage_main_image_add(evas, SETTING_STORAGE_APPS_ICON_PATH, apps_size, height);
109 elm_box_pack_end(status_box, apps);
112 /* pictures, videos */
113 unsigned int pics_videos_size = 0;
114 temp_size = ((float)ad->pics_videos_status.dTotal / total_size) * width;
115 if (temp_size < 1 && temp_size > 0) {
116 pics_videos_size = 1;
118 pics_videos_size = (unsigned int)temp_size;
120 if (pics_videos_size > 0) {
121 Evas_Object *pics = __setting_storage_main_image_add(evas, SETTING_STORAGE_PICS_ICON_PATH, pics_videos_size, height);
122 elm_box_pack_end(status_box, pics);
126 unsigned int audio_size = 0;
127 temp_size = ((float)ad->audio_status.dTotal / total_size) * width;
128 if (temp_size < 1 && temp_size > 0) {
131 audio_size = (unsigned int)temp_size;
133 if (audio_size > 0) {
134 Evas_Object *audio = __setting_storage_main_image_add(evas, SETTING_STORAGE_AUDIO_ICON_PATH, audio_size, height);
135 elm_box_pack_end(status_box, audio);
138 /* Miscellaneous files */
139 unsigned int others_size = 0;
140 temp_size = ((float)ad->others_status.dTotal / total_size) * width;
141 if (temp_size < 1 && temp_size > 0) {
144 others_size = (unsigned int)temp_size;
146 if (others_size > 0) {
147 Evas_Object *misc = __setting_storage_main_image_add(evas, SETTING_STORAGE_MISCES_ICON_PATH, others_size, height);
148 elm_box_pack_end(status_box, misc);
152 unsigned int avail_size = 0;
153 temp_size = ((float)ad->internal_status.dAvail / total_size) * width;
154 if (temp_size < 1 && temp_size > 0) {
157 avail_size = (unsigned int)temp_size;
159 int sum = apps_size + pics_videos_size + audio_size + others_size;
160 if ((sum + avail_size) > width) {
161 avail_size = width - sum;
164 if (avail_size > 0) {
165 Evas_Object *avail = __setting_storage_main_image_add(evas, SETTING_STORAGE_AVAIL_ICON_PATH, avail_size, height);
166 elm_box_pack_end(status_box, avail);
174 static void __gl_del(void *data, Evas_Object *obj)
176 /* SETTING_TRACE_BEGIN; */
177 Setting_GenGroupItem_Data *item_data = (Setting_GenGroupItem_Data *) data;
179 G_FREE(item_data->keyStr);
184 static int __setting_storage_main_fs_stat(double *total, double *avail, const char *path)
187 setting_retvm_if(NULL == total || NULL == avail, SETTING_RETURN_FAIL, "Null output parameters");
191 if (!statvfs(path, &s)) {
192 SETTING_TRACE("f_bsize = %ld f_blocks = %ld f_bavail = %ld f_frsize = %ld",
193 s.f_bsize, s.f_blocks, s.f_bavail, s.f_frsize);
194 *total = (double)s.f_frsize * s.f_blocks;
195 *avail = (double)s.f_bsize * s.f_bavail;
197 return SETTING_RETURN_FAIL;
200 return SETTING_RETURN_SUCCESS;
203 static int __setting_storage_status_size_transition(double size, char *size_desc)
205 //SETTING_TRACE_BEGIN;
206 //SETTING_TRACE("size = %f", size);
207 double tmp_size = 0.0;
209 if (size < SETTING_STORAGE_MEGABYTE_VALUE) { // size < 1MB: show x.xKB
210 tmp_size = size / SETTING_STORAGE_KILOBYTE_VALUE;
211 ret = snprintf(size_desc, SETTING_STORAGE_MAX_STR_LEN, "%4.2lf%s", tmp_size, "KB");
212 retv_if(ret < 0, SETTING_RETURN_FAIL);
213 } else if (size < SETTING_STORAGE_GIGABYTE_VALUE) { // size < 1GB: show x.xMB
214 tmp_size = size / SETTING_STORAGE_MEGABYTE_VALUE;
215 ret = snprintf(size_desc, SETTING_STORAGE_MAX_STR_LEN, "%4.2lf%s", tmp_size, "MB");
216 retv_if(ret < 0, SETTING_RETURN_FAIL);
217 } else { // 1G <= size: show x.xGB
218 tmp_size = size / SETTING_STORAGE_GIGABYTE_VALUE;
219 ret = snprintf(size_desc, SETTING_STORAGE_MAX_STR_LEN, "%4.2lf%s", tmp_size, "GB");
220 retv_if(ret < 0, SETTING_RETURN_FAIL);
223 return SETTING_RETURN_SUCCESS;
227 static void __setting_storage_main_internal_storage_status_get(void *data)
230 setting_retm_if(data == NULL, "Data parameter is NULL");
231 SettingStorageUG *ad = (SettingStorageUG *) data;
235 int ret = SETTING_RETURN_SUCCESS;
236 Setting_Storage_Status internal_status;
238 ret = __setting_storage_main_fs_stat(&dTotal, &dAvail, SETTING_STORAGE_OPT_USR_PATH);
239 setting_retm_if(ret == SETTING_RETURN_FAIL, "get opt status failed");
240 internal_status.dTotal = dTotal;
241 internal_status.dAvail = dAvail;
243 ad->internal_status = internal_status;
246 static bool __setting_storage_main_media_item_cb(media_info_h media, void *data)
248 //SETTING_TRACE_BEGIN;
249 setting_retvm_if(media == NULL, true, "media is NULL");
250 setting_retvm_if(data == NULL, true, "Data parameter is NULL");
251 double *total_size = (double *) data;
253 unsigned long long size = 0;
255 char *file_path = NULL;
256 media_info_get_file_path(media, &file_path);
258 if (!ecore_file_exists(file_path)) {
264 media_info_get_size(media, &size);
265 //SETTING_TRACE("size : [%lld]", size);
271 static double __setting_storage_main_pictures_videos_status_get()
274 double total_size = 0.0;
276 int ret = MEDIA_CONTENT_ERROR_NONE;
277 filter_h filter = NULL;
280 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*/
282 ret = media_filter_create(&filter);
283 if(ret != MEDIA_CONTENT_ERROR_NONE) {
284 SETTING_TRACE_ERROR("Fail to create filter");
288 ret = media_filter_set_condition(filter, condition, MEDIA_CONTENT_COLLATE_DEFAULT);
289 if(ret != MEDIA_CONTENT_ERROR_NONE) {
290 media_filter_destroy(filter);
291 SETTING_TRACE_ERROR("Fail to set condition");
295 ret = media_info_foreach_media_from_db(filter, __setting_storage_main_media_item_cb, &total_size);
296 if(ret != MEDIA_CONTENT_ERROR_NONE) {
297 media_filter_destroy(filter);
298 SETTING_TRACE_ERROR("Fail to get media");
302 ret = media_filter_destroy(filter);
303 if (ret != MEDIA_CONTENT_ERROR_NONE) {
304 SETTING_TRACE_ERROR("destroy filter failed\n\n");
311 static double __setting_storage_main_audio_status_get()
315 double total_size = 0.0;
317 int ret = MEDIA_CONTENT_ERROR_NONE;
318 filter_h filter = NULL;
321 char *condition = "MEDIA_TYPE=3 and MEDIA_PATH LIKE \'/opt/usr/%%\'"; /*0-image, 1-video, 2-sound, 3-music, 4-other*/
323 ret = media_filter_create(&filter);
324 if(ret != MEDIA_CONTENT_ERROR_NONE) {
325 SETTING_TRACE("Fail to create filter");
329 ret = media_filter_set_condition(filter, condition, MEDIA_CONTENT_COLLATE_DEFAULT);
330 if(ret != MEDIA_CONTENT_ERROR_NONE) {
331 media_filter_destroy(filter);
332 SETTING_TRACE("Fail to set condition");
336 ret = media_info_foreach_media_from_db(filter, __setting_storage_main_media_item_cb, &total_size);
337 if(ret != MEDIA_CONTENT_ERROR_NONE) {
338 media_filter_destroy(filter);
339 SETTING_TRACE("Fail to get media");
343 ret = media_filter_destroy(filter);
344 if (ret != MEDIA_CONTENT_ERROR_NONE) {
345 SETTING_TRACE_ERROR("destroy filter failed\n\n");
352 static bool __setting_storage_main_other_item_cb(media_info_h media, void *data)
354 //SETTING_TRACE_BEGIN;
355 setting_retvm_if(media == NULL, true, "media is NULL");
356 setting_retvm_if(data == NULL, true, "Data parameter is NULL");
357 double *total_size = (double *) data;
359 unsigned long long size = 0;
361 char *file_path = NULL;
362 media_info_get_file_path(media, &file_path);
364 if (!ecore_file_exists(file_path)) {
369 if (!safeStrNCmp(file_path, PATH1, sizeof(PATH1)) ||
370 !safeStrNCmp(file_path, PATH2, sizeof(PATH2)) ||
371 !safeStrNCmp(file_path, PATH3, sizeof(PATH3)) ||
372 !safeStrNCmp(file_path, PATH4, sizeof(PATH4)) ||
373 !safeStrNCmp(file_path, PATH5, sizeof(PATH5)) ||
374 !safeStrNCmp(file_path, PATH6, sizeof(PATH6)) ||
375 !safeStrNCmp(file_path, PATH7, sizeof(PATH7)) ||
376 !safeStrNCmp(file_path, PATH8, sizeof(PATH8)) ||
377 !safeStrNCmp(file_path, PATH9, sizeof(PATH9)))
383 media_info_get_size(media, &size);
384 //SETTING_TRACE("size : [%lld]", size);
391 * Miscellaneous files is all directories files under /opt/usr/media/ except below default directories:
392 * ++++++++++++++++++++++++++++++++++++++++++++++++
395 * drwxrwxrwx 11 app app 4096 Jan 4 12:42 .
396 * drwxr-xr-x 20 root root 4096 Jan 7 10:09 ..
397 * drwxr-xr-x 2 root root 4096 Jan 4 08:46 .tmp_download
398 * drwxr-xr-x 2 app app 4096 Jan 4 08:47 .video-hub
399 * drwxrwxrwx 2 app app 4096 Oct 5 2012 Camera
400 * drwxrwxrwx 3 app app 4096 Jan 4 08:46 Downloads
401 * drwxrwxrwx 2 app app 4096 Oct 5 2012 Images
402 * drwxrwxrwx 2 app app 4096 Oct 5 2012 Others
403 * drwxrwxrwx 3 app app 4096 Oct 5 2012 Sounds
404 * drwxrwxrwx 2 app app 4096 Oct 5 2012 Videos
405 * drwxrwxrwx 2 app app 16384 Oct 5 2012 lost+found
406 * ++++++++++++++++++++++++++++++++++++++++++++++++
408 static double __setting_storage_main_miscellaneous_size_get()
411 double total_size = 0.0;
413 int ret = MEDIA_CONTENT_ERROR_NONE;
414 filter_h filter = NULL;
417 char *condition = "(MEDIA_TYPE=4) and MEDIA_PATH LIKE \'/opt/usr/media/%%\'";
419 ret = media_filter_create(&filter);
420 if(ret != MEDIA_CONTENT_ERROR_NONE) {
421 SETTING_TRACE_ERROR("Fail to create filter");
425 ret = media_filter_set_condition(filter, condition, MEDIA_CONTENT_COLLATE_DEFAULT);
426 if(ret != MEDIA_CONTENT_ERROR_NONE) {
427 media_filter_destroy(filter);
428 SETTING_TRACE_ERROR("Fail to set condition");
432 ret = media_info_foreach_media_from_db(filter, __setting_storage_main_other_item_cb, &total_size);
433 if(ret != MEDIA_CONTENT_ERROR_NONE) {
434 media_filter_destroy(filter);
435 SETTING_TRACE_ERROR("Fail to get media");
439 ret = media_filter_destroy(filter);
440 if (ret != MEDIA_CONTENT_ERROR_NONE) {
441 SETTING_TRACE_ERROR("destroy filter failed");
448 static void __setting_storage_main_launch_ug_destroy_cb(ui_gadget_h ug, void *priv)
451 /* restore the '<-' button on the navigate bar */
452 retm_if(priv == NULL, "priv is NULL");
453 SettingStorageUG *ad = (SettingStorageUG *) priv;
457 Elm_Object_Item *navi_it = elm_naviframe_top_item_get(ad->navibar);
458 retm_if(navi_it == NULL, "navi_it is NULL");
459 Evas_Object *back_btn = elm_object_item_part_content_get(navi_it, "prev_btn");
461 if (back_btn != NULL) {
462 elm_object_style_set(back_btn, NAVI_BACK_BUTTON_STYLE); /* take into effect */
465 setting_view_update(&setting_view_storage_main, ad);
468 static void __setting_storage_main_launch_ug_layout_cb(ui_gadget_h ug, enum ug_mode mode, void *priv)
471 retm_if(priv == NULL, "priv is NULL");
472 SettingStorageUG *ad = (SettingStorageUG *) priv;
473 Evas_Object *base = NULL;
474 base = (Evas_Object *) ug_get_layout(ug);
475 retm_if(base == NULL, "base is NULL");
478 case UG_MODE_FULLVIEW:
479 evas_object_size_hint_weight_set(base, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
480 //elm_win_resize_object_add(ad->win_get, base);
481 evas_object_show(base);
489 static void __setting_storage_main_launch_manage_app_ug(void *data)
493 retm_if(data == NULL, "Data parameter is NULL");
495 SettingStorageUG *ad = (SettingStorageUG *) data;
498 if (service_create(&svc)) {
502 service_add_extra_data(svc, "viewtype", "manage-applications");
504 struct ug_cbs *cbs = (struct ug_cbs *)calloc(1, sizeof(struct ug_cbs));
506 SETTING_TRACE_ERROR("calloc failed");
507 service_destroy(svc);
510 cbs->layout_cb = __setting_storage_main_launch_ug_layout_cb;
511 cbs->result_cb = NULL;
512 cbs->destroy_cb = __setting_storage_main_launch_ug_destroy_cb;
513 cbs->priv = (void *)ad;
515 ui_gadget_h ug = ug_create(ad->ug, "setting-manage-applications-efl", UG_MODE_FULLVIEW, svc, cbs);
516 if (NULL == ug) { /* error handling */
517 SETTING_TRACE_ERROR("NULL == ug");
521 service_destroy(svc);
525 static void __setting_storage_main_app_launch(char *app_name)
528 setting_retm_if(app_name == NULL, "app_name is NULL");
530 app_launcher(app_name);
533 static void __setting_storage_main_Gendial_mouse_up_cb(void *data, Evas_Object *obj, void *event_info)
537 setting_retm_if(data == NULL, "Data parameter is NULL");
538 Elm_Object_Item *item = (Elm_Object_Item *) event_info;
539 elm_genlist_item_selected_set(item, 0);
540 Setting_GenGroupItem_Data *list_item = (Setting_GenGroupItem_Data *) elm_object_item_data_get(item);
542 SettingStorageUG *ad = (SettingStorageUG *) data;
544 SETTING_TRACE("clicking item[%s]", _(list_item->keyStr));
547 if (!safeStrCmp(SETTING_STORAGE_DEFAULT_STORAGE_STR, list_item->keyStr)) {
548 setting_view_change(&setting_view_storage_main,
549 &setting_view_storage_default_storage, ad);
550 } else if (!safeStrCmp(SETTING_STORAGE_MISCES_STR, list_item->keyStr)) {
551 setting_view_change(&setting_view_storage_main,
552 &setting_view_storage_miscellaneous_files, ad);
557 if (!safeStrCmp("IDS_ST_BODY_APPLICATIONS", list_item->keyStr)) {
558 __setting_storage_main_launch_manage_app_ug(ad);
559 } else if (!safeStrCmp(SETTING_STORAGE_DEFAULT_STORAGE_STR, list_item->keyStr)) {
560 setting_view_change(&setting_view_storage_main,
561 &setting_view_storage_default_storage, ad);
562 } else if (!safeStrCmp(SETTING_STORAGE_PICS_STR, list_item->keyStr)) {
563 __setting_storage_main_app_launch("org.tizen.gallery");
564 } else if (!safeStrCmp(SETTING_STORAGE_AUDIO_STR, list_item->keyStr)) {
565 __setting_storage_main_app_launch("org.tizen.music-player");
566 } else if (!safeStrCmp(SETTING_STORAGE_MISCES_STR, list_item->keyStr)) {
567 setting_view_change(&setting_view_storage_main,
568 &setting_view_storage_miscellaneous_files, ad);
575 static int __setting_storage_main_check_mmc_status()
578 struct stat parent_stat, mount_stat;
580 ret = stat(SETTING_STORAGE_MMC_PATH, &mount_stat);
581 setting_retvm_if(ret != 0, -1, "get stat error : /opt/storage/sdcard");
583 ret = stat(SETTING_STORAGE_MMC_PARENT_PATH, &parent_stat);
584 setting_retvm_if(ret != 0, -1, "get stat error : /opt/storage/sdcard/..");
586 /* Does not mounted, same st_dev */
587 if(mount_stat.st_dev == parent_stat.st_dev) {
589 } else { /* MMC mounted, diff st_dev */
594 static void __setting_storage_main_sd_card_info_get(char* szTotal, char* szAvail)
596 int mmc_status = __setting_storage_main_check_mmc_status();
597 setting_retm_if(mmc_status == -1, "check mmc status failed");
599 /* Does not mounted, same st_dev */
600 if (mmc_status == 0) {
601 snprintf(szTotal, SETTING_STORAGE_MAX_STR_LEN, "%s", _("IDS_ST_HEADER_UNAVAILABLE"));
602 snprintf(szAvail, SETTING_STORAGE_MAX_STR_LEN, "%s", _("IDS_ST_HEADER_UNAVAILABLE"));
604 /* MMC mounted, diff st_dev */
609 int ret = SETTING_RETURN_SUCCESS;
610 ret = __setting_storage_main_fs_stat(&dTotal, &dAvail, SETTING_STORAGE_MMC_PATH);
611 setting_retm_if(ret == SETTING_RETURN_FAIL, "get sd card size detail failed");
613 ret = __setting_storage_status_size_transition(dTotal, szTotal);
614 setting_retm_if(ret == SETTING_RETURN_FAIL, "__setting_storage_status_size_transition failed");
616 ret = __setting_storage_status_size_transition(dAvail, szAvail);
617 setting_retm_if(ret == SETTING_RETURN_FAIL, "__setting_storage_status_size_transition failed");
619 SETTING_TRACE("Total[%s], Avail[%s]", szTotal, szAvail);
623 static int __setting_storage_main_mmc_content_init(void *data, setting_storage_mmc_cb cb)
626 setting_retvm_if(NULL == data, SETTING_RETURN_FAIL, "data is NULL");
627 setting_retvm_if(NULL == cb, SETTING_RETURN_FAIL, "cb is NULL");
628 SettingStorageUG *ad = (SettingStorageUG *)data;
629 if (ad->mmc_content == NULL) {
630 ad->mmc_content = (struct mmc_contents *)calloc(1, sizeof(struct mmc_contents *));
631 if (ad->mmc_content == NULL ) {
632 SETTING_TRACE_ERROR("calloc failed");
633 return SETTING_RETURN_FAIL;
636 ad->mmc_content->mmc_cb = cb;
637 ad->mmc_content->user_data = ad;
638 return SETTING_RETURN_SUCCESS;
641 #if SUPPORT_SD_CARD_FORMAT
642 static void __setting_storage_status_sd_card_popup_format_response_cb(void *data,
643 Evas_Object *obj, void *event_info)
646 setting_retm_if(data == NULL, "Data parameter is NULL");
647 SettingStorageUG *ad = (SettingStorageUG *)data;
650 evas_object_del(ad->popup);
654 char sd_total[SETTING_STORAGE_MAX_STR_LEN] = { 0, };
655 char sd_available[SETTING_STORAGE_MAX_STR_LEN] = { 0, };
656 __setting_storage_main_sd_card_info_get(sd_total, sd_available);
659 G_FREE(ad->sd_total->sub_desc);
660 ad->sd_total->sub_desc = (char *)g_strdup(sd_total);
661 elm_object_item_data_set(ad->sd_total->item, ad->sd_total);
662 elm_genlist_item_update(ad->sd_total->item);
664 if (ad->sd_available) {
665 G_FREE(ad->sd_available->sub_desc);
666 ad->sd_available->sub_desc = (char *)g_strdup(sd_available);
667 elm_object_item_data_set(ad->sd_available->item, ad->sd_available);
668 elm_genlist_item_update(ad->sd_available->item);
673 static void __setting_storage_status_sd_card_popup_response_cb(void *data,
674 Evas_Object *obj, void *event_info)
677 setting_retm_if(data == NULL, "Data parameter is NULL");
678 SettingStorageUG *ad = (SettingStorageUG *)data;
681 evas_object_del(ad->popup);
686 static void __setting_storage_main_sd_card_mount_cb(int val, void *data)
689 setting_retm_if(data == NULL, "Data parameter is NULL");
690 SettingStorageUG *ad = (SettingStorageUG *) data;
693 evas_object_del(ad->popup);
698 if (val == SETTING_STORAGE_SYSMAN_REQUEST_SUCCESS) {
700 SETTING_TRACE("mount success");
702 } else if (val == SETTING_STORAGE_SYSMAN_REQUEST_MOUNT_ALREADY) {
703 desc = _(SETTING_STORAGE_SD_CARD_MOUNT_ALREADY_DESC);
705 desc = _("IDS_COM_POP_FAILED");
708 ad->popup = setting_create_popup_without_btn(ad, ad->win_get, NULL, desc,
709 __setting_storage_status_sd_card_popup_response_cb,
710 SETTING_STORAGE_POPUP_TIMER, FALSE, FALSE);
713 static void __setting_storage_main_sd_card_unmount_cb(int val, void *data)
716 setting_retm_if(data == NULL, "Data parameter is NULL");
717 SettingStorageUG *ad = (SettingStorageUG *) data;
720 evas_object_del(ad->popup);
724 if (val == SETTING_STORAGE_SYSMAN_REQUEST_SUCCESS) {
726 SETTING_TRACE("unmount success");
729 ad->popup = setting_create_popup_without_btn(ad, ad->win_get, NULL, _("IDS_COM_POP_FAILED"),
730 __setting_storage_status_sd_card_popup_response_cb,
731 SETTING_STORAGE_POPUP_TIMER, FALSE, FALSE);
735 static void __setting_storage_main_sd_card_mount_unmount(void *data)
738 setting_retm_if(data == NULL, "Data parameter is NULL");
739 SettingStorageUG *ad = (SettingStorageUG *)data;
741 int mmc_status = __setting_storage_main_check_mmc_status();
742 setting_retm_if(mmc_status == -1, "check mmc status failed");
745 evas_object_del(ad->popup);
749 /* Show progressbar popup */
750 ad->popup = setting_create_popup_with_progressbar(ad, ad->win_get,
751 "pending_list", NULL, NULL,
752 __setting_storage_status_sd_card_popup_response_cb,
753 SETTING_STORAGE_PROGRESSBAR_TIMEOUT, TRUE, TRUE);
756 /* Does not mounted, same st_dev */
757 if (mmc_status == 0) {
758 ret = __setting_storage_main_mmc_content_init(ad, __setting_storage_main_sd_card_mount_cb);
759 if (ret == SETTING_RETURN_FAIL) {
760 SETTING_TRACE_ERROR("__setting_storage_main_mmc_content_init fail");
762 evas_object_del(ad->popup);
765 ad->popup = setting_create_popup_without_btn(ad, ad->win_get,
766 NULL, _("IDS_COM_POP_FAILED"),
767 __setting_storage_status_sd_card_popup_response_cb,
768 SETTING_STORAGE_POPUP_TIMER, FALSE, FALSE);
771 ret = sysman_request_mount_mmc(ad->mmc_content);
773 SETTING_TRACE_ERROR("fail to call sysman_request_mount_mmc");
776 /* MMC mounted, diff st_dev */
778 ret = __setting_storage_main_mmc_content_init(ad, __setting_storage_main_sd_card_unmount_cb);
779 if (ret == SETTING_RETURN_FAIL) {
780 SETTING_TRACE_ERROR("__setting_storage_main_sd_card_unmount_cb fail");
782 evas_object_del(ad->popup);
785 ad->popup = setting_create_popup_without_btn(ad, ad->win_get,
786 NULL, _("IDS_COM_POP_FAILED"),
787 __setting_storage_status_sd_card_popup_response_cb,
788 SETTING_STORAGE_POPUP_TIMER, FALSE, FALSE);
792 ret = sysman_request_unmount_mmc(ad->mmc_content,
793 MNT_FORCE); /* 1 = MNT_FORCE */
795 SETTING_TRACE_ERROR("fail to call sysman_request_unmount_mmc");
799 /* if fail, popup failed info */
802 evas_object_del(ad->popup);
805 ad->popup = setting_create_popup_without_btn(ad, ad->win_get,
806 NULL, _("IDS_COM_POP_FAILED"),
807 __setting_storage_status_sd_card_popup_response_cb,
808 SETTING_STORAGE_POPUP_TIMER, FALSE, FALSE);
812 #if SUPPORT_SD_CARD_FORMAT
813 static void __setting_storage_main_sd_card_scan_cb(media_content_error_e err, void *data)
816 setting_retm_if(data == NULL, "Data parameter is NULL");
817 SettingStorageUG *ad = (SettingStorageUG *) data;
819 SETTING_TRACE("scan_cb result = %d", err);
822 evas_object_del(ad->popup);
826 if (err == MEDIA_CONTENT_ERROR_NONE) {
827 ad->popup = setting_create_popup_without_btn(ad, ad->win_get, NULL, _("IDS_COM_POP_SUCCESS"),
828 __setting_storage_status_sd_card_popup_format_response_cb,
829 SETTING_STORAGE_POPUP_TIMER, FALSE, FALSE);
832 ad->popup = setting_create_popup_without_btn(ad, ad->win_get, NULL, _("IDS_COM_POP_FAILED"),
833 __setting_storage_status_sd_card_popup_response_cb,
834 SETTING_STORAGE_POPUP_TIMER, FALSE, FALSE);
838 static void __setting_storage_main_sd_card_format_cb(int val, void *data)
841 setting_retm_if(data == NULL, "Data parameter is NULL");
842 SettingStorageUG *ad = (SettingStorageUG *) data;
844 if (val == SETTING_STORAGE_SYSMAN_REQUEST_SUCCESS) {
845 int ret = media_content_scan_folder(SETTING_STORAGE_MMC_PATH, __setting_storage_main_sd_card_scan_cb, ad);
847 if(ret != MEDIA_CONTENT_ERROR_NONE) {
848 SETTING_TRACE_ERROR("Fail to media_content_scan_file : %d", ret);
853 evas_object_del(ad->popup);
856 ad->popup = setting_create_popup_without_btn(ad, ad->win_get, NULL, _("IDS_COM_POP_FAILED"),
857 __setting_storage_status_sd_card_popup_response_cb,
858 SETTING_STORAGE_POPUP_TIMER, FALSE, FALSE);
862 static void __setting_storage_main_sd_card_format_popup_yes(void *data)
865 setting_retm_if(data == NULL, "Data parameter is NULL");
866 SettingStorageUG *ad = (SettingStorageUG *) data;
869 evas_object_del(ad->popup);
873 /* Show Formatting..... popup */
874 ad->popup = setting_create_popup_with_progressbar(ad, ad->win_get,
875 "pending_list", NULL,
879 int ret = __setting_storage_main_mmc_content_init(ad, __setting_storage_main_sd_card_format_cb);
880 if (ret == SETTING_RETURN_FAIL) {
881 SETTING_TRACE_ERROR("__setting_storage_main_mmc_content_init fail");
883 evas_object_del(ad->popup);
886 ad->popup = setting_create_popup_without_btn(ad, ad->win_get,
887 NULL, _("IDS_COM_POP_FAILED"),
888 __setting_storage_status_sd_card_popup_response_cb,
889 SETTING_STORAGE_POPUP_TIMER, FALSE, FALSE);
893 ret = sysman_request_format_mmc(ad->mmc_content);
894 /* if fail, destory popup */
896 SETTING_TRACE_ERROR("fail to call sysman_request_format_mmc");
898 evas_object_del(ad->popup);
901 ad->popup = setting_create_popup_without_btn(ad, ad->win_get,
902 NULL, _("IDS_COM_POP_FAILED"),
903 __setting_storage_status_sd_card_popup_response_cb,
904 SETTING_STORAGE_POPUP_TIMER, FALSE, FALSE);
908 static void __setting_storage_main_sd_card_format_popup_no(void *data)
911 setting_retm_if(data == NULL, "Data parameter is NULL");
912 SettingStorageUG *ad = (SettingStorageUG *) data;
915 evas_object_del(ad->popup);
920 static void __setting_storage_main_sd_card_ask_format_resp_cb(void *data, Evas_Object *obj, void *event_info)
923 setting_retm_if(data == NULL, "Data parameter is NULL");
924 int response_type = btn_type(obj);
925 if (POPUP_RESPONSE_OK == response_type) {
926 __setting_storage_main_sd_card_format_popup_yes(data);
927 } else if (POPUP_RESPONSE_CANCEL == response_type) {
928 __setting_storage_main_sd_card_format_popup_no(data);
932 static void __setting_storage_main_sd_card_format_popup_create(void *data)
935 setting_retm_if(data == NULL, "Data parameter is NULL");
936 SettingStorageUG *ad = (SettingStorageUG *) data;
939 evas_object_del(ad->popup);
943 ad->popup = setting_create_popup_with_btn(ad, ad->win_get, NULL,
944 _(SETTING_STORAGE_FORMAT_ASK_MSG),
945 __setting_storage_main_sd_card_ask_format_resp_cb, 0,
946 2, _("IDS_COM_SK_YES"),_("IDS_COM_SK_NO"));
950 static void __setting_storage_main_mouse_up_Gendial_list_cb(void *data, Evas_Object *obj,
954 setting_retm_if(data == NULL, "Data parameter is NULL");
955 setting_retm_if(event_info == NULL, "Invalid argument: event info is NULL");
957 SettingStorageUG *ad = (SettingStorageUG *) data;
958 Elm_Object_Item *item = (Elm_Object_Item *) event_info;
959 elm_genlist_item_selected_set(item, 0);
960 Setting_GenGroupItem_Data *list_item = (Setting_GenGroupItem_Data *) elm_object_item_data_get(item);
962 SETTING_TRACE("clicking item[%s]", _(list_item->keyStr));
965 int ret = vconf_get_int(VCONFKEY_FILEMANAGER_DB_STATUS, &db_status);
966 setting_retm_if(ret != 0, "fail to get vconf");
968 /* if SD card is busy, show popup */
969 if (db_status != VCONFKEY_FILEMANAGER_DB_UPDATED) {
971 evas_object_del(ad->popup);
974 ad->popup = setting_create_popup_without_btn(ad, ad->win_get,
975 NULL, _("IDS_ST_BODY_SORRY_YOUR_SD_CARD_IS_BUSY"),
976 __setting_storage_status_sd_card_popup_response_cb,
977 SETTING_STORAGE_POPUP_TIMER, FALSE, FALSE);
981 if (list_item == ad->sd_mount) {
982 __setting_storage_main_sd_card_mount_unmount(ad);
984 #if SUPPORT_SD_CARD_FORMAT
985 else if (list_item == ad->sd_format) {
986 __setting_storage_main_sd_card_format_popup_create(ad);
991 static void __setting_storage_main_sd_card_info_append(void* data)
994 setting_retm_if(data == NULL, "Data parameter is NULL");
995 SettingStorageUG *ad = (SettingStorageUG *) data;
997 /* remove the sd info items */
999 elm_object_item_del(ad->sd_mount->item);
1000 ad->sd_mount = NULL;
1003 elm_object_item_del(ad->sd_total->item);
1004 ad->sd_total = NULL;
1006 if (ad->sd_available) {
1007 elm_object_item_del(ad->sd_available->item);
1008 ad->sd_available = NULL;
1010 #if SUPPORT_SD_CARD_FORMAT
1011 if (ad->sd_format) {
1012 elm_object_item_del(ad->sd_format->item);
1013 ad->sd_format = NULL;
1016 int mmc_mode = VCONFKEY_SYSMAN_MMC_REMOVED;
1017 int ret = vconf_get_int(VCONFKEY_SYSMAN_MMC_STATUS, &mmc_mode);
1018 setting_retm_if(ret != 0, "Get vconf failed");
1020 if (mmc_mode == VCONFKEY_SYSMAN_MMC_REMOVED) {
1021 ad->sd_mount = setting_create_Gendial_field_def(ad->genlist, &(ad->itc_2text_2), NULL,
1022 ad, SWALLOW_Type_INVALID, NULL,
1023 NULL, 0, SETTING_STORAGE_MOUNT_STR,
1024 _(SETTING_STORAGE_INSERT_STR),
1027 setting_disable_genlist_item(ad->sd_mount->item);
1029 } else if (mmc_mode == VCONFKEY_SYSMAN_MMC_INSERTED_NOT_MOUNTED) {
1030 ad->sd_mount = setting_create_Gendial_field_def(ad->genlist, &(ad->itc_2text_2),
1031 __setting_storage_main_mouse_up_Gendial_list_cb,
1032 ad, SWALLOW_Type_INVALID, NULL,
1033 NULL, 0, SETTING_STORAGE_MOUNT_STR,
1034 _(SETTING_STORAGE_INSERT_STR),
1036 } else if (mmc_mode == VCONFKEY_SYSMAN_MMC_MOUNTED) {
1037 char sd_total[SETTING_STORAGE_MAX_STR_LEN] = { 0, };
1038 char sd_available[SETTING_STORAGE_MAX_STR_LEN] = { 0, };
1039 __setting_storage_main_sd_card_info_get(sd_total, sd_available);
1041 ad->sd_total = setting_create_Gendial_field_def(ad->genlist, &(ad->itc_2text_2), NULL,
1042 ad, SWALLOW_Type_INVALID, NULL,
1043 NULL, 0, "IDS_ST_BODY_TOTAL_SPACE",
1047 ad->sd_total->userdata = ad;
1048 elm_genlist_item_select_mode_set(ad->sd_total->item, ELM_OBJECT_SELECT_MODE_DISPLAY_ONLY);
1050 SETTING_TRACE_ERROR("ad->sd_total is NULL");
1053 ad->sd_available = setting_create_Gendial_field_def(ad->genlist, &(ad->itc_2text_2), NULL,
1054 ad, SWALLOW_Type_INVALID, NULL,
1055 NULL, 0, "IDS_ST_BODY_AVAILABLE_SPACE",
1058 if (ad->sd_available) {
1059 ad->sd_available->userdata = ad;
1060 elm_genlist_item_select_mode_set(ad->sd_available->item, ELM_OBJECT_SELECT_MODE_DISPLAY_ONLY);
1062 SETTING_TRACE_ERROR("ad->sd_available is NULL");
1065 ad->sd_mount = setting_create_Gendial_field_def(ad->genlist, &(ad->itc_1text),
1066 __setting_storage_main_mouse_up_Gendial_list_cb,
1067 ad, SWALLOW_Type_INVALID, NULL,
1068 NULL, 0, "IDS_ST_BODY_UNMOUNT_SD_CARD", NULL,
1071 ad->sd_mount->userdata = ad;
1073 SETTING_TRACE_ERROR("ad->sd_mount is NULL");
1076 #if SUPPORT_SD_CARD_FORMAT
1077 ad->sd_format = setting_create_Gendial_field_def(ad->genlist, &(ad->itc_1text),
1078 __setting_storage_main_mouse_up_Gendial_list_cb,
1079 ad, SWALLOW_Type_INVALID, NULL,
1081 "IDS_ST_BODY_FORMAT_SD_CARD",
1083 if (ad->sd_format) {
1084 ad->sd_format->userdata = ad;
1086 SETTING_TRACE_ERROR("ad->sd_format is NULL");
1090 SETTING_TRACE_ERROR("error status of sd card");
1093 Elm_Object_Item *item = NULL;
1094 item = elm_genlist_item_append(ad->genlist, &itc_bottom_seperator, NULL, NULL,
1095 ELM_GENLIST_ITEM_NONE, NULL, NULL);
1096 elm_genlist_item_select_mode_set(item, ELM_OBJECT_SELECT_MODE_DISPLAY_ONLY);
1099 static void __setting_storage_vconf_change_cb(keynode_t *key, void *data)
1101 SETTING_TRACE_BEGIN;
1102 setting_retm_if(NULL == key, "key is NULL");
1103 setting_retm_if(NULL == data, "data is NULL");
1104 SettingStorageUG *ad = (SettingStorageUG *)data;
1105 int status = vconf_keynode_get_int(key);
1106 char *vconf_name = vconf_keynode_get_name(key);
1108 if (!safeStrCmp(vconf_name, VCONFKEY_SYSMAN_MMC_STATUS)) {
1109 SETTING_TRACE("status:%d", status);
1110 /* remove last item -> seperator */
1111 Elm_Object_Item *last_item = NULL;
1112 last_item = elm_genlist_last_item_get(ad->genlist);
1114 elm_object_item_del(last_item);
1116 __setting_storage_main_sd_card_info_append(ad);
1120 static void __setting_storage_main_genlist_update(Setting_GenGroupItem_Data *data, Setting_Storage_Status status)
1122 //SETTING_TRACE_BEGIN;
1123 setting_retm_if(data == NULL, "Data parameter is NULL");
1124 Setting_GenGroupItem_Data *item_data = (Setting_GenGroupItem_Data *) data;
1126 char desc[SETTING_STORAGE_MAX_STR_LEN + 1] = {0,};
1127 int ret = __setting_storage_status_size_transition(status.dTotal, desc);
1128 setting_retm_if(ret == SETTING_RETURN_FAIL, "failed to transform")
1130 G_FREE(item_data->sub_desc);
1131 item_data->sub_desc = (char *)g_strdup(desc);
1132 elm_object_item_data_set(item_data->item, item_data);
1133 elm_genlist_item_update(item_data->item);
1136 static ail_cb_ret_e __setting_storage_main_appinfo_func_cb(const ail_appinfo_h ail_info, void *data)
1138 Eina_List **apps_list = (Eina_List **) data;
1140 char *pkg_name = NULL;
1141 char *pkg_type = NULL;
1143 ail_appinfo_get_str(ail_info, AIL_PROP_PACKAGE_STR, &pkg_name);
1144 setting_retvm_if(pkg_name == NULL, AIL_CB_RET_CONTINUE, "get pkg_name failed");
1146 ail_appinfo_get_str(ail_info, AIL_PROP_X_SLP_PACKAGETYPE_STR, &pkg_type);
1147 setting_retvm_if(pkg_type == NULL, AIL_CB_RET_CONTINUE, "get pkg_type failed");
1149 App_Info *app_info = (App_Info*)calloc(1, sizeof(App_Info));
1150 setting_retvm_if(app_info == NULL, AIL_CB_RET_CONTINUE, "failed to calloc");
1152 app_info->pkg_name = (char *)g_strdup(pkg_name);
1153 app_info->pkg_type = (char *)g_strdup(pkg_type);
1154 *apps_list = eina_list_append(*apps_list, app_info);
1155 return AIL_CB_RET_CONTINUE;
1158 static void __setting_storage_main_applications_list_get(Eina_List **apps_list)
1160 SETTING_TRACE_BEGIN;
1161 /* get app_info from AIL */
1162 ail_filter_h filter_rpm = NULL;
1163 ail_filter_h filter_wrt = NULL;
1164 ail_filter_h filter_tpk = NULL;
1166 ail_filter_new(&filter_rpm);
1167 ail_filter_new(&filter_wrt);
1168 ail_filter_new(&filter_tpk);
1170 ail_filter_add_str(filter_rpm, AIL_PROP_X_SLP_PACKAGETYPE_STR, RPM_PREFIX);
1171 ail_filter_add_str(filter_wrt, AIL_PROP_X_SLP_PACKAGETYPE_STR, WRT_PREFIX);
1172 ail_filter_add_str(filter_tpk, AIL_PROP_X_SLP_PACKAGETYPE_STR, TPK_PREFIX);
1174 ail_filter_list_appinfo_foreach(filter_rpm, __setting_storage_main_appinfo_func_cb, (void*)apps_list);
1175 ail_filter_list_appinfo_foreach(filter_wrt, __setting_storage_main_appinfo_func_cb, (void*)apps_list);
1176 ail_filter_list_appinfo_foreach(filter_tpk, __setting_storage_main_appinfo_func_cb, (void*)apps_list);
1178 ail_filter_destroy(filter_rpm);
1179 ail_filter_destroy(filter_wrt);
1180 ail_filter_destroy(filter_tpk);
1183 static double __setting_storage_main_applications_status_get(void *data)
1185 SETTING_TRACE_BEGIN;
1186 setting_retvm_if(data == NULL, 0.0, "Data parameter is NULL");
1187 SettingStorageUG *ad = (SettingStorageUG *)data;
1189 Eina_List *apps_list = NULL;
1190 __setting_storage_main_applications_list_get(&apps_list);
1192 SETTING_TRACE("count = %d", eina_list_count(apps_list));
1194 double total_size = 0.0;
1196 Eina_List *l = NULL;
1197 App_Info *app_info = NULL;
1198 EINA_LIST_FOREACH (apps_list, l, app_info)
1201 pthread_mutex_lock(&ad->exit_mutex);
1202 exit_flag = ad->exit_flag;
1203 pthread_mutex_unlock(&ad->exit_mutex);
1205 if (exit_flag == 1) {
1206 SETTING_TRACE("exit_flag is 1");
1210 //SETTING_TRACE("pkg_name: %s ", app_info->pkg_name);
1211 //SETTING_TRACE("pkg_type: %s", app_info->pkg_type);
1212 pkgmgr_info *pkg_info = pkgmgr_info_new(app_info->pkg_type, app_info->pkg_name);
1214 //SETTING_TRACE("pkg_info is null, couldn't get the sizes");
1215 app_info->total_size = 0;
1218 buf = pkgmgr_info_get_string(pkg_info, STR_INSTALLED_SIZE);
1220 //SETTING_TRACE("size : %s", buf);
1221 app_info->total_size = atoi(buf);
1224 app_info->total_size = 0;
1226 pkgmgr_info_free(pkg_info);
1229 total_size += app_info->total_size;
1233 Eina_List *tmp = NULL;
1235 EINA_LIST_FOREACH(apps_list, tmp, app_info)
1237 G_FREE(app_info->pkg_name);
1238 G_FREE(app_info->pkg_type);
1241 eina_list_free(apps_list);
1247 void __setting_storage_main_pipe_cb(void *data, void *buffer, unsigned int nbyte)
1249 SETTING_TRACE_BEGIN;
1250 setting_retm_if(data == NULL, "Data parameter is NULL");
1251 setting_retm_if(buffer == NULL, "buffer parameter is NULL");
1252 SettingStorageUG *ad = (SettingStorageUG *)data;
1254 Update_Info *update_info = (Update_Info *) buffer;
1256 SETTING_TRACE("update_info : %d", update_info->type);
1258 switch (update_info->type) {
1259 case SETTING_STORAGE_APPLICATIONS:
1261 ad->apps_status.dTotal = update_info->total_size;
1262 __setting_storage_main_genlist_update(ad->apps, ad->apps_status);
1265 case SETTING_STORAGE_PICTURES_VIDEO:
1267 ad->pics_videos_status.dTotal = update_info->total_size;
1268 __setting_storage_main_genlist_update(ad->pics_videos, ad->pics_videos_status);
1271 case SETTING_STORAGE_AUDIO:
1273 ad->audio_status.dTotal = update_info->total_size;
1274 __setting_storage_main_genlist_update(ad->audio, ad->audio_status);
1277 case SETTING_STORAGE_MISCELLANEOUS:
1279 ad->others_status.dTotal = update_info->total_size;
1280 __setting_storage_main_genlist_update(ad->others, ad->others_status);
1285 SETTING_TRACE_ERROR("wrong update type");
1289 __setting_storage_main_genlist_update(ad->internal, ad->internal_status);
1294 static void *__setting_storage_main_thread_start_routine(void *data)
1296 SETTING_TRACE("==== sub thread id = %d =====", (int)pthread_self());
1297 SETTING_TRACE_BEGIN;
1298 setting_retvm_if(data == NULL, NULL, "Data parameter is NULL");
1299 SettingStorageUG *ad = (SettingStorageUG *)data;
1301 //Ecore_Pipe *pipe = ad->pipe;
1302 update_type type = SETTING_STORAGE_PICTURES_VIDEO;
1304 pthread_mutex_lock(&ad->update_mutex);
1305 while (ad->type == SETTING_STORAGE_SLEEP) {
1306 /* wait to be waked up*/
1307 pthread_cond_wait(&ad->wait_cond, &ad->update_mutex);
1310 pthread_mutex_unlock(&ad->update_mutex);
1312 SETTING_TRACE("thread start to work, update type = %d", type);
1316 pthread_mutex_lock(&ad->exit_mutex);
1317 exit_flag = ad->exit_flag;
1318 pthread_mutex_unlock(&ad->exit_mutex);
1320 if (exit_flag == 1) {
1321 SETTING_TRACE("exit_flag is 1");
1325 if (type >= SETTING_STORAGE_MAX) {
1326 SETTING_TRACE("work is done, thread will sleep");
1327 pthread_mutex_lock(&ad->update_mutex);
1328 ad->type = SETTING_STORAGE_SLEEP;
1329 pthread_mutex_unlock(&ad->update_mutex);
1334 case SETTING_STORAGE_PICTURES_VIDEO:
1336 /* get pictures and videos info */
1337 double pics_videos_size = __setting_storage_main_pictures_videos_status_get();
1338 SETTING_TRACE("pics_videos_size = %f", pics_videos_size);
1340 Update_Info pics_videos_info;
1341 memset(&pics_videos_info, 0, sizeof(Update_Info));
1342 pics_videos_info.type = SETTING_STORAGE_PICTURES_VIDEO;
1343 pics_videos_info.total_size = pics_videos_size;
1345 ecore_pipe_write(ad->pipe, &pics_videos_info, sizeof(pics_videos_info));
1348 case SETTING_STORAGE_AUDIO:
1350 /* get audio info */
1351 double audio_size = __setting_storage_main_audio_status_get();
1352 SETTING_TRACE("audio_size = %f", audio_size);
1354 Update_Info audio_info;
1355 memset(&audio_info, 0, sizeof(Update_Info));
1356 audio_info.type = SETTING_STORAGE_AUDIO;
1357 audio_info.total_size = audio_size;
1359 ecore_pipe_write(ad->pipe, &audio_info, sizeof(audio_info));
1362 case SETTING_STORAGE_MISCELLANEOUS:
1364 /* get miscellaneous files info */
1365 double misc_size = __setting_storage_main_miscellaneous_size_get();
1366 SETTING_TRACE("misc_size = %f", misc_size);
1368 Update_Info misc_info;
1369 memset(&misc_info, 0, sizeof(Update_Info));
1370 misc_info.type = SETTING_STORAGE_MISCELLANEOUS;
1371 misc_info.total_size = misc_size;
1373 ecore_pipe_write(ad->pipe, &misc_info, sizeof(misc_info));
1376 case SETTING_STORAGE_APPLICATIONS:
1379 double apps_size = __setting_storage_main_applications_status_get(ad);
1380 SETTING_TRACE("apps_size = %f", apps_size);
1382 Update_Info apps_info;
1383 memset(&apps_info, 0, sizeof(Update_Info));
1384 apps_info.type = SETTING_STORAGE_APPLICATIONS;
1385 apps_info.total_size = apps_size;
1387 ecore_pipe_write(ad->pipe, &apps_info, sizeof(apps_info));
1392 SETTING_TRACE("type = %d", type);
1397 pthread_mutex_lock(&ad->update_mutex);
1399 SETTING_TRACE("ad->type = %d", ad->type);
1400 pthread_mutex_unlock(&ad->update_mutex);
1403 pthread_exit((void *) 0);
1407 static void __setting_storage_main_init(void *data)
1409 SETTING_TRACE_BEGIN;
1410 setting_retm_if(data == NULL, "Data parameter is NULL");
1411 SettingStorageUG *ad = (SettingStorageUG *)data;
1413 pthread_mutex_init(&ad->exit_mutex, NULL);
1414 pthread_mutex_init(&ad->update_mutex, NULL);
1415 pthread_cond_init(&ad->wait_cond, NULL);
1417 ad->exit_flag = EINA_FALSE;
1418 ad->type = SETTING_STORAGE_PICTURES_VIDEO;
1420 ad->internal_status.dAvail = 0.0;
1421 ad->internal_status.dTotal= 0.0;
1423 ad->apps_status.dAvail = 0.0;
1424 ad->apps_status.dTotal= 0.0;
1426 ad->pics_videos_status.dAvail = 0.0;
1427 ad->pics_videos_status.dTotal= 0.0;
1429 ad->audio_status.dAvail = 0.0;
1430 ad->audio_status.dTotal= 0.0;
1432 ad->others_status.dAvail = 0.0;
1433 ad->others_status.dTotal= 0.0;
1436 /* ***************************************************
1440 ***************************************************/
1441 static int setting_storage_main_create(void *cb)
1443 SETTING_TRACE_BEGIN;
1445 retv_if(cb == NULL, SETTING_GENERAL_ERR_NULL_DATA_PARAMETER);
1447 SettingStorageUG *ad = (SettingStorageUG *) cb;
1449 __setting_storage_main_init(ad);
1451 int ret = SETTING_RETURN_SUCCESS;
1453 retvm_if(ad->win_main_layout == NULL, SETTING_DRAW_ERR_FAIL_LOAD_EDJ,
1454 "win_main_layout is NULL");
1457 setting_create_layout_navi_bar_genlist(ad->win_main_layout,
1460 _("IDS_COM_BODY_BACK"),
1462 __setting_storage_main_click_softkey_back_cb,
1464 ad, &ad->genlist, &ad->navibar);
1466 ad->itc_2text_1icon_4.item_style = "dialogue/2text.1icon.4";
1467 ad->itc_2text_1icon_4.func.text_get = __gl_text_get;
1468 ad->itc_2text_1icon_4.func.content_get = __gl_content_get;
1469 ad->itc_2text_1icon_4.func.state_get = NULL;
1470 ad->itc_2text_1icon_4.func.del = __gl_del;
1472 __setting_storage_main_internal_storage_status_get(ad);
1474 Elm_Object_Item *item = NULL;
1476 bool is_emulator = isEmulBin();
1479 item = elm_genlist_item_append(ad->genlist, &itc_seperator, NULL, NULL,
1480 ELM_GENLIST_ITEM_NONE, NULL, NULL);
1481 elm_genlist_item_select_mode_set(item, ELM_OBJECT_SELECT_MODE_DISPLAY_ONLY);
1483 /* Default storage */
1484 setting_create_Gendial_field_def(ad->genlist, &(ad->itc_1text),
1485 __setting_storage_main_Gendial_mouse_up_cb,
1486 ad, SWALLOW_Type_INVALID, NULL, NULL,
1487 0, SETTING_STORAGE_DEFAULT_STORAGE_STR,
1491 setting_create_Gendial_field_titleItem(ad->genlist, &(ad->itc_group_item),
1492 SETTING_STORAGE_INTERNAL_STORAGE_STR,
1496 char total_desc[SETTING_STORAGE_MAX_STR_LEN + 1] = {0,};
1497 ret = __setting_storage_status_size_transition(ad->internal_status.dTotal, total_desc);
1498 setting_retvm_if(ret == SETTING_RETURN_FAIL, SETTING_RETURN_FAIL, "failed to transform")
1501 ad->internal = (Setting_GenGroupItem_Data *) calloc(1, sizeof(Setting_GenGroupItem_Data));
1502 setting_retvm_if(!ad->internal, SETTING_RETURN_FAIL, "calloc failed");
1505 ad->internal->userdata = ad;
1506 ad->internal->keyStr = (char *)g_strdup(total_desc);
1507 ad->internal->item = elm_genlist_item_append(ad->genlist, &(ad->itc_2text_1icon_4), ad->internal, NULL,
1508 ELM_GENLIST_ITEM_NONE, NULL, NULL);
1509 elm_genlist_item_select_mode_set(ad->internal->item, ELM_OBJECT_SELECT_MODE_DISPLAY_ONLY);
1511 SETTING_TRACE_ERROR("ad->internal is NULL");
1512 return SETTING_RETURN_FAIL;
1516 ad->apps = setting_create_Gendial_field_def(ad->genlist, &(ad->itc_2text_1icon_3),
1517 __setting_storage_main_Gendial_mouse_up_cb,
1518 ad, SWALLOW_Type_INVALID, SETTING_STORAGE_APPS_ICON_PATH,
1519 NULL, 0, "IDS_ST_BODY_APPLICATIONS",
1520 _("IDS_ST_HEADER_PLEASE_WAIT"), NULL);
1522 ad->apps->userdata = ad;
1524 elm_genlist_item_select_mode_set(ad->apps->item, ELM_OBJECT_SELECT_MODE_DISPLAY_ONLY);
1527 SETTING_TRACE_ERROR("ad->apps is NULL");
1528 return SETTING_RETURN_FAIL;
1531 /* Pictures, Videos */
1532 ad->pics_videos = setting_create_Gendial_field_def(ad->genlist, &(ad->itc_2text_1icon_3),
1533 __setting_storage_main_Gendial_mouse_up_cb,
1534 ad, SWALLOW_Type_INVALID, SETTING_STORAGE_PICS_ICON_PATH,
1535 NULL, 0, SETTING_STORAGE_PICS_STR,
1536 _("IDS_ST_HEADER_PLEASE_WAIT"), NULL);
1537 if (ad->pics_videos) {
1538 ad->pics_videos->userdata = ad;
1540 elm_genlist_item_select_mode_set(ad->pics_videos->item, ELM_OBJECT_SELECT_MODE_DISPLAY_ONLY);
1543 SETTING_TRACE_ERROR("ad->pics_videos is NULL");
1544 return SETTING_RETURN_FAIL;
1548 ad->audio = setting_create_Gendial_field_def(ad->genlist, &(ad->itc_2text_1icon_3),
1549 __setting_storage_main_Gendial_mouse_up_cb,
1550 ad, SWALLOW_Type_INVALID, SETTING_STORAGE_AUDIO_ICON_PATH,
1551 NULL, 0, SETTING_STORAGE_AUDIO_STR,
1552 _("IDS_ST_HEADER_PLEASE_WAIT"), NULL);
1554 ad->audio->userdata = ad;
1557 elm_genlist_item_select_mode_set(ad->audio->item, ELM_OBJECT_SELECT_MODE_DISPLAY_ONLY);
1560 SETTING_TRACE_ERROR("ad->audio is NULL");
1561 return SETTING_RETURN_FAIL;
1564 /* Miscellaneous files */
1565 ad->others = setting_create_Gendial_field_def(ad->genlist, &(ad->itc_2text_1icon_3),
1566 __setting_storage_main_Gendial_mouse_up_cb,
1567 ad, SWALLOW_Type_INVALID, SETTING_STORAGE_MISCES_ICON_PATH,
1568 NULL, 0, SETTING_STORAGE_MISCES_STR,
1569 _("IDS_ST_HEADER_PLEASE_WAIT"), NULL);
1571 ad->others->userdata = ad;
1573 SETTING_TRACE_ERROR("ad->others is NULL");
1574 return SETTING_RETURN_FAIL;
1578 char avail_desc[SETTING_STORAGE_MAX_STR_LEN + 1] = {0,};
1579 ret = __setting_storage_status_size_transition(ad->internal_status.dAvail, avail_desc);
1580 setting_retvm_if(ret == SETTING_RETURN_FAIL, SETTING_RETURN_FAIL, "failed to transform")
1582 ad->avail = setting_create_Gendial_field_def(ad->genlist, &(ad->itc_2text_1icon_3), NULL,
1583 ad, SWALLOW_Type_INVALID, SETTING_STORAGE_AVAIL_ICON_PATH,
1584 NULL, 0, SETTING_STORAGE_AVAIL_STR,
1587 ad->avail->userdata = ad;
1588 elm_genlist_item_select_mode_set(ad->avail->item, ELM_OBJECT_SELECT_MODE_DISPLAY_ONLY);
1590 SETTING_TRACE_ERROR("ad->avail is NULL");
1591 return SETTING_RETURN_FAIL;
1596 /* Format USB storage */
1597 setting_create_Gendial_field_def(ad->genlist, &(ad->itc_1text), NULL,
1598 ad, SWALLOW_Type_INVALID, NULL,
1600 SETTING_STORAGE_FORMAT_STR,
1603 setting_create_Gendial_field_def(ad->genlist, &(ad->itc_bg_1icon), NULL,
1604 ad, SWALLOW_Type_LAYOUT_SPECIALIZTION_X,
1605 NULL, NULL, 0, SETTING_STORAGE_FORMAT_DESC_STR, NULL,
1610 setting_create_Gendial_field_titleItem(ad->genlist, &(ad->itc_group_item),
1611 "IDS_ST_BODY_SD_CARD", NULL);
1612 __setting_storage_main_sd_card_info_append(ad);
1614 ret = vconf_notify_key_changed(VCONFKEY_SYSMAN_MMC_STATUS,
1615 __setting_storage_vconf_change_cb, ad);
1617 SETTING_TRACE_ERROR("call vconf_notify_key_changed failed");
1620 item = elm_genlist_item_append(ad->genlist, &itc_bottom_seperator, NULL, NULL,
1621 ELM_GENLIST_ITEM_NONE, NULL, NULL);
1622 elm_genlist_item_select_mode_set(item, ELM_OBJECT_SELECT_MODE_DISPLAY_ONLY);
1625 setting_view_storage_main.is_create = 1;
1628 ecore_pipe_del(ad->pipe);
1631 ad->pipe = ecore_pipe_add(__setting_storage_main_pipe_cb, ad);
1634 ret = pthread_create(&ad->tid, NULL, __setting_storage_main_thread_start_routine, ad);
1636 SETTING_TRACE_ERROR("fail to pthread_create");
1638 SETTING_TRACE("thread id = %d", ad->tid);
1642 SETTING_TRACE_ERROR("fail to ecore_pipe_add");
1645 return SETTING_RETURN_SUCCESS;
1648 static int setting_storage_main_destroy(void *cb)
1651 retv_if(cb == NULL, SETTING_GENERAL_ERR_NULL_DATA_PARAMETER);
1653 SettingStorageUG *ad = (SettingStorageUG *) cb;
1657 pthread_mutex_lock(&ad->exit_mutex);
1659 pthread_mutex_unlock(&ad->exit_mutex);
1661 /* wake up thread */
1662 pthread_mutex_lock(&ad->update_mutex);
1663 ad->type = SETTING_STORAGE_REUPDATE;
1664 pthread_cond_signal(&ad->wait_cond);
1665 pthread_mutex_unlock(&ad->update_mutex);
1669 void *thread_ret = NULL;
1670 ret = pthread_join(ad->tid, &thread_ret);
1672 SETTING_TRACE_ERROR("fail to join with thread");
1674 SETTING_TRACE("thread exit code %d", (int)thread_ret);
1677 pthread_mutex_destroy(&ad->exit_mutex);
1678 pthread_mutex_destroy(&ad->update_mutex);
1679 pthread_cond_destroy(&ad->wait_cond);
1682 ecore_pipe_del(ad->pipe);
1687 ret = vconf_ignore_key_changed(VCONFKEY_SYSMAN_MMC_STATUS,
1688 __setting_storage_vconf_change_cb);
1690 SETTING_TRACE_ERROR("call vconf_ignore_key_changed failed");
1695 evas_object_del(ad->popup);
1699 if (ad->ly_main != NULL) {
1700 evas_object_del(ad->ly_main);
1701 setting_view_storage_main.is_create = 0;
1704 return SETTING_RETURN_SUCCESS;
1707 static int setting_storage_main_update(void *cb)
1709 SETTING_TRACE_BEGIN;
1711 retv_if(cb == NULL, SETTING_GENERAL_ERR_NULL_DATA_PARAMETER);
1712 SettingStorageUG *ad = (SettingStorageUG *) cb;
1716 __setting_storage_main_internal_storage_status_get(ad);
1718 /* update internal total size */
1719 char total_desc[SETTING_STORAGE_MAX_STR_LEN + 1] = {0,};
1720 ret = __setting_storage_status_size_transition(ad->internal_status.dTotal, total_desc);
1721 setting_retvm_if(ret == SETTING_RETURN_FAIL, SETTING_RETURN_FAIL, "failed to transform")
1723 G_FREE(ad->internal->keyStr);
1724 ad->internal->keyStr = (char *)g_strdup(total_desc);
1725 elm_object_item_data_set(ad->internal->item, ad->internal);
1726 elm_genlist_item_update(ad->internal->item);
1728 /* update internal available size */
1729 char avail_desc[SETTING_STORAGE_MAX_STR_LEN + 1] = {0,};
1730 ret = __setting_storage_status_size_transition(ad->internal_status.dAvail, avail_desc);
1731 setting_retvm_if(ret == SETTING_RETURN_FAIL, SETTING_RETURN_FAIL, "failed to transform")
1733 G_FREE(ad->avail->sub_desc);
1734 ad->avail->sub_desc = (char *)g_strdup(avail_desc);
1735 elm_object_item_data_set(ad->avail->item, ad->avail);
1736 elm_genlist_item_update(ad->avail->item);
1738 /* update miscellaneous */
1739 if (ad->back_from_misc) {
1740 double misc_size = __setting_storage_main_miscellaneous_size_get();
1742 ad->others_status.dTotal = misc_size;
1743 __setting_storage_main_genlist_update(ad->others, ad->others_status);
1746 /* wake up thread */
1747 pthread_mutex_lock(&ad->update_mutex);
1748 ad->type = SETTING_STORAGE_REUPDATE;
1749 pthread_cond_signal(&ad->wait_cond);
1750 pthread_mutex_unlock(&ad->update_mutex);
1752 if (ad->ly_main != NULL) {
1753 evas_object_show(ad->ly_main);
1756 return SETTING_RETURN_SUCCESS;
1759 static int setting_storage_main_cleanup(void *cb)
1762 retv_if(cb == NULL, SETTING_GENERAL_ERR_NULL_DATA_PARAMETER);
1764 SettingStorageUG *ad = (SettingStorageUG *) cb;
1766 if (ad->ly_main != NULL) {
1767 evas_object_hide(ad->ly_main);
1770 return SETTING_RETURN_SUCCESS;
1773 /* ***************************************************
1777 ***************************************************/
1779 static void __setting_storage_main_click_softkey_back_cb(void *data, Evas_Object *obj,
1783 ret_if(data == NULL);
1785 SettingStorageUG *ad = (SettingStorageUG *) data;
1786 /* Send destroy request */
1787 ug_destroy_me(ad->ug);