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-memory-status.h>
22 #define MAX_STR_LEN_ON_MEMORY_STATUS 32
24 #define MAIN_STORAGE 0
26 static int setting_memory_status_create(void *cb);
27 static int setting_memory_status_destroy(void *cb);
28 static int setting_memory_status_update(void *cb);
29 static int setting_memory_status_cleanup(void *cb);
31 setting_view setting_view_memory_status = {
32 .create = setting_memory_status_create,
33 .destroy = setting_memory_status_destroy,
34 .update = setting_memory_status_update,
35 .cleanup = setting_memory_status_cleanup,
38 static void __setting_memory_status_vconf_change_cb( keynode_t *key, void *data);
39 static int __setting_memory_status_check_mmc_status();
40 static int __setting_memory_status_mmc_content_init(void *data, setting_memory_mmc_cb cb);
42 static void __setting_memory_status_system_storage_available_size_get(char *szAvail)
48 int ret = SETTING_RETURN_SUCCESS;
49 setting_mem_status internal_mem_stat;
51 ret = __fs_stat(&dTotal, &dAvail, SETTING_MEMORY_STATUS_APP_PATH);
52 setting_retm_if(ret == SETTING_RETURN_FAIL, "get app_mem stat failed");
53 internal_mem_stat.dTotal = dTotal;
54 internal_mem_stat.dAvail = dAvail;
56 ret = setting_memory_status_size_transition(internal_mem_stat.dAvail, szAvail);
57 setting_retm_if(ret == SETTING_RETURN_FAIL, "setting_memory_status_size_transition fail");
60 static int setting_memory_status_create(void *cb)
64 SettingMemoryUG *ad = (SettingMemoryUG *) cb;
65 Evas_Object *scroller;
67 /* Evas_Object *user_mem_fr, *phone_mem_fr, *fr_bx1, *fr_bx2; */
68 /* Evas_Object *sp; */
69 /* float tmp_free_size, tmp_total_size; */
70 /* char free_str[MAX_STR_LEN_ON_MEMORY_STATUS] = {0, }; */
71 /* char total_str[MAX_STR_LEN_ON_MEMORY_STATUS] = {0, }; */
72 /* char size_str[MAX_STR_LEN_ON_MEMORY_STATUS*2] = {0, }; */
73 setting_push_layout_navi_bar_genlist(ad->win_main_layout, ad->win_get,
74 _("IDS_ST_BODY_MEMORY_STATUS"),
75 S_("IDS_COM_BODY_BACK"), NULL,
76 setting_memory_status_click_softkey_back,
77 NULL, ad, &scroller, ad->navi_bar);
79 /* External SD card */
80 setting_create_Gendial_field_titleItem(scroller, &(ad->itc_group_item),
81 SETTING_MEMORY_STATUS_EX_SD_CARD_DESC,
84 char ex_total_space[SETTING_MEMORY_MMC_MAX_MEM_STR_LEN] = { 0, };
85 char ex_available_space[SETTING_MEMORY_MMC_MAX_MEM_STR_LEN] = { 0, };
86 char ex_mount_status[SETTING_MEMORY_MMC_MAX_MEM_STR_LEN] = { 0, };
87 int ex_mmc_status = VCONFKEY_SYSMAN_MMC_REMOVED;
88 setting_memory_status_ex_sd_card_info(ex_total_space,
90 ex_mount_status, &ex_mmc_status);
93 setting_create_Gendial_field_def(scroller, &(ad->itc_2text_2), NULL,
94 ad, SWALLOW_Type_INVALID, NULL,
95 NULL, 0, ex_total_space,
96 SETTING_MEMORY_STATUS_TOTAL_SPACE_DESC,
98 if (ad->data_ex_total) {
99 ad->data_ex_total->userdata = ad;
100 elm_genlist_item_select_mode_set(ad->data_ex_total->item,
101 ELM_OBJECT_SELECT_MODE_DISPLAY_ONLY);
103 SETTING_TRACE_ERROR("ad->data_ex_total is NULL");
106 ad->data_ex_available =
107 setting_create_Gendial_field_def(scroller, &(ad->itc_2text_2), NULL,
108 ad, SWALLOW_Type_INVALID, NULL,
109 NULL, 0, ex_available_space,
110 SETTING_MEMORY_STATUS_AVAILABLE_SPACE_DESC,
112 if (ad->data_ex_available) {
113 ad->data_ex_available->userdata = ad;
114 elm_genlist_item_select_mode_set(ad->data_ex_available->item,
115 ELM_OBJECT_SELECT_MODE_DISPLAY_ONLY);
117 SETTING_TRACE_ERROR("ad->data_ex_available is NULL");
123 setting_create_Gendial_field_def(scroller, &(ad->itc_1text),
124 setting_memory_status_mouse_up_Gendial_list_cb,
125 ad, SWALLOW_Type_INVALID, NULL,
126 NULL, 0, ex_mount_status, NULL,
128 if (ad->data_ex_mount) {
129 ad->data_ex_mount->userdata = ad;
131 SETTING_TRACE_ERROR("ad->data_ex_mount is NULL");
135 setting_create_Gendial_field_def(scroller, &(ad->itc_1text),
136 setting_memory_status_mouse_up_Gendial_list_cb,
137 ad, SWALLOW_Type_INVALID, NULL,
139 SETTING_MEMORY_STATUS_FORMAT_SD_CARD_DESC,
141 if (ad->data_ex_format) {
142 ad->data_ex_format->userdata = ad;
144 SETTING_TRACE_ERROR("ad->data_ex_format is NULL");
147 setting_memory_status_list_item_enable_set_by_mmc_status(ad, ex_mmc_status);
151 setting_create_Gendial_field_titleItem(scroller, &(ad->itc_group_item),
152 SETTING_MEMORY_STATUS_SYSTEM_SPACE_DESC,
154 char system_storage_available[SETTING_MEMORY_MMC_MAX_MEM_STR_LEN] = {0,};
155 __setting_memory_status_system_storage_available_size_get(system_storage_available);
156 ad->data_system_storage_available =
157 setting_create_Gendial_field_def(scroller, &(ad->itc_2text_2), NULL,
158 ad, SWALLOW_Type_INVALID, NULL,
159 NULL, 0, system_storage_available,
160 SETTING_MEMORY_STATUS_AVAILABLE_SPACE_DESC,
162 if (ad->data_system_storage_available) {
163 ad->data_system_storage_available->userdata = ad;
164 elm_genlist_item_select_mode_set(ad->data_system_storage_available->
165 item, ELM_OBJECT_SELECT_MODE_DISPLAY_ONLY);
167 SETTING_TRACE_ERROR("ad->data_system_storage_available is NULL");
171 /* Internal phone storage */
172 setting_create_Gendial_field_titleItem(scroller, &(ad->itc_group_item),
173 SETTING_MEMORY_STATUS_MAIN_STORAGE_DESC,
176 char phone_storage_available[SETTING_MEMORY_MMC_MAX_MEM_STR_LEN] = {0,};
177 setting_memory_status_get_phone_storage_available_size(ad,
178 phone_storage_available);
179 ad->data_phone_storage_available =
180 setting_create_Gendial_field_def(scroller, &(ad->itc_2text_2), NULL,
181 ad, SWALLOW_Type_INVALID, NULL,
182 NULL, 0, phone_storage_available,
183 SETTING_MEMORY_STATUS_AVAILABLE_SPACE_DESC,
185 if (ad->data_phone_storage_available) {
186 ad->data_phone_storage_available->userdata = ad;
187 elm_genlist_item_select_mode_set(ad->data_phone_storage_available->
188 item, ELM_OBJECT_SELECT_MODE_DISPLAY_ONLY);
190 SETTING_TRACE_ERROR("ad->data_phone_storage_available is NULL");
194 Elm_Object_Item *item = NULL;
195 item = elm_genlist_item_append(scroller, &itc_bottom_seperator, NULL, NULL,
196 ELM_GENLIST_ITEM_NONE, NULL, NULL);
197 elm_genlist_item_select_mode_set(item, ELM_OBJECT_SELECT_MODE_DISPLAY_ONLY);
199 int ret = vconf_notify_key_changed(VCONFKEY_USB_STORAGE_STATUS,
200 __setting_memory_status_vconf_change_cb, ad);
202 SETTING_TRACE_ERROR("call vconf_notify_key_changed failed");
205 ret = vconf_notify_key_changed(VCONFKEY_SYSMAN_MMC_STATUS,
206 __setting_memory_status_vconf_change_cb, ad);
208 SETTING_TRACE_ERROR("call vconf_notify_key_changed failed");
211 setting_view_memory_status.is_create = 1;
212 return SETTING_RETURN_SUCCESS;
215 static int setting_memory_status_destroy(void *cb)
218 SettingMemoryUG *ad = (SettingMemoryUG *) cb;
220 if (ad->progress_bar) {
221 evas_object_del(ad->progress_bar);
222 ad->progress_bar = NULL;
226 evas_object_del(ad->popup);
230 int ret = vconf_ignore_key_changed(VCONFKEY_SYSMAN_MMC_STATUS,
231 __setting_memory_status_vconf_change_cb);
233 SETTING_TRACE_ERROR("call vconf_ignore_key_changed failed");
236 ret = vconf_ignore_key_changed(VCONFKEY_USB_STORAGE_STATUS,
237 __setting_memory_status_vconf_change_cb);
239 SETTING_TRACE_ERROR("call vconf_ignore_key_changed failed");
242 if (ad->mmc_content) {
243 FREE(ad->mmc_content);
246 elm_naviframe_item_pop(ad->navi_bar);
247 setting_view_memory_status.is_create = 0;
252 static int setting_memory_status_update(void *cb)
256 SettingMemoryUG *ad = (SettingMemoryUG *) cb;
258 SETTING_TRACE_ERROR("ad is null.");
260 // update sd card statistic
262 setting_memory_status_ex_sd_card_refresh_card_details_cb(ad, NULL, NULL);
264 // update internal phone storage statistic
265 char phone_storage_available[SETTING_MEMORY_MMC_MAX_MEM_STR_LEN] = {0,};
266 setting_memory_status_get_phone_storage_available_size(ad, phone_storage_available);
269 if (ad->data_phone_storage_available)
270 setting_memory_status_list_item_data_set(ad->data_phone_storage_available, phone_storage_available);
276 static int setting_memory_status_cleanup(void *cb)
278 return setting_memory_status_destroy(cb);
281 /*******************************************
285 *******************************************/
287 static int __fs_stat(double* pdTotal, double* pdAvail, const char* szPath)
290 setting_retvm_if(NULL == pdTotal || NULL == pdAvail,
291 SETTING_RETURN_FAIL, "Null output parameters");
295 if (!statvfs(szPath, &s)) {
296 SETTING_TRACE("f_bsize = %ld f_blocks = %ld f_bavail = %ld f_frsize = %ld",
297 s.f_bsize, s.f_blocks, s.f_bavail, s.f_frsize);
298 *pdTotal = (double)s.f_frsize * s.f_blocks;
299 *pdAvail = (double)s.f_bsize * s.f_bavail;
301 return SETTING_RETURN_FAIL;
304 return SETTING_RETURN_SUCCESS;
307 /*******************************************
311 *******************************************/
313 static void setting_memory_status_click_softkey_back(void *data,
317 SettingMemoryUG *ad = (SettingMemoryUG *) data;
318 setting_view_change(&setting_view_memory_status,
319 &setting_view_memory_main, ad);
323 setting_memory_status_ex_sd_card_info(char* szTotal, char* szAvail,
324 char* ex_mount_desc, int *ex_mmc_status)
326 int mmc_mode = VCONFKEY_SYSMAN_MMC_REMOVED;
327 int ret = vconf_get_int(VCONFKEY_SYSMAN_MMC_STATUS, &mmc_mode);
328 setting_retm_if(ret != 0, "Get VCONFKEY_SYSMAN_MMC_STATUS failed");
329 *ex_mmc_status = mmc_mode;
330 SETTING_TRACE("mmc_mode = %d", mmc_mode);
332 int mmc_status = __setting_memory_status_check_mmc_status();
333 setting_retm_if(mmc_status == -1, "check mmc status failed");
335 /* Does not mounted, same st_dev */
336 if (mmc_status == 0) {
337 snprintf(szTotal, SETTING_MEMORY_MMC_MAX_MEM_STR_LEN,
338 "%s", _("IDS_ST_HEADER_UNAVAILABLE"));
339 snprintf(szAvail, SETTING_MEMORY_MMC_MAX_MEM_STR_LEN,
340 "%s", _("IDS_ST_HEADER_UNAVAILABLE"));
341 snprintf(ex_mount_desc, SETTING_MEMORY_MMC_MAX_MEM_STR_LEN,
342 "%s", SETTING_MEMORY_STATUS_MOUNT_SD_CARD_DESC);
344 /* MMC mounted, diff st_dev */
346 snprintf(ex_mount_desc, SETTING_MEMORY_MMC_MAX_MEM_STR_LEN,
347 "%s", SETTING_MEMORY_STATUS_UNMOUNT_SD_CARD_DESC);
349 setting_memory_status_ex_sd_card_detail(szTotal, szAvail);
350 setting_retm_if(ret == SETTING_RETURN_FAIL,
351 "get sd card detail failed");
356 setting_memory_status_ex_sd_card_detail(char* szTotal, char* szAvail)
362 int ret = SETTING_RETURN_SUCCESS;
363 ret = __fs_stat(&dTotal, &dAvail, SETTING_MEMORY_STATUS_MMC_PATH);
364 setting_retvm_if(ret == SETTING_RETURN_FAIL, SETTING_RETURN_FAIL,
365 "get sd card size detail failed");
367 ret = setting_memory_status_size_transition(dTotal, szTotal);
368 setting_retvm_if(ret == SETTING_RETURN_FAIL, SETTING_RETURN_FAIL,
369 "setting_memory_status_size_transition failed");
371 ret = setting_memory_status_size_transition(dAvail, szAvail);
372 setting_retvm_if(ret == SETTING_RETURN_FAIL, SETTING_RETURN_FAIL,
373 "setting_memory_status_size_transition failed");
375 SETTING_TRACE("Total[%s], Avail[%s]", szTotal, szAvail);
376 return SETTING_RETURN_SUCCESS;
380 setting_memory_status_mouse_up_Gendial_list_cb(void *data, Evas_Object *obj,
384 setting_retm_if(data == NULL, "Data parameter is NULL");
385 setting_retm_if(event_info == NULL,
386 "Invalid argument: event info is NULL");
388 SettingMemoryUG *ad = (SettingMemoryUG *) data;
389 Elm_Object_Item *item = (Elm_Object_Item *) event_info;
390 elm_genlist_item_selected_set(item, 0);
391 Setting_GenGroupItem_Data *list_item =
392 (Setting_GenGroupItem_Data *) elm_object_item_data_get(item);
394 SETTING_TRACE("clicking item[%s]", _(list_item->keyStr));
395 if (list_item == ad->data_ex_mount) {
396 setting_memory_status_ex_sd_card_mount_unmount(ad);
397 } else if (list_item == ad->data_ex_format) {
398 setting_memory_status_ex_sd_card_format_promt_popup_create(ad);
403 setting_memory_status_ex_sd_card_format_promt_popup_create(void *data)
406 setting_retm_if(data == NULL, "Data parameter is NULL");
407 SettingMemoryUG *ad = (SettingMemoryUG *) data;
409 ad->curr_popup_cb = setting_memory_status_ex_sd_card_ask_format_resp_cb;
412 evas_object_del(ad->popup);
416 ad->popup = setting_create_popup_with_btn(ad, ad->win_get, NULL,
417 _(SETTING_MEMORY_STATUS_FORMAT_ASK_MSG),
418 ad->curr_popup_cb, 0,
419 2, _("IDS_COM_SK_YES"),_("IDS_COM_SK_NO"));
423 setting_memory_status_ex_sd_card_ask_format_resp_cb(void *data,
428 setting_retm_if(data == NULL, "Data parameter is NULL");
429 int response_type = btn_type(obj);
430 if (POPUP_RESPONSE_OK == response_type) {
431 setting_memory_status_ex_sd_card_format_promt_popup_left_btn_cb
433 } else if (POPUP_RESPONSE_CANCEL == response_type) {
434 setting_memory_status_ex_sd_card_format_promt_popup_right_btn_cb
440 setting_memory_status_ex_sd_card_format_promt_popup_left_btn_cb(void *data,
447 setting_retm_if(data == NULL, "Data parameter is NULL");
448 SettingMemoryUG *ad = (SettingMemoryUG *) data;
451 evas_object_del(ad->popup);
455 /* Show Formatting..... popup */
456 ad->popup = setting_create_popup_with_progressbar(ad, ad->win_get,
458 _("IDS_ST_POP_MSG_FORMATTING"),
460 SETTING_MEMORY_STATUS_PROGRESSBAR_TIMEOUT, TRUE, TRUE);
462 int ret = __setting_memory_status_mmc_content_init(ad, setting_memory_status_ex_sd_card_format_cb);
463 if (ret == SETTING_RETURN_FAIL) {
464 SETTING_TRACE_ERROR("__setting_memory_status_mmc_content_init fail");
466 evas_object_del(ad->popup);
469 ad->popup = setting_create_popup_without_btn(ad, ad->win_get,
470 NULL, _("IDS_COM_POP_FAILED"),
472 SETTING_MEMORY_POPUP_TIMER, FALSE, FALSE);
476 ret = sysman_request_format_mmc(ad->mmc_content);
477 /* if fail, destory popup */
479 SETTING_TRACE_ERROR("call sysman_request_format_mmc fail");
481 evas_object_del(ad->popup);
484 ad->popup = setting_create_popup_without_btn(ad, ad->win_get,
485 NULL, _("IDS_COM_POP_FAILED"),
487 SETTING_MEMORY_POPUP_TIMER, FALSE, FALSE);
492 setting_memory_status_ex_sd_card_format_promt_popup_right_btn_cb(void *data,
499 setting_retm_if(data == NULL, "Data parameter is NULL");
500 SettingMemoryUG *ad = (SettingMemoryUG *) data;
503 evas_object_del(ad->popup);
508 static void setting_memory_status_ex_sd_card_mount_unmount(void *data)
511 setting_retm_if(data == NULL, "Data parameter is NULL");
512 SettingMemoryUG *ad = (SettingMemoryUG *)data;
514 int mmc_status = __setting_memory_status_check_mmc_status();
515 setting_retm_if(mmc_status == -1, "check mmc status failed");
518 evas_object_del(ad->popup);
522 /* Show progressbar popup */
523 ad->popup = setting_create_popup_with_progressbar(ad, ad->win_get,
526 SETTING_MEMORY_STATUS_PROGRESSBAR_TIMEOUT, TRUE, TRUE);
529 /* Does not mounted, same st_dev */
530 if (mmc_status == 0) {
531 ret = __setting_memory_status_mmc_content_init(ad, setting_memory_status_ex_sd_card_mount_cb);
532 if (ret == SETTING_RETURN_FAIL) {
533 SETTING_TRACE_ERROR("__setting_memory_status_mmc_content_init fail");
535 evas_object_del(ad->popup);
538 ad->popup = setting_create_popup_without_btn(ad, ad->win_get,
539 NULL, _("IDS_COM_POP_FAILED"),
541 SETTING_MEMORY_POPUP_TIMER, FALSE, FALSE);
544 ret = sysman_request_mount_mmc(ad->mmc_content);
546 SETTING_TRACE_ERROR("call sysman_request_mount_mmc fail");
549 /* MMC mounted, diff st_dev */
551 ret = __setting_memory_status_mmc_content_init(ad, setting_memory_status_ex_sd_card_unmount_cb);
552 if (ret == SETTING_RETURN_FAIL) {
553 SETTING_TRACE_ERROR("__setting_memory_status_mmc_content_init fail");
555 evas_object_del(ad->popup);
558 ad->popup = setting_create_popup_without_btn(ad, ad->win_get,
559 NULL, _("IDS_COM_POP_FAILED"),
561 SETTING_MEMORY_POPUP_TIMER, FALSE, FALSE);
565 ret = sysman_request_unmount_mmc(ad->mmc_content,
566 MNT_FORCE); /* 1 = MNT_FORCE */
568 SETTING_TRACE_ERROR("call sysman_request_unmount_mmc fail");
572 /* if fail, popup failed info */
575 evas_object_del(ad->popup);
578 ad->popup = setting_create_popup_without_btn(ad, ad->win_get,
579 NULL, _("IDS_COM_POP_FAILED"),
581 SETTING_MEMORY_POPUP_TIMER, FALSE, FALSE);
586 setting_memory_status_ex_sd_card_refresh_card_details_cb(void *data,
591 setting_retm_if(data == NULL, "Data parameter is NULL");
592 SettingMemoryUG *ad = (SettingMemoryUG *)data;
595 evas_object_del(ad->popup);
599 char ex_total_space[SETTING_MEMORY_MMC_MAX_MEM_STR_LEN] = {0, };
600 char ex_available_space[SETTING_MEMORY_MMC_MAX_MEM_STR_LEN] = {0, };
601 char ex_mount_status[SETTING_MEMORY_MMC_MAX_MEM_STR_LEN] = {0, };
602 int ex_mmc_status = VCONFKEY_SYSMAN_MMC_REMOVED;
603 setting_memory_status_ex_sd_card_info(ex_total_space, ex_available_space,
604 ex_mount_status, &ex_mmc_status);
606 setting_memory_status_list_item_data_set(ad->data_ex_total, ex_total_space);
607 setting_memory_status_list_item_data_set(ad->data_ex_available, ex_available_space);
610 setting_memory_status_list_item_data_set(ad->data_ex_mount, ex_mount_status);
612 setting_memory_status_list_item_enable_set_by_mmc_status(ad, ex_mmc_status);
616 setting_memory_status_ex_sd_card_operate_complete(void *data, char *desc,
620 setting_retm_if(data == NULL, "Data parameter is NULL");
621 SettingMemoryUG *ad = (SettingMemoryUG *) data;
622 setting_memory_hide_popup_with_progress_bar(ad);
625 evas_object_del(ad->popup);
628 ad->popup = setting_create_popup_without_btn(ad, ad->win_get, NULL, desc,
629 setting_memory_status_ex_sd_card_refresh_card_details_cb,
630 SETTING_MEMORY_POPUP_TIMER, FALSE, FALSE);
635 setting_memory_status_list_item_enable_set_by_mmc_status(void *data,
639 setting_retm_if(data == NULL, "Data parameter is NULL");
640 SettingMemoryUG *ad = (SettingMemoryUG *) data;
642 if (ex_mmc_status == VCONFKEY_SYSMAN_MMC_REMOVED) {
643 setting_disable_genlist_item(ad->data_ex_total->item);
644 setting_disable_genlist_item(ad->data_ex_available->item);
647 setting_disable_genlist_item(ad->data_ex_mount->item);
648 setting_disable_genlist_item(ad->data_ex_format->item);
650 } else if (ex_mmc_status == VCONFKEY_SYSMAN_MMC_INSERTED_NOT_MOUNTED) {
651 setting_disable_genlist_item(ad->data_ex_total->item);
652 setting_disable_genlist_item(ad->data_ex_available->item);
655 setting_enable_genlist_item(ad->data_ex_mount->item);
656 setting_disable_genlist_item(ad->data_ex_format->item);
658 } else if (ex_mmc_status == VCONFKEY_SYSMAN_MMC_MOUNTED){
660 SETTING_TRACE_DEBUG("abnormal status of MMC");
663 int storage_status = VCONFKEY_USB_STORAGE_STATUS_OFF;
664 int ret = vconf_get_int(VCONFKEY_USB_STORAGE_STATUS, &storage_status);
665 setting_retm_if(ret != 0, "Get VCONFKEY_USB_STORAGE_STATUS failed");
667 if (storage_status == VCONFKEY_USB_STORAGE_STATUS_UMS_MMC_ON) {
670 setting_disable_genlist_item(ad->data_ex_mount->item);
671 setting_disable_genlist_item(ad->data_ex_format->item);
676 static void setting_memory_status_list_item_data_set(Setting_GenGroupItem_Data *
677 item_data, char *data)
680 setting_retm_if(item_data == NULL, "Data parameter is NULL");
682 G_FREE(item_data->keyStr);
683 item_data->keyStr = (char *)g_strdup(data);
684 elm_object_item_data_set(item_data->item, item_data);
685 elm_genlist_item_update(item_data->item);
689 setting_memory_status_get_phone_storage_available_size(void *data,
693 setting_retm_if(data == NULL, "Data parameter is NULL");
694 //SettingMemoryUG *ad = (SettingMemoryUG *) data;
698 int ret = SETTING_RETURN_SUCCESS;
699 setting_mem_status internal_mem_stat;
701 ret = __fs_stat(&dTotal, &dAvail, SETTING_MEMORY_STATUS_APP_PATH);
702 setting_retm_if(ret == SETTING_RETURN_FAIL, "get app_mem stat failed");
703 internal_mem_stat.dTotal = dTotal;
704 internal_mem_stat.dAvail = dAvail;
708 ret = __fs_stat(&dTotal, &dAvail, SETTING_MEMORY_STATUS_MEDIA_PATH);
709 setting_retm_if(ret == SETTING_RETURN_FAIL, "get media_mem stat failed");
710 internal_mem_stat.dTotal += dTotal;
711 internal_mem_stat.dAvail += dAvail;
713 ret = setting_memory_status_size_transition(internal_mem_stat.dAvail,
715 setting_retm_if(ret == SETTING_RETURN_FAIL, "setting_memory_status_size_transition fail");
719 setting_memory_status_size_transition(double size, char *size_desc)
723 double tmp_size = 0.0;
725 if (size < SETTING_MEMORY_MEGABYTE_VALUE) { // size < 1MB: show x.xKB
726 tmp_size = size / SETTING_MEMORY_KILOBYTE_VALUE;
727 ret = snprintf(size_desc, SETTING_MEMORY_MMC_MAX_MEM_STR_LEN, "%4.2lf%s", tmp_size, "KB");
728 retv_if(ret < 0, SETTING_RETURN_FAIL);
729 } else if (size < SETTING_MEMORY_GIGABYTE_VALUE) { // size < 1GB: show x.xMB
730 tmp_size = size / SETTING_MEMORY_MEGABYTE_VALUE;
731 ret = snprintf(size_desc, SETTING_MEMORY_MMC_MAX_MEM_STR_LEN, "%4.2lf%s", tmp_size, "MB");
732 retv_if(ret < 0, SETTING_RETURN_FAIL);
733 } else { // 1G <= size: show x.xGB
734 tmp_size = size / SETTING_MEMORY_GIGABYTE_VALUE;
735 ret = snprintf(size_desc, SETTING_MEMORY_MMC_MAX_MEM_STR_LEN, "%4.2lf%s", tmp_size, "GB");
736 retv_if(ret < 0, SETTING_RETURN_FAIL);
739 return SETTING_RETURN_SUCCESS;
742 static void setting_memory_status_ex_sd_card_format_cb(int val, void *data)
745 setting_retm_if(data == NULL, "Data parameter is NULL");
746 if (val == SETTING_MEMORY_STATUS_SYSMAN_REQUEST_SUCCESS) {
747 setting_memory_status_ex_sd_card_operate_complete(data,
748 _("IDS_COM_POP_SUCCESS"),
752 setting_memory_status_ex_sd_card_operate_complete(data,
753 _("IDS_COM_POP_FAILED"),
758 static void setting_memory_status_ex_sd_card_mount_cb(int val, void *data)
761 setting_retm_if(data == NULL, "Data parameter is NULL");
762 if (val == SETTING_MEMORY_STATUS_SYSMAN_REQUEST_SUCCESS) {
763 setting_memory_status_ex_sd_card_operate_complete(data,
764 _("IDS_COM_POP_SUCCESS"),
766 } else if (val == SETTING_MEMORY_STATUS_SYSMAN_REQUEST_MOUNT_ALREADY) {
767 setting_memory_status_ex_sd_card_operate_complete(data,
768 _(SETTING_MEMORY_STATUS_EX_SD_CARD_MOUNT_ALREADY_DESC),
771 setting_memory_status_ex_sd_card_operate_complete(data,
772 _("IDS_COM_POP_FAILED"),
777 static void setting_memory_status_ex_sd_card_unmount_cb(int val, void *data)
780 setting_retm_if(data == NULL, "Data parameter is NULL");
781 if (val == SETTING_MEMORY_STATUS_SYSMAN_REQUEST_SUCCESS) {
782 setting_memory_status_ex_sd_card_operate_complete(data,
783 _("IDS_COM_POP_SUCCESS"),
786 setting_memory_status_ex_sd_card_operate_complete(data,
787 _("IDS_COM_POP_FAILED"),
792 static void __setting_memory_status_vconf_change_cb( keynode_t *key, void *data)
795 setting_retm_if(NULL == key, "key is NULL");
796 setting_retm_if(NULL == data, "data is NULL");
797 SettingMemoryUG *ad = (SettingMemoryUG *)data;
799 int status = vconf_keynode_get_int(key);
800 char *vconf_name = vconf_keynode_get_name(key);
802 if (!safeStrCmp(vconf_name, VCONFKEY_USB_STORAGE_STATUS)) {
803 SETTING_TRACE("status:%d", status);
804 setting_memory_status_ex_sd_card_refresh_card_details_cb(ad,
807 char phone_storage_available[SETTING_MEMORY_MMC_MAX_MEM_STR_LEN] = {0,};
808 setting_memory_status_get_phone_storage_available_size(ad,
809 phone_storage_available);
812 setting_memory_status_list_item_data_set(ad->data_phone_storage_available, phone_storage_available);
814 } else if (!safeStrCmp(vconf_name, VCONFKEY_SYSMAN_MMC_STATUS)) {
815 SETTING_TRACE("status:%d", status);
816 setting_memory_status_ex_sd_card_refresh_card_details_cb(ad,
820 SETTING_TRACE_ERROR("vconf_name is NULL");
824 static int __setting_memory_status_check_mmc_status()
827 struct stat parent_stat, mount_stat;
829 ret = stat(SETTING_MEMORY_STATUS_MMC_PATH, &mount_stat);
830 setting_retvm_if(ret != 0, -1, "get stat error : /opt/storage/sdcard");
832 ret = stat(SETTING_MEMORY_STATUS_MMC_PARENT_PATH, &parent_stat);
833 setting_retvm_if(ret != 0, -1, "get stat error : /opt/storage/sdcard/..");
835 /* Does not mounted, same st_dev */
836 if(mount_stat.st_dev == parent_stat.st_dev)
840 /* MMC mounted, diff st_dev */
847 static int __setting_memory_status_mmc_content_init(void *data, setting_memory_mmc_cb cb)
850 setting_retvm_if(NULL == data, SETTING_RETURN_FAIL, "data is NULL");
851 setting_retvm_if(NULL == cb, SETTING_RETURN_FAIL, "cb is NULL");
852 SettingMemoryUG *ad = (SettingMemoryUG *)data;
853 if (ad->mmc_content == NULL) {
854 ad->mmc_content = (struct mmc_contents *)calloc(1, sizeof(struct mmc_contents));
855 if (ad->mmc_content == NULL ) {
856 SETTING_TRACE_ERROR("calloc failed");
857 return SETTING_RETURN_FAIL;
860 ad->mmc_content->mmc_cb = cb;
861 ad->mmc_content->user_data = ad;
862 return SETTING_RETURN_SUCCESS;