setting-memory/src/setting-memory-status.c

   1 /*
   2  * setting
   3  *
   4  * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd.
   5  *
   6  * Contact: MyoungJune Park <mj2004.park@samsung.com>
   7  *
   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
  11  *
  12  * http://www.apache.org/licenses/LICENSE-2.0
  13  *
  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.
  19  *
  20  */
  21 #include <setting-memory-status.h>
  22 #define MAX_STR_LEN_ON_MEMORY_STATUS    32
  23
  24 #define MAIN_STORAGE 0
  25
  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);
  30
  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,
  36 };
  37
  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);
  41
  42 static void __setting_memory_status_system_storage_available_size_get(char *szAvail)
  43 {
  44         SETTING_TRACE_BEGIN;
  45
  46         double dTotal = 0.0;
  47         double dAvail = 0.0;
  48         int ret = SETTING_RETURN_SUCCESS;
  49         setting_mem_status internal_mem_stat;
  50
  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;
  55
  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");
  58 }
  59
  60 static int setting_memory_status_create(void *cb)
  61 {
  62         SETTING_TRACE_BEGIN;
  63
  64         SettingMemoryUG *ad = (SettingMemoryUG *) cb;
  65         Evas_Object *scroller;
  66
  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);
  78
  79         /*  External SD card */
  80         setting_create_Gendial_field_titleItem(scroller, &(ad->itc_group_item),
  81                                                SETTING_MEMORY_STATUS_EX_SD_CARD_DESC,
  82                                                NULL);
  83
  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,
  89                                               ex_available_space,
  90                                               ex_mount_status, &ex_mmc_status);
  91
  92         ad->data_ex_total =
  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,
  97                                              NULL);
  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);
 102         } else {
 103                 SETTING_TRACE_ERROR("ad->data_ex_total is NULL");
 104         }
 105
 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,
 111                                              NULL);
 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);
 116         } else {
 117                 SETTING_TRACE_ERROR("ad->data_ex_available is NULL");
 118         }
 119
 120         if(!isEmulBin())
 121         {
 122                 ad->data_ex_mount =
 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,
 127                                              NULL);
 128                 if (ad->data_ex_mount) {
 129                         ad->data_ex_mount->userdata = ad;
 130                 } else {
 131                         SETTING_TRACE_ERROR("ad->data_ex_mount is NULL");
 132                 }
 133
 134                 ad->data_ex_format =
 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,
 138                                              NULL, 0,
 139                                              SETTING_MEMORY_STATUS_FORMAT_SD_CARD_DESC,
 140                                              NULL, NULL);
 141                 if (ad->data_ex_format) {
 142                         ad->data_ex_format->userdata = ad;
 143                 } else {
 144                         SETTING_TRACE_ERROR("ad->data_ex_format is NULL");
 145                 }
 146
 147                 setting_memory_status_list_item_enable_set_by_mmc_status(ad, ex_mmc_status);
 148         }
 149
 150         /* System storage */
 151         setting_create_Gendial_field_titleItem(scroller, &(ad->itc_group_item),
 152                                                SETTING_MEMORY_STATUS_SYSTEM_SPACE_DESC,
 153                                                NULL);
 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,
 161                                              NULL);
 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);
 166         } else {
 167                 SETTING_TRACE_ERROR("ad->data_system_storage_available is NULL");
 168         }
 169
 170 #if MAIN_STORAGE
 171         /*  Internal phone storage */
 172         setting_create_Gendial_field_titleItem(scroller, &(ad->itc_group_item),
 173                                                SETTING_MEMORY_STATUS_MAIN_STORAGE_DESC,
 174                                                NULL);
 175
 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,
 184                                              NULL);
 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);
 189         } else {
 190                 SETTING_TRACE_ERROR("ad->data_phone_storage_available is NULL");
 191         }
 192 #endif
 193
 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);
 198
 199         int ret = vconf_notify_key_changed(VCONFKEY_USB_STORAGE_STATUS,
 200                         __setting_memory_status_vconf_change_cb, ad);
 201         if (ret != 0) {
 202                 SETTING_TRACE_ERROR("call vconf_notify_key_changed failed");
 203         }
 204
 205         ret = vconf_notify_key_changed(VCONFKEY_SYSMAN_MMC_STATUS,
 206                         __setting_memory_status_vconf_change_cb, ad);
 207         if (ret != 0) {
 208                 SETTING_TRACE_ERROR("call vconf_notify_key_changed failed");
 209         }
 210
 211         setting_view_memory_status.is_create = 1;
 212         return SETTING_RETURN_SUCCESS;
 213 }
 214
 215 static int setting_memory_status_destroy(void *cb)
 216 {
 217         SETTING_TRACE_BEGIN;
 218         SettingMemoryUG *ad = (SettingMemoryUG *) cb;
 219
 220         if (ad->progress_bar) {
 221                 evas_object_del(ad->progress_bar);
 222                 ad->progress_bar = NULL;
 223         }
 224
 225         if (ad->popup) {
 226                 evas_object_del(ad->popup);
 227                 ad->popup = NULL;
 228         }
 229
 230         int ret = vconf_ignore_key_changed(VCONFKEY_SYSMAN_MMC_STATUS,
 231                         __setting_memory_status_vconf_change_cb);
 232         if (ret != 0) {
 233                 SETTING_TRACE_ERROR("call vconf_ignore_key_changed failed");
 234         }
 235
 236         ret = vconf_ignore_key_changed(VCONFKEY_USB_STORAGE_STATUS,
 237                         __setting_memory_status_vconf_change_cb);
 238         if (ret != 0) {
 239                 SETTING_TRACE_ERROR("call vconf_ignore_key_changed failed");
 240         }
 241
 242         if (ad->mmc_content) {
 243                 FREE(ad->mmc_content);
 244         }
 245
 246         elm_naviframe_item_pop(ad->navi_bar);
 247         setting_view_memory_status.is_create = 0;
 248
 249         return 0;
 250 }
 251
 252 static int setting_memory_status_update(void *cb)
 253 {
 254         SETTING_TRACE_BEGIN;
 255
 256         SettingMemoryUG *ad = (SettingMemoryUG *) cb;
 257         if (!ad) {
 258                 SETTING_TRACE_ERROR("ad is null.");
 259         }
 260         // update sd card statistic
 261         if (ad)
 262                 setting_memory_status_ex_sd_card_refresh_card_details_cb(ad, NULL, NULL);
 263
 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);
 267
 268 #if MAIN_STORAGE
 269         if (ad->data_phone_storage_available)
 270                 setting_memory_status_list_item_data_set(ad->data_phone_storage_available, phone_storage_available);
 271 #endif
 272         SETTING_TRACE_END;
 273         return 0;
 274 }
 275
 276 static int setting_memory_status_cleanup(void *cb)
 277 {
 278         return setting_memory_status_destroy(cb);
 279 }
 280
 281 /*******************************************
 282  *
 283  *general function
 284  *
 285  *******************************************/
 286
 287 static int __fs_stat(double* pdTotal, double* pdAvail, const char* szPath)
 288 {
 289         SETTING_TRACE_BEGIN;
 290         setting_retvm_if(NULL == pdTotal || NULL == pdAvail,
 291                 SETTING_RETURN_FAIL, "Null output parameters");
 292
 293         struct statvfs s;
 294
 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;
 300         } else {
 301                 return SETTING_RETURN_FAIL;
 302         }
 303
 304         return SETTING_RETURN_SUCCESS;
 305 }
 306
 307 /*******************************************
 308  *
 309  *callback function
 310  *
 311  *******************************************/
 312
 313 static void setting_memory_status_click_softkey_back(void *data,
 314                                                      Evas_Object *obj,
 315                                                      void *event_info)
 316 {
 317         SettingMemoryUG *ad = (SettingMemoryUG *) data;
 318         setting_view_change(&setting_view_memory_status,
 319                             &setting_view_memory_main, ad);
 320 }
 321
 322 static void
 323 setting_memory_status_ex_sd_card_info(char* szTotal, char* szAvail,
 324                                       char* ex_mount_desc, int *ex_mmc_status)
 325 {
 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);
 331
 332         int mmc_status = __setting_memory_status_check_mmc_status();
 333         setting_retm_if(mmc_status == -1, "check mmc status failed");
 334
 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);
 343         }
 344         /*  MMC mounted, diff st_dev */
 345         else {
 346                 snprintf(ex_mount_desc, SETTING_MEMORY_MMC_MAX_MEM_STR_LEN,
 347                          "%s", SETTING_MEMORY_STATUS_UNMOUNT_SD_CARD_DESC);
 348                 ret =
 349                     setting_memory_status_ex_sd_card_detail(szTotal, szAvail);
 350                 setting_retm_if(ret == SETTING_RETURN_FAIL,
 351                                 "get sd card detail failed");
 352         }
 353 }
 354
 355 static int
 356 setting_memory_status_ex_sd_card_detail(char* szTotal, char* szAvail)
 357 {
 358         SETTING_TRACE_BEGIN;
 359         double dTotal = 0.0;
 360         double dAvail = 0.0;
 361
 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");
 366
 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");
 370
 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");
 374
 375         SETTING_TRACE("Total[%s], Avail[%s]", szTotal, szAvail);
 376         return SETTING_RETURN_SUCCESS;
 377 }
 378
 379 static void
 380 setting_memory_status_mouse_up_Gendial_list_cb(void *data, Evas_Object *obj,
 381                                                void *event_info)
 382 {
 383         SETTING_TRACE_BEGIN;
 384         setting_retm_if(data == NULL, "Data parameter is NULL");
 385         setting_retm_if(event_info == NULL,
 386                         "Invalid argument: event info is NULL");
 387
 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);
 393
 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);
 399         }
 400 }
 401
 402 static void
 403 setting_memory_status_ex_sd_card_format_promt_popup_create(void *data)
 404 {
 405         SETTING_TRACE_BEGIN;
 406         setting_retm_if(data == NULL, "Data parameter is NULL");
 407         SettingMemoryUG *ad = (SettingMemoryUG *) data;
 408
 409         ad->curr_popup_cb = setting_memory_status_ex_sd_card_ask_format_resp_cb;
 410
 411         if (ad->popup) {
 412                 evas_object_del(ad->popup);
 413                 ad->popup = NULL;
 414         }
 415
 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"));
 420 }
 421
 422 static void
 423 setting_memory_status_ex_sd_card_ask_format_resp_cb(void *data,
 424                                                     Evas_Object *obj,
 425                                                     void *event_info)
 426 {
 427         SETTING_TRACE_BEGIN;
 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
 432                     (data, NULL, NULL);
 433         } else if (POPUP_RESPONSE_CANCEL == response_type) {
 434                 setting_memory_status_ex_sd_card_format_promt_popup_right_btn_cb
 435                     (data, NULL, NULL);
 436         }
 437 }
 438
 439 static void
 440 setting_memory_status_ex_sd_card_format_promt_popup_left_btn_cb(void *data,
 441                                                                 Evas_Object *
 442                                                                 obj,
 443                                                                 void
 444                                                                 *event_info)
 445 {
 446         SETTING_TRACE_BEGIN;
 447         setting_retm_if(data == NULL, "Data parameter is NULL");
 448         SettingMemoryUG *ad = (SettingMemoryUG *) data;
 449
 450         if (ad->popup) {
 451                 evas_object_del(ad->popup);
 452                 ad->popup = NULL;
 453         }
 454
 455         /* Show Formatting..... popup */
 456         ad->popup = setting_create_popup_with_progressbar(ad, ad->win_get,
 457                                                  "list_process",
 458                                                  _("IDS_ST_POP_MSG_FORMATTING"),
 459                                                  NULL, NULL,
 460                                                  SETTING_MEMORY_STATUS_PROGRESSBAR_TIMEOUT, TRUE, TRUE);
 461
 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");
 465                 if (ad->popup) {
 466                         evas_object_del(ad->popup);
 467                         ad->popup = NULL;
 468                 }
 469                 ad->popup = setting_create_popup_without_btn(ad, ad->win_get,
 470                                                  NULL, _("IDS_COM_POP_FAILED"),
 471                                                  NULL,
 472                                                  SETTING_MEMORY_POPUP_TIMER, FALSE, FALSE);
 473                 return;
 474         }
 475
 476         ret = sysman_request_format_mmc(ad->mmc_content);
 477         /*  if fail, destory popup */
 478         if (ret == -1) {
 479                 SETTING_TRACE_ERROR("call sysman_request_format_mmc fail");
 480                 if (ad->popup) {
 481                         evas_object_del(ad->popup);
 482                         ad->popup = NULL;
 483                 }
 484                 ad->popup = setting_create_popup_without_btn(ad, ad->win_get,
 485                                                  NULL, _("IDS_COM_POP_FAILED"),
 486                                                  NULL,
 487                                                  SETTING_MEMORY_POPUP_TIMER, FALSE, FALSE);
 488         }
 489 }
 490
 491 static void
 492 setting_memory_status_ex_sd_card_format_promt_popup_right_btn_cb(void *data,
 493                                                                  Evas_Object *
 494                                                                  obj,
 495                                                                  void
 496                                                                  *event_info)
 497 {
 498         SETTING_TRACE_BEGIN;
 499         setting_retm_if(data == NULL, "Data parameter is NULL");
 500         SettingMemoryUG *ad = (SettingMemoryUG *) data;
 501
 502         if (ad->popup) {
 503                 evas_object_del(ad->popup);
 504                 ad->popup = NULL;
 505         }
 506 }
 507
 508 static void setting_memory_status_ex_sd_card_mount_unmount(void *data)
 509 {
 510         SETTING_TRACE_BEGIN;
 511         setting_retm_if(data == NULL, "Data parameter is NULL");
 512         SettingMemoryUG *ad = (SettingMemoryUG *)data;
 513
 514         int mmc_status = __setting_memory_status_check_mmc_status();
 515         setting_retm_if(mmc_status == -1, "check mmc status failed");
 516
 517         if (ad->popup) {
 518                 evas_object_del(ad->popup);
 519                 ad->popup = NULL;
 520         }
 521
 522         /* Show progressbar popup */
 523         ad->popup = setting_create_popup_with_progressbar(ad, ad->win_get,
 524                                                  "pending_list",
 525                                                  NULL, NULL, NULL,
 526                                                  SETTING_MEMORY_STATUS_PROGRESSBAR_TIMEOUT, TRUE, TRUE);
 527
 528         int ret = -1;
 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");
 534                         if (ad->popup) {
 535                                 evas_object_del(ad->popup);
 536                                 ad->popup = NULL;
 537                         }
 538                         ad->popup = setting_create_popup_without_btn(ad, ad->win_get,
 539                                                  NULL, _("IDS_COM_POP_FAILED"),
 540                                                  NULL,
 541                                                  SETTING_MEMORY_POPUP_TIMER, FALSE, FALSE);
 542                         return;
 543                 }
 544                 ret = sysman_request_mount_mmc(ad->mmc_content);
 545                 if (ret == -1) {
 546                         SETTING_TRACE_ERROR("call sysman_request_mount_mmc fail");
 547                 }
 548         }
 549         /*  MMC mounted, diff st_dev */
 550         else {
 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");
 554                         if (ad->popup) {
 555                                 evas_object_del(ad->popup);
 556                                 ad->popup = NULL;
 557                         }
 558                         ad->popup = setting_create_popup_without_btn(ad, ad->win_get,
 559                                                  NULL, _("IDS_COM_POP_FAILED"),
 560                                                  NULL,
 561                                                  SETTING_MEMORY_POPUP_TIMER, FALSE, FALSE);
 562                         return;
 563                 }
 564
 565                 ret = sysman_request_unmount_mmc(ad->mmc_content,
 566                                                  MNT_FORCE);    /*  1 = MNT_FORCE */
 567                 if (ret == -1) {
 568                         SETTING_TRACE_ERROR("call sysman_request_unmount_mmc fail");
 569                 }
 570         }
 571
 572         /*  if fail, popup failed info */
 573         if (ret == -1) {
 574                 if (ad->popup) {
 575                         evas_object_del(ad->popup);
 576                         ad->popup = NULL;
 577                 }
 578                 ad->popup = setting_create_popup_without_btn(ad, ad->win_get,
 579                                                  NULL, _("IDS_COM_POP_FAILED"),
 580                                                  NULL,
 581                                                  SETTING_MEMORY_POPUP_TIMER, FALSE, FALSE);
 582         }
 583 }
 584
 585 static void
 586 setting_memory_status_ex_sd_card_refresh_card_details_cb(void *data,
 587                                                          Evas_Object *obj,
 588                                                          void *event_info)
 589 {
 590         SETTING_TRACE_BEGIN;
 591         setting_retm_if(data == NULL, "Data parameter is NULL");
 592         SettingMemoryUG *ad = (SettingMemoryUG *)data;
 593
 594         if (ad->popup) {
 595                 evas_object_del(ad->popup);
 596                 ad->popup = NULL;
 597         }
 598
 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);
 605
 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);
 608         if(!isEmulBin())
 609         {
 610                 setting_memory_status_list_item_data_set(ad->data_ex_mount, ex_mount_status);
 611         }
 612         setting_memory_status_list_item_enable_set_by_mmc_status(ad, ex_mmc_status);
 613 }
 614
 615 static void
 616 setting_memory_status_ex_sd_card_operate_complete(void *data, char *desc,
 617                                                   bool popup_flag)
 618 {
 619         SETTING_TRACE_BEGIN;
 620         setting_retm_if(data == NULL, "Data parameter is NULL");
 621         SettingMemoryUG *ad = (SettingMemoryUG *) data;
 622         setting_memory_hide_popup_with_progress_bar(ad);
 623         if (popup_flag) {
 624                 if (ad->popup) {
 625                         evas_object_del(ad->popup);
 626                         ad->popup = NULL;
 627                 }
 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);
 631         }
 632 }
 633
 634 static void
 635 setting_memory_status_list_item_enable_set_by_mmc_status(void *data,
 636                                                          int ex_mmc_status)
 637 {
 638         SETTING_TRACE_BEGIN;
 639         setting_retm_if(data == NULL, "Data parameter is NULL");
 640         SettingMemoryUG *ad = (SettingMemoryUG *) data;
 641
 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);
 645                 if(!isEmulBin())
 646                 {
 647                         setting_disable_genlist_item(ad->data_ex_mount->item);
 648                         setting_disable_genlist_item(ad->data_ex_format->item);
 649                 }
 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);
 653                 if(!isEmulBin())
 654                 {
 655                         setting_enable_genlist_item(ad->data_ex_mount->item);
 656                         setting_disable_genlist_item(ad->data_ex_format->item);
 657                 }
 658         } else if (ex_mmc_status == VCONFKEY_SYSMAN_MMC_MOUNTED){
 659         } else {
 660                 SETTING_TRACE_DEBUG("abnormal status of MMC");
 661         }
 662
 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");
 666
 667         if (storage_status == VCONFKEY_USB_STORAGE_STATUS_UMS_MMC_ON) {
 668                 if(!isEmulBin())
 669                 {
 670                         setting_disable_genlist_item(ad->data_ex_mount->item);
 671                         setting_disable_genlist_item(ad->data_ex_format->item);
 672                 }
 673         }
 674 }
 675
 676 static void setting_memory_status_list_item_data_set(Setting_GenGroupItem_Data *
 677                                                      item_data, char *data)
 678 {
 679         SETTING_TRACE_BEGIN;
 680         setting_retm_if(item_data == NULL, "Data parameter is NULL");
 681
 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);
 686 }
 687
 688 static void
 689 setting_memory_status_get_phone_storage_available_size(void *data,
 690                                                        char *szAvail)
 691 {
 692         SETTING_TRACE_BEGIN;
 693         setting_retm_if(data == NULL, "Data parameter is NULL");
 694         //SettingMemoryUG *ad = (SettingMemoryUG *) data;
 695
 696         double dTotal = 0.0;
 697         double dAvail = 0.0;
 698         int ret = SETTING_RETURN_SUCCESS;
 699         setting_mem_status internal_mem_stat;
 700
 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;
 705
 706         dTotal = 0.0;
 707         dAvail = 0.0;
 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;
 712
 713         ret = setting_memory_status_size_transition(internal_mem_stat.dAvail,
 714                                                   szAvail);
 715         setting_retm_if(ret == SETTING_RETURN_FAIL, "setting_memory_status_size_transition fail");
 716 }
 717
 718 static int
 719 setting_memory_status_size_transition(double size, char *size_desc)
 720 {
 721         SETTING_TRACE_BEGIN;
 722
 723         double tmp_size = 0.0;
 724         int ret = 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);
 737         }
 738
 739         return SETTING_RETURN_SUCCESS;
 740 }
 741
 742 static void setting_memory_status_ex_sd_card_format_cb(int val, void *data)
 743 {
 744         SETTING_TRACE_BEGIN;
 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"),
 749                                                                   TRUE);
 750
 751         } else {
 752                 setting_memory_status_ex_sd_card_operate_complete(data,
 753                                                                   _("IDS_COM_POP_FAILED"),
 754                                                                   TRUE);
 755         }
 756 }
 757
 758 static void setting_memory_status_ex_sd_card_mount_cb(int val, void *data)
 759 {
 760         SETTING_TRACE_BEGIN;
 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"),
 765                                                                   FALSE);
 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),
 769                                                                   TRUE);
 770         } else {
 771                 setting_memory_status_ex_sd_card_operate_complete(data,
 772                                                                   _("IDS_COM_POP_FAILED"),
 773                                                                   TRUE);
 774         }
 775 }
 776
 777 static void setting_memory_status_ex_sd_card_unmount_cb(int val, void *data)
 778 {
 779         SETTING_TRACE_BEGIN;
 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"),
 784                                                                   FALSE);
 785         } else {
 786                 setting_memory_status_ex_sd_card_operate_complete(data,
 787                                                                   _("IDS_COM_POP_FAILED"),
 788                                                                   TRUE);
 789         }
 790 }
 791
 792 static void __setting_memory_status_vconf_change_cb( keynode_t *key, void *data)
 793 {
 794         SETTING_TRACE_BEGIN;
 795         setting_retm_if(NULL == key, "key is NULL");
 796         setting_retm_if(NULL == data, "data is NULL");
 797         SettingMemoryUG *ad = (SettingMemoryUG *)data;
 798
 799         int status = vconf_keynode_get_int(key);
 800         char *vconf_name = vconf_keynode_get_name(key);
 801
 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,
 805                                                         NULL,
 806                                                         NULL);
 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);
 810
 811 #if MAIN_STORAGE
 812                 setting_memory_status_list_item_data_set(ad->data_phone_storage_available, phone_storage_available);
 813 #endif
 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,
 817                                                         NULL,
 818                                                         NULL);
 819         } else {
 820                 SETTING_TRACE_ERROR("vconf_name is NULL");
 821         }
 822 }
 823
 824 static int __setting_memory_status_check_mmc_status()
 825 {
 826         int ret = 0;
 827         struct stat parent_stat, mount_stat;
 828
 829         ret = stat(SETTING_MEMORY_STATUS_MMC_PATH, &mount_stat);
 830         setting_retvm_if(ret != 0, -1, "get stat error : /opt/storage/sdcard");
 831
 832         ret = stat(SETTING_MEMORY_STATUS_MMC_PARENT_PATH, &parent_stat);
 833         setting_retvm_if(ret != 0, -1, "get stat error : /opt/storage/sdcard/..");
 834
 835         /* Does not mounted, same st_dev */
 836         if(mount_stat.st_dev == parent_stat.st_dev)
 837         {
 838                 return 0;
 839         }
 840         /* MMC mounted, diff st_dev */
 841         else
 842         {
 843                 return 1;
 844         }
 845 }
 846
 847 static int __setting_memory_status_mmc_content_init(void *data, setting_memory_mmc_cb cb)
 848 {
 849         SETTING_TRACE_BEGIN;
 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;
 858                 }
 859         }
 860         ad->mmc_content->mmc_cb = cb;
 861         ad->mmc_content->user_data = ad;
 862         return SETTING_RETURN_SUCCESS;
 863 }