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

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