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

   1 /*
   2  * setting
   3  * Copyright (c) 2012 Samsung Electronics Co., Ltd.
   4  *
   5  * Licensed under the Flora License, Version 1.0 (the License);
   6  * you may not use this file except in compliance with the License.
   7  * You may obtain a copy of the License at
   8  *
   9  *     http://floralicense.org/license/
  10  *
  11  * Unless required by applicable law or agreed to in writing, software
  12  * distributed under the License is distributed on an AS IS BASIS,
  13  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14  * See the License for the specific language governing permissions and
  15  * limitations under the License.
  16  */
  17 #include <setting-memory-status.h>
  18 #define MAX_STR_LEN_ON_MEMORY_STATUS    32
  19
  20 #define MAIN_STORAGE 0
  21
  22 static int setting_memory_status_create(void *cb);
  23 static int setting_memory_status_destroy(void *cb);
  24 static int setting_memory_status_update(void *cb);
  25 static int setting_memory_status_cleanup(void *cb);
  26
  27 setting_view setting_view_memory_status = {
  28         .create = setting_memory_status_create,
  29         .destroy = setting_memory_status_destroy,
  30         .update = setting_memory_status_update,
  31         .cleanup = setting_memory_status_cleanup,
  32 };
  33
  34 static void __setting_memory_status_vconf_change_cb( keynode_t *key, void *data);
  35 static int __setting_memory_status_check_mmc_status();
  36 static int __setting_memory_status_mmc_content_init(void *data, setting_memory_mmc_cb cb);
  37
  38 static void __setting_memory_status_system_storage_available_size_get(char *szAvail)
  39 {
  40         SETTING_TRACE_BEGIN;
  41
  42         double dTotal = 0.0;
  43         double dAvail = 0.0;
  44         int ret = SETTING_RETURN_SUCCESS;
  45         setting_mem_status internal_mem_stat;
  46
  47         ret = __fs_stat(&dTotal, &dAvail, SETTING_MEMORY_STATUS_APP_PATH);
  48         setting_retm_if(ret == SETTING_RETURN_FAIL, "get app_mem stat failed");
  49         internal_mem_stat.dTotal = dTotal;
  50         internal_mem_stat.dAvail = dAvail;
  51
  52         ret = setting_memory_status_size_transition(internal_mem_stat.dAvail, szAvail);
  53         setting_retm_if(ret == SETTING_RETURN_FAIL, "setting_memory_status_size_transition fail");
  54 }
  55
  56 static int setting_memory_status_create(void *cb)
  57 {
  58         SETTING_TRACE_BEGIN;
  59
  60         SettingMemoryUG *ad = (SettingMemoryUG *) cb;
  61         Evas_Object *scroller;
  62
  63         /* Evas_Object *user_mem_fr, *phone_mem_fr, *fr_bx1, *fr_bx2; */
  64         /* Evas_Object *sp; */
  65         /* float tmp_free_size, tmp_total_size; */
  66         /* char free_str[MAX_STR_LEN_ON_MEMORY_STATUS] = {0, }; */
  67         /* char total_str[MAX_STR_LEN_ON_MEMORY_STATUS] = {0, }; */
  68         /* char size_str[MAX_STR_LEN_ON_MEMORY_STATUS*2] = {0, }; */
  69         setting_push_layout_navi_bar_genlist(ad->win_main_layout, ad->win_get,
  70                                              _("IDS_ST_BODY_MEMORY_STATUS"),
  71                                              S_("IDS_COM_BODY_BACK"), NULL,
  72                                              setting_memory_status_click_softkey_back,
  73                                              NULL, ad, &scroller, ad->navi_bar);
  74
  75         /*  External SD card */
  76         setting_create_Gendial_field_titleItem(scroller, &(ad->itc_group_item),
  77                                                SETTING_MEMORY_STATUS_EX_SD_CARD_DESC,
  78                                                NULL);
  79
  80         char ex_total_space[SETTING_MEMORY_MMC_MAX_MEM_STR_LEN] = { 0, };
  81         char ex_available_space[SETTING_MEMORY_MMC_MAX_MEM_STR_LEN] = { 0, };
  82         char ex_mount_status[SETTING_MEMORY_MMC_MAX_MEM_STR_LEN] = { 0, };
  83         int ex_mmc_status = VCONFKEY_SYSMAN_MMC_REMOVED;
  84         setting_memory_status_ex_sd_card_info(ex_total_space,
  85                                               ex_available_space,
  86                                               ex_mount_status, &ex_mmc_status);
  87
  88         ad->data_ex_total =
  89             setting_create_Gendial_field_def(scroller, &(ad->itc_2text_2), NULL,
  90                                              ad, SWALLOW_Type_INVALID, NULL,
  91                                              NULL, 0, ex_total_space,
  92                                              SETTING_MEMORY_STATUS_TOTAL_SPACE_DESC,
  93                                              NULL);
  94         if (ad->data_ex_total) {
  95                 ad->data_ex_total->userdata = ad;
  96                 elm_genlist_item_select_mode_set(ad->data_ex_total->item,
  97                         ELM_OBJECT_SELECT_MODE_DISPLAY_ONLY);
  98         } else {
  99                 SETTING_TRACE_ERROR("ad->data_ex_total is NULL");
 100         }
 101
 102         ad->data_ex_available =
 103             setting_create_Gendial_field_def(scroller, &(ad->itc_2text_2), NULL,
 104                                              ad, SWALLOW_Type_INVALID, NULL,
 105                                              NULL, 0, ex_available_space,
 106                                              SETTING_MEMORY_STATUS_AVAILABLE_SPACE_DESC,
 107                                              NULL);
 108         if (ad->data_ex_available) {
 109                 ad->data_ex_available->userdata = ad;
 110                 elm_genlist_item_select_mode_set(ad->data_ex_available->item,
 111                                           ELM_OBJECT_SELECT_MODE_DISPLAY_ONLY);
 112         } else {
 113                 SETTING_TRACE_ERROR("ad->data_ex_available is NULL");
 114         }
 115
 116         if(!isEmulBin())
 117         {
 118                 ad->data_ex_mount =
 119                                         setting_create_Gendial_field_def(scroller, &(ad->itc_1text),
 120                                              setting_memory_status_mouse_up_Gendial_list_cb,
 121                                              ad, SWALLOW_Type_INVALID, NULL,
 122                                              NULL, 0, ex_mount_status, NULL,
 123                                              NULL);
 124                 if (ad->data_ex_mount) {
 125                         ad->data_ex_mount->userdata = ad;
 126                 } else {
 127                         SETTING_TRACE_ERROR("ad->data_ex_mount is NULL");
 128                 }
 129
 130                 ad->data_ex_format =
 131                                         setting_create_Gendial_field_def(scroller, &(ad->itc_1text),
 132                                              setting_memory_status_mouse_up_Gendial_list_cb,
 133                                              ad, SWALLOW_Type_INVALID, NULL,
 134                                              NULL, 0,
 135                                              SETTING_MEMORY_STATUS_FORMAT_SD_CARD_DESC,
 136                                              NULL, NULL);
 137                 if (ad->data_ex_format) {
 138                         ad->data_ex_format->userdata = ad;
 139                 } else {
 140                         SETTING_TRACE_ERROR("ad->data_ex_format is NULL");
 141                 }
 142
 143                 setting_memory_status_list_item_enable_set_by_mmc_status(ad, ex_mmc_status);
 144         }
 145
 146         /* System storage */
 147         setting_create_Gendial_field_titleItem(scroller, &(ad->itc_group_item),
 148                                                SETTING_MEMORY_STATUS_SYSTEM_SPACE_DESC,
 149                                                NULL);
 150         char system_storage_available[SETTING_MEMORY_MMC_MAX_MEM_STR_LEN] = {0,};
 151         __setting_memory_status_system_storage_available_size_get(system_storage_available);
 152         ad->data_system_storage_available =
 153             setting_create_Gendial_field_def(scroller, &(ad->itc_2text_2), NULL,
 154                                              ad, SWALLOW_Type_INVALID, NULL,
 155                                              NULL, 0, system_storage_available,
 156                                              SETTING_MEMORY_STATUS_AVAILABLE_SPACE_DESC,
 157                                              NULL);
 158         if (ad->data_system_storage_available) {
 159                 ad->data_system_storage_available->userdata = ad;
 160                 elm_genlist_item_select_mode_set(ad->data_system_storage_available->
 161                                           item, ELM_OBJECT_SELECT_MODE_DISPLAY_ONLY);
 162         } else {
 163                 SETTING_TRACE_ERROR("ad->data_system_storage_available is NULL");
 164         }
 165
 166 #if MAIN_STORAGE
 167         /*  Internal phone storage */
 168         setting_create_Gendial_field_titleItem(scroller, &(ad->itc_group_item),
 169                                                SETTING_MEMORY_STATUS_MAIN_STORAGE_DESC,
 170                                                NULL);
 171
 172         char phone_storage_available[SETTING_MEMORY_MMC_MAX_MEM_STR_LEN] = {0,};
 173         setting_memory_status_get_phone_storage_available_size(ad,
 174                                                                phone_storage_available);
 175         ad->data_phone_storage_available =
 176             setting_create_Gendial_field_def(scroller, &(ad->itc_2text_2), NULL,
 177                                              ad, SWALLOW_Type_INVALID, NULL,
 178                                              NULL, 0, phone_storage_available,
 179                                              SETTING_MEMORY_STATUS_AVAILABLE_SPACE_DESC,
 180                                              NULL);
 181         if (ad->data_phone_storage_available) {
 182                 ad->data_phone_storage_available->userdata = ad;
 183                 elm_genlist_item_select_mode_set(ad->data_phone_storage_available->
 184                                           item, ELM_OBJECT_SELECT_MODE_DISPLAY_ONLY);
 185         } else {
 186                 SETTING_TRACE_ERROR("ad->data_phone_storage_available is NULL");
 187         }
 188 #endif
 189
 190         Elm_Object_Item *item = NULL;
 191         item = elm_genlist_item_append(scroller, &itc_bottom_seperator, NULL, NULL,
 192                                     ELM_GENLIST_ITEM_NONE, NULL, NULL);
 193         elm_genlist_item_select_mode_set(item, ELM_OBJECT_SELECT_MODE_DISPLAY_ONLY);
 194
 195         int ret = vconf_notify_key_changed(VCONFKEY_SYSMAN_MMC_STATUS,
 196                         __setting_memory_status_vconf_change_cb, ad);
 197         if (ret != 0) {
 198                 SETTING_TRACE_ERROR("call vconf_notify_key_changed failed");
 199         }
 200
 201         setting_view_memory_status.is_create = 1;
 202         return SETTING_RETURN_SUCCESS;
 203 }
 204
 205 static int setting_memory_status_destroy(void *cb)
 206 {
 207         SETTING_TRACE_BEGIN;
 208         SettingMemoryUG *ad = (SettingMemoryUG *) cb;
 209
 210         if (ad->progress_bar) {
 211                 evas_object_del(ad->progress_bar);
 212                 ad->progress_bar = NULL;
 213         }
 214
 215         if (ad->popup) {
 216                 evas_object_del(ad->popup);
 217                 ad->popup = NULL;
 218         }
 219
 220         int ret = vconf_ignore_key_changed(VCONFKEY_SYSMAN_MMC_STATUS,
 221                         __setting_memory_status_vconf_change_cb);
 222         if (ret != 0) {
 223                 SETTING_TRACE_ERROR("call vconf_ignore_key_changed failed");
 224         }
 225
 226         if (ad->mmc_content) {
 227                 FREE(ad->mmc_content);
 228         }
 229
 230         elm_naviframe_item_pop(ad->navi_bar);
 231         setting_view_memory_status.is_create = 0;
 232
 233         return 0;
 234 }
 235
 236 static int setting_memory_status_update(void *cb)
 237 {
 238         SETTING_TRACE_BEGIN;
 239
 240         SettingMemoryUG *ad = (SettingMemoryUG *) cb;
 241         if (!ad) {
 242                 SETTING_TRACE_ERROR("ad is null.");
 243         }
 244         // update sd card statistic
 245         if (ad)
 246                 setting_memory_status_ex_sd_card_refresh_card_details_cb(ad, NULL, NULL);
 247
 248         // update internal phone storage statistic
 249         char phone_storage_available[SETTING_MEMORY_MMC_MAX_MEM_STR_LEN] = {0,};
 250         setting_memory_status_get_phone_storage_available_size(ad, phone_storage_available);
 251
 252 #if MAIN_STORAGE
 253         if (ad->data_phone_storage_available)
 254                 setting_memory_status_list_item_data_set(ad->data_phone_storage_available, phone_storage_available);
 255 #endif
 256         SETTING_TRACE_END;
 257         return 0;
 258 }
 259
 260 static int setting_memory_status_cleanup(void *cb)
 261 {
 262         return setting_memory_status_destroy(cb);
 263 }
 264
 265 /*******************************************
 266  *
 267  *general function
 268  *
 269  *******************************************/
 270
 271 static int __fs_stat(double* pdTotal, double* pdAvail, const char* szPath)
 272 {
 273         SETTING_TRACE_BEGIN;
 274         setting_retvm_if(NULL == pdTotal || NULL == pdAvail,
 275                 SETTING_RETURN_FAIL, "Null output parameters");
 276
 277         struct statvfs s;
 278
 279         if (!statvfs(szPath, &s)) {
 280                 SETTING_TRACE("f_bsize = %ld f_blocks = %ld f_bavail = %ld f_frsize = %ld",
 281                      s.f_bsize, s.f_blocks, s.f_bavail, s.f_frsize);
 282                 *pdTotal = (double)s.f_frsize * s.f_blocks;
 283                 *pdAvail = (double)s.f_bsize * s.f_bavail;
 284         } else {
 285                 return SETTING_RETURN_FAIL;
 286         }
 287
 288         return SETTING_RETURN_SUCCESS;
 289 }
 290
 291 /*******************************************
 292  *
 293  *callback function
 294  *
 295  *******************************************/
 296
 297 static void setting_memory_status_click_softkey_back(void *data,
 298                                                      Evas_Object *obj,
 299                                                      void *event_info)
 300 {
 301         SettingMemoryUG *ad = (SettingMemoryUG *) data;
 302         setting_view_change(&setting_view_memory_status,
 303                             &setting_view_memory_main, ad);
 304 }
 305
 306 static void
 307 setting_memory_status_ex_sd_card_info(char* szTotal, char* szAvail,
 308                                       char* ex_mount_desc, int *ex_mmc_status)
 309 {
 310         int mmc_mode = VCONFKEY_SYSMAN_MMC_REMOVED;
 311         int ret = vconf_get_int(VCONFKEY_SYSMAN_MMC_STATUS, &mmc_mode);
 312         setting_retm_if(ret != 0, "Get VCONFKEY_SYSMAN_MMC_STATUS failed");
 313         *ex_mmc_status = mmc_mode;
 314         SETTING_TRACE("mmc_mode = %d", mmc_mode);
 315
 316         int mmc_status = __setting_memory_status_check_mmc_status();
 317         setting_retm_if(mmc_status == -1, "check mmc status failed");
 318
 319         /* Does not mounted, same st_dev */
 320         if (mmc_status == 0) {
 321                 snprintf(szTotal, SETTING_MEMORY_MMC_MAX_MEM_STR_LEN,
 322                          "%s", _("IDS_ST_HEADER_UNAVAILABLE"));
 323                 snprintf(szAvail, SETTING_MEMORY_MMC_MAX_MEM_STR_LEN,
 324                          "%s", _("IDS_ST_HEADER_UNAVAILABLE"));
 325                 snprintf(ex_mount_desc, SETTING_MEMORY_MMC_MAX_MEM_STR_LEN,
 326                          "%s", SETTING_MEMORY_STATUS_MOUNT_SD_CARD_DESC);
 327         }
 328         /*  MMC mounted, diff st_dev */
 329         else {
 330                 snprintf(ex_mount_desc, SETTING_MEMORY_MMC_MAX_MEM_STR_LEN,
 331                          "%s", SETTING_MEMORY_STATUS_UNMOUNT_SD_CARD_DESC);
 332                 ret =
 333                     setting_memory_status_ex_sd_card_detail(szTotal, szAvail);
 334                 setting_retm_if(ret == SETTING_RETURN_FAIL,
 335                                 "get sd card detail failed");
 336         }
 337 }
 338
 339 static int
 340 setting_memory_status_ex_sd_card_detail(char* szTotal, char* szAvail)
 341 {
 342         SETTING_TRACE_BEGIN;
 343         double dTotal = 0.0;
 344         double dAvail = 0.0;
 345
 346         int ret = SETTING_RETURN_SUCCESS;
 347         ret = __fs_stat(&dTotal, &dAvail, SETTING_MEMORY_STATUS_MMC_PATH);
 348         setting_retvm_if(ret == SETTING_RETURN_FAIL, SETTING_RETURN_FAIL,
 349                          "get sd card size detail failed");
 350
 351         ret = setting_memory_status_size_transition(dTotal, szTotal);
 352         setting_retvm_if(ret == SETTING_RETURN_FAIL, SETTING_RETURN_FAIL,
 353                          "setting_memory_status_size_transition failed");
 354
 355         ret = setting_memory_status_size_transition(dAvail, szAvail);
 356         setting_retvm_if(ret == SETTING_RETURN_FAIL, SETTING_RETURN_FAIL,
 357                          "setting_memory_status_size_transition failed");
 358
 359         SETTING_TRACE("Total[%s], Avail[%s]", szTotal, szAvail);
 360         return SETTING_RETURN_SUCCESS;
 361 }
 362
 363 static void
 364 setting_memory_status_mouse_up_Gendial_list_cb(void *data, Evas_Object *obj,
 365                                                void *event_info)
 366 {
 367         SETTING_TRACE_BEGIN;
 368         setting_retm_if(data == NULL, "Data parameter is NULL");
 369         setting_retm_if(event_info == NULL,
 370                         "Invalid argument: event info is NULL");
 371
 372         SettingMemoryUG *ad = (SettingMemoryUG *) data;
 373         Elm_Object_Item *item = (Elm_Object_Item *) event_info;
 374         elm_genlist_item_selected_set(item, 0);
 375         Setting_GenGroupItem_Data *list_item =
 376             (Setting_GenGroupItem_Data *) elm_object_item_data_get(item);
 377
 378         SETTING_TRACE("clicking item[%s]", _(list_item->keyStr));
 379         if (list_item == ad->data_ex_mount) {
 380                 setting_memory_status_ex_sd_card_mount_unmount(ad);
 381         } else if (list_item == ad->data_ex_format) {
 382                 setting_memory_status_ex_sd_card_format_promt_popup_create(ad);
 383         }
 384 }
 385
 386 static void
 387 setting_memory_status_ex_sd_card_format_promt_popup_create(void *data)
 388 {
 389         SETTING_TRACE_BEGIN;
 390         setting_retm_if(data == NULL, "Data parameter is NULL");
 391         SettingMemoryUG *ad = (SettingMemoryUG *) data;
 392
 393         ad->curr_popup_cb = setting_memory_status_ex_sd_card_ask_format_resp_cb;
 394
 395         if (ad->popup) {
 396                 evas_object_del(ad->popup);
 397                 ad->popup = NULL;
 398         }
 399
 400         ad->popup = setting_create_popup_with_btn(ad, ad->win_get, NULL,
 401                                          _(SETTING_MEMORY_STATUS_FORMAT_ASK_MSG),
 402                                          ad->curr_popup_cb, 0,
 403                                          2, _("IDS_COM_SK_YES"),_("IDS_COM_SK_NO"));
 404 }
 405
 406 static void
 407 setting_memory_status_ex_sd_card_ask_format_resp_cb(void *data,
 408                                                     Evas_Object *obj,
 409                                                     void *event_info)
 410 {
 411         SETTING_TRACE_BEGIN;
 412         setting_retm_if(data == NULL, "Data parameter is NULL");
 413         int response_type = btn_type(obj);
 414         if (POPUP_RESPONSE_OK == response_type) {
 415                 setting_memory_status_ex_sd_card_format_promt_popup_left_btn_cb
 416                     (data, NULL, NULL);
 417         } else if (POPUP_RESPONSE_CANCEL == response_type) {
 418                 setting_memory_status_ex_sd_card_format_promt_popup_right_btn_cb
 419                     (data, NULL, NULL);
 420         }
 421 }
 422
 423 static void
 424 setting_memory_status_ex_sd_card_format_promt_popup_left_btn_cb(void *data,
 425                                                                 Evas_Object *
 426                                                                 obj,
 427                                                                 void
 428                                                                 *event_info)
 429 {
 430         SETTING_TRACE_BEGIN;
 431         setting_retm_if(data == NULL, "Data parameter is NULL");
 432         SettingMemoryUG *ad = (SettingMemoryUG *) data;
 433
 434         if (ad->popup) {
 435                 evas_object_del(ad->popup);
 436                 ad->popup = NULL;
 437         }
 438
 439         /* Show Formatting..... popup */
 440         ad->popup = setting_create_popup_with_progressbar(ad, ad->win_get,
 441                                                  "list_process",
 442                                                  _("IDS_ST_POP_MSG_FORMATTING"),
 443                                                  NULL, NULL,
 444                                                  SETTING_MEMORY_STATUS_PROGRESSBAR_TIMEOUT, TRUE, TRUE);
 445
 446         int ret = __setting_memory_status_mmc_content_init(ad, setting_memory_status_ex_sd_card_format_cb);
 447         if (ret == SETTING_RETURN_FAIL) {
 448                 SETTING_TRACE_ERROR("__setting_memory_status_mmc_content_init fail");
 449                 if (ad->popup) {
 450                         evas_object_del(ad->popup);
 451                         ad->popup = NULL;
 452                 }
 453                 ad->popup = setting_create_popup_without_btn(ad, ad->win_get,
 454                                                  NULL, _("IDS_COM_POP_FAILED"),
 455                                                  NULL,
 456                                                  SETTING_MEMORY_POPUP_TIMER, FALSE, FALSE);
 457                 return;
 458         }
 459
 460         ret = sysman_request_format_mmc(ad->mmc_content);
 461         /*  if fail, destory popup */
 462         if (ret == -1) {
 463                 SETTING_TRACE_ERROR("call sysman_request_format_mmc fail");
 464                 if (ad->popup) {
 465                         evas_object_del(ad->popup);
 466                         ad->popup = NULL;
 467                 }
 468                 ad->popup = setting_create_popup_without_btn(ad, ad->win_get,
 469                                                  NULL, _("IDS_COM_POP_FAILED"),
 470                                                  NULL,
 471                                                  SETTING_MEMORY_POPUP_TIMER, FALSE, FALSE);
 472         }
 473 }
 474
 475 static void
 476 setting_memory_status_ex_sd_card_format_promt_popup_right_btn_cb(void *data,
 477                                                                  Evas_Object *
 478                                                                  obj,
 479                                                                  void
 480                                                                  *event_info)
 481 {
 482         SETTING_TRACE_BEGIN;
 483         setting_retm_if(data == NULL, "Data parameter is NULL");
 484         SettingMemoryUG *ad = (SettingMemoryUG *) data;
 485
 486         if (ad->popup) {
 487                 evas_object_del(ad->popup);
 488                 ad->popup = NULL;
 489         }
 490 }
 491
 492 static void setting_memory_status_ex_sd_card_mount_unmount(void *data)
 493 {
 494         SETTING_TRACE_BEGIN;
 495         setting_retm_if(data == NULL, "Data parameter is NULL");
 496         SettingMemoryUG *ad = (SettingMemoryUG *)data;
 497
 498         int mmc_status = __setting_memory_status_check_mmc_status();
 499         setting_retm_if(mmc_status == -1, "check mmc status failed");
 500
 501         if (ad->popup) {
 502                 evas_object_del(ad->popup);
 503                 ad->popup = NULL;
 504         }
 505
 506         /* Show progressbar popup */
 507         ad->popup = setting_create_popup_with_progressbar(ad, ad->win_get,
 508                                                  "pending_list",
 509                                                  NULL, NULL, NULL,
 510                                                  SETTING_MEMORY_STATUS_PROGRESSBAR_TIMEOUT, TRUE, TRUE);
 511
 512         int ret = -1;
 513         /* Does not mounted, same st_dev */
 514         if (mmc_status == 0) {
 515                 ret = __setting_memory_status_mmc_content_init(ad, setting_memory_status_ex_sd_card_mount_cb);
 516                 if (ret == SETTING_RETURN_FAIL) {
 517                         SETTING_TRACE_ERROR("__setting_memory_status_mmc_content_init fail");
 518                         if (ad->popup) {
 519                                 evas_object_del(ad->popup);
 520                                 ad->popup = NULL;
 521                         }
 522                         ad->popup = setting_create_popup_without_btn(ad, ad->win_get,
 523                                                  NULL, _("IDS_COM_POP_FAILED"),
 524                                                  NULL,
 525                                                  SETTING_MEMORY_POPUP_TIMER, FALSE, FALSE);
 526                         return;
 527                 }
 528                 ret = sysman_request_mount_mmc(ad->mmc_content);
 529                 if (ret == -1) {
 530                         SETTING_TRACE_ERROR("call sysman_request_mount_mmc fail");
 531                 }
 532         }
 533         /*  MMC mounted, diff st_dev */
 534         else {
 535                 ret = __setting_memory_status_mmc_content_init(ad, setting_memory_status_ex_sd_card_unmount_cb);
 536                 if (ret == SETTING_RETURN_FAIL) {
 537                         SETTING_TRACE_ERROR("__setting_memory_status_mmc_content_init fail");
 538                         if (ad->popup) {
 539                                 evas_object_del(ad->popup);
 540                                 ad->popup = NULL;
 541                         }
 542                         ad->popup = setting_create_popup_without_btn(ad, ad->win_get,
 543                                                  NULL, _("IDS_COM_POP_FAILED"),
 544                                                  NULL,
 545                                                  SETTING_MEMORY_POPUP_TIMER, FALSE, FALSE);
 546                         return;
 547                 }
 548
 549                 ret = sysman_request_unmount_mmc(ad->mmc_content,
 550                                                  MNT_FORCE);    /*  1 = MNT_FORCE */
 551                 if (ret == -1) {
 552                         SETTING_TRACE_ERROR("call sysman_request_unmount_mmc fail");
 553                 }
 554         }
 555
 556         /*  if fail, popup failed info */
 557         if (ret == -1) {
 558                 if (ad->popup) {
 559                         evas_object_del(ad->popup);
 560                         ad->popup = NULL;
 561                 }
 562                 ad->popup = setting_create_popup_without_btn(ad, ad->win_get,
 563                                                  NULL, _("IDS_COM_POP_FAILED"),
 564                                                  NULL,
 565                                                  SETTING_MEMORY_POPUP_TIMER, FALSE, FALSE);
 566         }
 567 }
 568
 569 static void
 570 setting_memory_status_ex_sd_card_refresh_card_details_cb(void *data,
 571                                                          Evas_Object *obj,
 572                                                          void *event_info)
 573 {
 574         SETTING_TRACE_BEGIN;
 575         setting_retm_if(data == NULL, "Data parameter is NULL");
 576         SettingMemoryUG *ad = (SettingMemoryUG *)data;
 577
 578         if (ad->popup) {
 579                 evas_object_del(ad->popup);
 580                 ad->popup = NULL;
 581         }
 582
 583         char ex_total_space[SETTING_MEMORY_MMC_MAX_MEM_STR_LEN] = {0, };
 584         char ex_available_space[SETTING_MEMORY_MMC_MAX_MEM_STR_LEN] = {0, };
 585         char ex_mount_status[SETTING_MEMORY_MMC_MAX_MEM_STR_LEN] = {0, };
 586         int ex_mmc_status = VCONFKEY_SYSMAN_MMC_REMOVED;
 587         setting_memory_status_ex_sd_card_info(ex_total_space, ex_available_space,
 588                                               ex_mount_status, &ex_mmc_status);
 589
 590         setting_memory_status_list_item_data_set(ad->data_ex_total, ex_total_space);
 591         setting_memory_status_list_item_data_set(ad->data_ex_available, ex_available_space);
 592         if(!isEmulBin())
 593         {
 594                 setting_memory_status_list_item_data_set(ad->data_ex_mount, ex_mount_status);
 595         }
 596         setting_memory_status_list_item_enable_set_by_mmc_status(ad, ex_mmc_status);
 597 }
 598
 599 static void
 600 setting_memory_status_ex_sd_card_operate_complete(void *data, char *desc,
 601                                                   bool popup_flag)
 602 {
 603         SETTING_TRACE_BEGIN;
 604         setting_retm_if(data == NULL, "Data parameter is NULL");
 605         SettingMemoryUG *ad = (SettingMemoryUG *) data;
 606         setting_memory_hide_popup_with_progress_bar(ad);
 607         if (popup_flag) {
 608                 if (ad->popup) {
 609                         evas_object_del(ad->popup);
 610                         ad->popup = NULL;
 611                 }
 612                 ad->popup = setting_create_popup_without_btn(ad, ad->win_get, NULL, desc,
 613                                                  setting_memory_status_ex_sd_card_refresh_card_details_cb,
 614                                                  SETTING_MEMORY_POPUP_TIMER, FALSE, FALSE);
 615         }
 616 }
 617
 618 static void
 619 setting_memory_status_list_item_enable_set_by_mmc_status(void *data,
 620                                                          int ex_mmc_status)
 621 {
 622         SETTING_TRACE_BEGIN;
 623         setting_retm_if(data == NULL, "Data parameter is NULL");
 624         SettingMemoryUG *ad = (SettingMemoryUG *) data;
 625
 626         if (ex_mmc_status == VCONFKEY_SYSMAN_MMC_REMOVED) {
 627                 setting_disable_genlist_item(ad->data_ex_total->item);
 628                 setting_disable_genlist_item(ad->data_ex_available->item);
 629                 if(!isEmulBin())
 630                 {
 631                         setting_disable_genlist_item(ad->data_ex_mount->item);
 632                         setting_disable_genlist_item(ad->data_ex_format->item);
 633                 }
 634         } else if (ex_mmc_status == VCONFKEY_SYSMAN_MMC_INSERTED_NOT_MOUNTED) {
 635                 setting_disable_genlist_item(ad->data_ex_total->item);
 636                 setting_disable_genlist_item(ad->data_ex_available->item);
 637                 if(!isEmulBin())
 638                 {
 639                         setting_enable_genlist_item(ad->data_ex_mount->item);
 640                         setting_disable_genlist_item(ad->data_ex_format->item);
 641                 }
 642         } else if (ex_mmc_status == VCONFKEY_SYSMAN_MMC_MOUNTED){
 643         } else {
 644                 SETTING_TRACE_DEBUG("abnormal status of MMC");
 645         }
 646 }
 647
 648 static void setting_memory_status_list_item_data_set(Setting_GenGroupItem_Data *
 649                                                      item_data, char *data)
 650 {
 651         SETTING_TRACE_BEGIN;
 652         setting_retm_if(item_data == NULL, "Data parameter is NULL");
 653
 654         G_FREE(item_data->keyStr);
 655         item_data->keyStr = (char *)g_strdup(data);
 656         elm_object_item_data_set(item_data->item, item_data);
 657         elm_genlist_item_update(item_data->item);
 658 }
 659
 660 static void
 661 setting_memory_status_get_phone_storage_available_size(void *data,
 662                                                        char *szAvail)
 663 {
 664         SETTING_TRACE_BEGIN;
 665         setting_retm_if(data == NULL, "Data parameter is NULL");
 666         //SettingMemoryUG *ad = (SettingMemoryUG *) data;
 667
 668         double dTotal = 0.0;
 669         double dAvail = 0.0;
 670         int ret = SETTING_RETURN_SUCCESS;
 671         setting_mem_status internal_mem_stat;
 672
 673         ret = __fs_stat(&dTotal, &dAvail, SETTING_MEMORY_STATUS_APP_PATH);
 674         setting_retm_if(ret == SETTING_RETURN_FAIL, "get app_mem stat failed");
 675         internal_mem_stat.dTotal = dTotal;
 676         internal_mem_stat.dAvail = dAvail;
 677
 678         dTotal = 0.0;
 679         dAvail = 0.0;
 680         ret = __fs_stat(&dTotal, &dAvail, SETTING_MEMORY_STATUS_MEDIA_PATH);
 681         setting_retm_if(ret == SETTING_RETURN_FAIL, "get media_mem stat failed");
 682         internal_mem_stat.dTotal += dTotal;
 683         internal_mem_stat.dAvail += dAvail;
 684
 685         ret = setting_memory_status_size_transition(internal_mem_stat.dAvail,
 686                                                   szAvail);
 687         setting_retm_if(ret == SETTING_RETURN_FAIL, "setting_memory_status_size_transition fail");
 688 }
 689
 690 static int
 691 setting_memory_status_size_transition(double size, char *size_desc)
 692 {
 693         SETTING_TRACE_BEGIN;
 694
 695         double tmp_size = 0.0;
 696         int ret = 0;
 697         if (size < SETTING_MEMORY_MEGABYTE_VALUE) {     // size < 1MB: show x.xKB
 698                 tmp_size = size / SETTING_MEMORY_KILOBYTE_VALUE;
 699                 ret = snprintf(size_desc, SETTING_MEMORY_MMC_MAX_MEM_STR_LEN, "%4.2lf%s", tmp_size, "KB");
 700                 retv_if(ret < 0, SETTING_RETURN_FAIL);
 701         } else if (size < SETTING_MEMORY_GIGABYTE_VALUE) {      // size < 1GB: show x.xMB
 702                 tmp_size = size / SETTING_MEMORY_MEGABYTE_VALUE;
 703                 ret = snprintf(size_desc, SETTING_MEMORY_MMC_MAX_MEM_STR_LEN, "%4.2lf%s", tmp_size, "MB");
 704                 retv_if(ret < 0, SETTING_RETURN_FAIL);
 705         } else { // 1G <= size: show x.xGB
 706                 tmp_size = size / SETTING_MEMORY_GIGABYTE_VALUE;
 707                 ret = snprintf(size_desc, SETTING_MEMORY_MMC_MAX_MEM_STR_LEN, "%4.2lf%s", tmp_size, "GB");
 708                 retv_if(ret < 0, SETTING_RETURN_FAIL);
 709         }
 710
 711         return SETTING_RETURN_SUCCESS;
 712 }
 713
 714 static void setting_memory_status_ex_sd_card_format_cb(int val, void *data)
 715 {
 716         SETTING_TRACE_BEGIN;
 717         setting_retm_if(data == NULL, "Data parameter is NULL");
 718         if (val == SETTING_MEMORY_STATUS_SYSMAN_REQUEST_SUCCESS) {
 719                 setting_memory_status_ex_sd_card_operate_complete(data,
 720                                                                   _("IDS_COM_POP_SUCCESS"),
 721                                                                   TRUE);
 722
 723         } else {
 724                 setting_memory_status_ex_sd_card_operate_complete(data,
 725                                                                   _("IDS_COM_POP_FAILED"),
 726                                                                   TRUE);
 727         }
 728 }
 729
 730 static void setting_memory_status_ex_sd_card_mount_cb(int val, void *data)
 731 {
 732         SETTING_TRACE_BEGIN;
 733         setting_retm_if(data == NULL, "Data parameter is NULL");
 734         if (val == SETTING_MEMORY_STATUS_SYSMAN_REQUEST_SUCCESS) {
 735                 setting_memory_status_ex_sd_card_operate_complete(data,
 736                                                                   _("IDS_COM_POP_SUCCESS"),
 737                                                                   FALSE);
 738         } else if (val == SETTING_MEMORY_STATUS_SYSMAN_REQUEST_MOUNT_ALREADY) {
 739                 setting_memory_status_ex_sd_card_operate_complete(data,
 740                                                                   _(SETTING_MEMORY_STATUS_EX_SD_CARD_MOUNT_ALREADY_DESC),
 741                                                                   TRUE);
 742         } else {
 743                 setting_memory_status_ex_sd_card_operate_complete(data,
 744                                                                   _("IDS_COM_POP_FAILED"),
 745                                                                   TRUE);
 746         }
 747 }
 748
 749 static void setting_memory_status_ex_sd_card_unmount_cb(int val, void *data)
 750 {
 751         SETTING_TRACE_BEGIN;
 752         setting_retm_if(data == NULL, "Data parameter is NULL");
 753         if (val == SETTING_MEMORY_STATUS_SYSMAN_REQUEST_SUCCESS) {
 754                 setting_memory_status_ex_sd_card_operate_complete(data,
 755                                                                   _("IDS_COM_POP_SUCCESS"),
 756                                                                   FALSE);
 757         } else {
 758                 setting_memory_status_ex_sd_card_operate_complete(data,
 759                                                                   _("IDS_COM_POP_FAILED"),
 760                                                                   TRUE);
 761         }
 762 }
 763
 764 static void __setting_memory_status_vconf_change_cb( keynode_t *key, void *data)
 765 {
 766         SETTING_TRACE_BEGIN;
 767         setting_retm_if(NULL == key, "key is NULL");
 768         setting_retm_if(NULL == data, "data is NULL");
 769         SettingMemoryUG *ad = (SettingMemoryUG *)data;
 770
 771         int status = vconf_keynode_get_int(key);
 772         char *vconf_name = vconf_keynode_get_name(key);
 773
 774         if (!safeStrCmp(vconf_name, VCONFKEY_SYSMAN_MMC_STATUS)) {
 775                 SETTING_TRACE("status:%d", status);
 776                 setting_memory_status_ex_sd_card_refresh_card_details_cb(ad,
 777                                                         NULL,
 778                                                         NULL);
 779         } else {
 780                 SETTING_TRACE_ERROR("vconf_name is NULL");
 781         }
 782 }
 783
 784 static int __setting_memory_status_check_mmc_status()
 785 {
 786         int ret = 0;
 787         struct stat parent_stat, mount_stat;
 788
 789         ret = stat(SETTING_MEMORY_STATUS_MMC_PATH, &mount_stat);
 790         setting_retvm_if(ret != 0, -1, "get stat error : /opt/storage/sdcard");
 791
 792         ret = stat(SETTING_MEMORY_STATUS_MMC_PARENT_PATH, &parent_stat);
 793         setting_retvm_if(ret != 0, -1, "get stat error : /opt/storage/sdcard/..");
 794
 795         /* Does not mounted, same st_dev */
 796         if(mount_stat.st_dev == parent_stat.st_dev)
 797         {
 798                 return 0;
 799         }
 800         /* MMC mounted, diff st_dev */
 801         else
 802         {
 803                 return 1;
 804         }
 805 }
 806
 807 static int __setting_memory_status_mmc_content_init(void *data, setting_memory_mmc_cb cb)
 808 {
 809         SETTING_TRACE_BEGIN;
 810         setting_retvm_if(NULL == data, SETTING_RETURN_FAIL, "data is NULL");
 811         setting_retvm_if(NULL == cb, SETTING_RETURN_FAIL, "cb is NULL");
 812         SettingMemoryUG *ad = (SettingMemoryUG *)data;
 813         if (ad->mmc_content == NULL) {
 814                 ad->mmc_content = (struct mmc_contents *)calloc(1, sizeof(struct mmc_contents));
 815                 if (ad->mmc_content == NULL ) {
 816                         SETTING_TRACE_ERROR("calloc failed");
 817                         return SETTING_RETURN_FAIL;
 818                 }
 819         }
 820         ad->mmc_content->mmc_cb = cb;
 821         ad->mmc_content->user_data = ad;
 822         return SETTING_RETURN_SUCCESS;
 823 }