setting-storage/src/setting-storage-main.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-storage-main.h>
  22 #include <Ecore_X.h>
  23 #include <package-manager.h>
  24 #include <ail.h>
  25 #include <media_content.h>
  26
  27 static int setting_storage_main_create(void *cb);
  28 static int setting_storage_main_destroy(void *cb);
  29 static int setting_storage_main_update(void *cb);
  30 static int setting_storage_main_cleanup(void *cb);
  31
  32 static void __setting_storage_main_click_softkey_back_cb(void *data, Evas_Object *obj,
  33                                         void *event_info);
  34
  35 setting_view setting_view_storage_main = {
  36         .create = setting_storage_main_create,
  37         .destroy = setting_storage_main_destroy,
  38         .update = setting_storage_main_update,
  39         .cleanup = setting_storage_main_cleanup,
  40 };
  41
  42 static char *__gl_text_get(void *data, Evas_Object *obj, const char *part)
  43 {
  44         retv_if(!data, NULL);
  45         Setting_GenGroupItem_Data *item_data = data;
  46
  47         if (!safeStrCmp(part, "elm.text.1")) {
  48                 return (char *)g_strdup(item_data->keyStr);
  49         }
  50         return NULL;
  51 }
  52
  53 static Evas_Object *__gl_content_get(void *data, Evas_Object *obj, const char *part)
  54 {
  55         retv_if(!data, NULL);
  56         Setting_GenGroupItem_Data *item_data = data;
  57         SettingStorageUG *ad = (SettingStorageUG *) item_data->userdata;
  58
  59         int width = SETTING_STORAGE_ICON_WIDTH;
  60         int height = SETTING_STORAGE_ICON_HEIGHT;
  61         float temp_size = 0.0;
  62
  63         if (!safeStrCmp(part, "elm.icon")){
  64                 Evas_Object *status_box = NULL;
  65                 status_box = elm_box_add(obj);
  66                 retvm_if(status_box == NULL, NULL, "Cannot get box");
  67                 elm_box_horizontal_set(status_box, 1);
  68                 evas_object_size_hint_align_set(status_box, 0.0, EVAS_HINT_FILL);
  69                 evas_object_show(status_box);
  70
  71                 Evas *evas = evas_object_evas_get(obj);
  72
  73                 /* apps */
  74                 unsigned int apps_size = 0;
  75                 temp_size = ((float)ad->apps_status.dTotal / ad->internal_status.dTotal) * width;
  76                 if (temp_size < 1 && temp_size > 0) {
  77                         apps_size = 1;
  78                 } else {
  79                         apps_size = (unsigned int)temp_size;
  80                 }
  81                 if (apps_size > 0) {
  82                         Evas_Object *apps = NULL;
  83                         apps = evas_object_image_add(evas);
  84                         evas_object_size_hint_weight_set(apps, 0.0, EVAS_HINT_EXPAND);
  85                         evas_object_image_load_size_set(apps, apps_size, height);
  86                         evas_object_image_file_set(apps, SETTING_STORAGE_APPS_ICON_PATH, NULL);
  87                         evas_object_image_fill_set(apps, 0, 0, apps_size, height);
  88                         evas_object_size_hint_min_set(apps, apps_size, height);
  89                         evas_object_show(apps);
  90                         elm_box_pack_end(status_box, apps);
  91                 }
  92
  93                 /* pictures, videos */
  94                 unsigned int pics_videos_size = 0;
  95                 temp_size = ((float)ad->pics_videos_status.dTotal / ad->internal_status.dTotal) * width;
  96                 if (temp_size < 1 && temp_size > 0) {
  97                         pics_videos_size = 1;
  98                 } else {
  99                         pics_videos_size = (unsigned int)temp_size;
 100                 }
 101                 if (pics_videos_size > 0) {
 102                         Evas_Object *pics = NULL;
 103                         pics = evas_object_image_add(evas);
 104                         evas_object_size_hint_weight_set(pics, 0.0, EVAS_HINT_EXPAND);
 105                         evas_object_image_load_size_set(pics, pics_videos_size, height);
 106                         evas_object_image_file_set(pics, SETTING_STORAGE_PICS_ICON_PATH, NULL);
 107                         evas_object_image_fill_set(pics, 0, 0, pics_videos_size, height);
 108                         evas_object_size_hint_min_set(pics, pics_videos_size, height);
 109                         evas_object_show(pics);
 110                         elm_box_pack_end(status_box, pics);
 111                 }
 112
 113                 /* downloads */
 114                 unsigned int downloads_size = 0;
 115                 temp_size = ((float)ad->downloads_status.dTotal / ad->internal_status.dTotal) * width;
 116                 if (temp_size < 1 && temp_size > 0) {
 117                         downloads_size = 1;
 118                 } else {
 119                         downloads_size = (unsigned int)temp_size;
 120                 }
 121                 if (downloads_size > 0) {
 122                         Evas_Object *downs = NULL;
 123                         downs = evas_object_image_add(evas);
 124                         evas_object_size_hint_weight_set(downs, 0.0, EVAS_HINT_EXPAND);
 125                         evas_object_image_load_size_set(downs, downloads_size, height);
 126                         evas_object_image_file_set(downs, SETTING_STORAGE_DOWNS_ICON_PATH, NULL);
 127                         evas_object_image_fill_set(downs, 0, 0, downloads_size, height);
 128                         evas_object_size_hint_min_set(downs, downloads_size, height);
 129                         evas_object_show(downs);
 130                         elm_box_pack_end(status_box, downs);
 131                 }
 132
 133                 /* audio */
 134                 unsigned int audio_size = 0;
 135                 temp_size = ((float)ad->audio_status.dTotal / ad->internal_status.dTotal) * width;
 136                 if (temp_size < 1 && temp_size > 0) {
 137                         audio_size = 1;
 138                 } else {
 139                         audio_size = (unsigned int)temp_size;
 140                 }
 141                 if (audio_size > 0) {
 142                         Evas_Object *audio = NULL;
 143                         audio = evas_object_image_add(evas);
 144                         evas_object_size_hint_weight_set(audio, 0.0, EVAS_HINT_EXPAND);
 145                         evas_object_image_load_size_set(audio, audio_size, height);
 146                         evas_object_image_file_set(audio, SETTING_STORAGE_AUDIO_ICON_PATH, NULL);
 147                         evas_object_image_fill_set(audio, 0, 0, audio_size, height);
 148                         evas_object_size_hint_min_set(audio, audio_size, height);
 149                         evas_object_show(audio);
 150                         elm_box_pack_end(status_box, audio);
 151                 }
 152
 153                 /* Miscellaneous files */
 154                 unsigned int others_size = 0;
 155                 temp_size = ((float)ad->others_status.dTotal / ad->internal_status.dTotal) * width;
 156                 if (temp_size < 1 && temp_size > 0) {
 157                         others_size = 1;
 158                 } else {
 159                         others_size = (unsigned int)temp_size;
 160                 }
 161                 if (others_size > 0) {
 162                         Evas_Object *misc = NULL;
 163                         misc = evas_object_image_add(evas);
 164                         evas_object_size_hint_weight_set(misc, 0.0, EVAS_HINT_EXPAND);
 165                         evas_object_image_load_size_set(misc, others_size, height);
 166                         evas_object_image_file_set(misc, SETTING_STORAGE_MISCES_ICON_PATH, NULL);
 167                         evas_object_image_fill_set(misc, 0, 0, others_size, height);
 168                         evas_object_size_hint_min_set(misc, others_size, height);
 169                         evas_object_show(misc);
 170                         elm_box_pack_end(status_box, misc);
 171                 }
 172
 173                 /* available */
 174                 unsigned int avail_size = 0;
 175                 temp_size = ((float)ad->internal_status.dAvail / ad->internal_status.dTotal) * width;
 176                 if (temp_size < 1 && temp_size > 0) {
 177                         avail_size = 1;
 178                 } else {
 179                         avail_size = (unsigned int)temp_size;
 180                 }
 181                 if (avail_size > 0) {
 182                         Evas_Object *avail = NULL;
 183                         avail = evas_object_image_add(evas);
 184                         evas_object_size_hint_weight_set(avail, 0.0, EVAS_HINT_EXPAND);
 185                         evas_object_image_load_size_set(avail, avail_size, height);
 186                         evas_object_image_file_set(avail, SETTING_STORAGE_AVAIL_ICON_PATH, NULL);
 187                         evas_object_image_fill_set(avail, 0, 0, avail_size, height);
 188                         evas_object_size_hint_min_set(avail, avail_size, height);
 189                         evas_object_show(avail);
 190                         elm_box_pack_end(status_box, avail);
 191                 }
 192
 193                 return status_box;
 194         }
 195         return NULL;
 196 }
 197
 198 static void __gl_del(void *data, Evas_Object *obj)
 199 {
 200         /* SETTING_TRACE_BEGIN; */
 201         Setting_GenGroupItem_Data *item_data = (Setting_GenGroupItem_Data *) data;
 202         if (item_data) {
 203                 G_FREE(item_data->keyStr);
 204                 FREE(item_data);
 205         }
 206 }
 207
 208 static int __setting_storage_main_fs_stat(double *total, double *avail, const char *path)
 209 {
 210         SETTING_TRACE_BEGIN;
 211         setting_retvm_if(NULL == total || NULL == avail, SETTING_RETURN_FAIL, "Null output parameters");
 212
 213         struct statvfs s;
 214
 215         if (!statvfs(path, &s)) {
 216                 SETTING_TRACE("f_bsize = %ld f_blocks = %ld f_bavail = %ld f_frsize = %ld",
 217                      s.f_bsize, s.f_blocks, s.f_bavail, s.f_frsize);
 218                 *total = (double)s.f_frsize * s.f_blocks;
 219                 *avail = (double)s.f_bsize * s.f_bavail;
 220         } else {
 221                 return SETTING_RETURN_FAIL;
 222         }
 223
 224         return SETTING_RETURN_SUCCESS;
 225 }
 226
 227 static long __setting_storage_main_folder_size_get(char *path)
 228 {
 229         SETTING_TRACE_BEGIN;
 230         setting_retvm_if(NULL == path, SETTING_RETURN_FAIL, "path is NULL");
 231
 232         unsigned long size = 0;
 233         Eina_List *file_list = NULL;
 234         Eina_List *dir_list = NULL;
 235
 236         if (ecore_file_is_dir(path)) {
 237                 int ret = SETTING_RETURN_FAIL;
 238                 ret = setting_storage_file_list_get(path, &dir_list, &file_list);
 239
 240                 if (ret == SETTING_RETURN_SUCCESS) {
 241                         int i = 0;
 242                         int dir_list_len =  setting_storage_list_len_get(dir_list);
 243                         int file_list_len = setting_storage_list_len_get(file_list);
 244                         SETTING_TRACE("dir_list_len is [%d] file_list_len is [%d]", dir_list_len, file_list_len);
 245                         for (i = 0; i < file_list_len; i++) {
 246                                 Node_Info *pNode = NULL;
 247                                 pNode = (Node_Info *)eina_list_nth(file_list, i);
 248                                 if (pNode == NULL)
 249                                         continue;
 250                                 size += pNode->size;
 251                         }
 252                         for (i = 0; i < dir_list_len; i++) {
 253                                 Node_Info *pNode = NULL;
 254                                 char *full_path = NULL;
 255                                 pNode = (Node_Info *)eina_list_nth(dir_list, i);
 256                                 if (pNode == NULL)
 257                                         continue;
 258                                 full_path =  g_strconcat(pNode->path, "/", pNode->name, NULL);
 259                                 SETTING_TRACE("full_path is [%s]", full_path);
 260                                 size += (__setting_storage_main_folder_size_get(full_path));
 261                                 FREE(full_path);
 262                         }
 263                 }
 264         }
 265
 266         if (file_list) {
 267                 eina_list_free(file_list);
 268                 file_list = NULL;
 269         }
 270
 271         if (dir_list) {
 272                 eina_list_free(dir_list);
 273                 dir_list = NULL;
 274         }
 275
 276         return size;
 277 }
 278
 279 static int __setting_storage_status_size_transition(double size, char *size_desc)
 280 {
 281         SETTING_TRACE_BEGIN;
 282         SETTING_TRACE("size = %f", size);
 283         double tmp_size = 0.0;
 284         int ret = 0;
 285         if (size < SETTING_STORAGE_MEGABYTE_VALUE) {    // size < 1MB: show x.xKB
 286                 tmp_size = size / SETTING_STORAGE_KILOBYTE_VALUE;
 287                 ret = snprintf(size_desc, SETTING_STORAGE_MAX_STR_LEN, "%4.2lf%s", tmp_size, "KB");
 288                 retv_if(ret < 0, SETTING_RETURN_FAIL);
 289         } else if (size < SETTING_STORAGE_GIGABYTE_VALUE) {     // size < 1GB: show x.xMB
 290                 tmp_size = size / SETTING_STORAGE_MEGABYTE_VALUE;
 291                 ret = snprintf(size_desc, SETTING_STORAGE_MAX_STR_LEN, "%4.2lf%s", tmp_size, "MB");
 292                 retv_if(ret < 0, SETTING_RETURN_FAIL);
 293         } else { // 1G <= size: show x.xGB
 294                 tmp_size = size / SETTING_STORAGE_GIGABYTE_VALUE;
 295                 ret = snprintf(size_desc, SETTING_STORAGE_MAX_STR_LEN, "%4.2lf%s", tmp_size, "GB");
 296                 retv_if(ret < 0, SETTING_RETURN_FAIL);
 297         }
 298
 299         return SETTING_RETURN_SUCCESS;
 300 }
 301
 302
 303 static void __setting_storage_main_internal_storage_status_get(void *data)
 304 {
 305         SETTING_TRACE_BEGIN;
 306         setting_retm_if(data == NULL, "Data parameter is NULL");
 307         SettingStorageUG *ad = (SettingStorageUG *) data;
 308
 309         double dTotal = 0.0;
 310         double dAvail = 0.0;
 311         int ret = SETTING_RETURN_SUCCESS;
 312         Setting_Storage_Status internal_status;
 313
 314         ret = __setting_storage_main_fs_stat(&dTotal, &dAvail, SETTING_STORAGE_OPT_PATH);
 315         setting_retm_if(ret == SETTING_RETURN_FAIL, "get opt status failed");
 316         internal_status.dTotal = dTotal;
 317         internal_status.dAvail = dAvail;
 318
 319         dTotal = 0.0;
 320         dAvail = 0.0;
 321         ret = __setting_storage_main_fs_stat(&dTotal, &dAvail, SETTING_STORAGE_MEDIA_PATH);
 322         setting_retm_if(ret == SETTING_RETURN_FAIL, "get media status failed");
 323
 324         internal_status.dTotal += dTotal;
 325         internal_status.dAvail += dAvail;
 326
 327         ad->internal_status = internal_status;
 328 }
 329
 330 static void __setting_storage_main_pictures_videos_status_get(void *data)
 331 {
 332         SETTING_TRACE_BEGIN;
 333         setting_retm_if(data == NULL, "Data parameter is NULL");
 334         SettingStorageUG *ad = (SettingStorageUG *) data;
 335
 336         double dTotal = 0.0;
 337         int ret = SETTING_RETURN_SUCCESS;
 338         Setting_Storage_Status pics_videos_status;
 339
 340         dTotal = __setting_storage_main_folder_size_get(SETTING_STORAGE_PICTURES_PATH);
 341         setting_retm_if(ret == SETTING_RETURN_FAIL, "get pictures status failed");
 342         pics_videos_status.dTotal = dTotal;
 343         //SETTING_TRACE("pics_videos_status = %f", dTotal);
 344
 345         dTotal = 0.0;
 346         dTotal = __setting_storage_main_folder_size_get(SETTING_STORAGE_VIDEOS_PATH);
 347         setting_retm_if(ret == SETTING_RETURN_FAIL, "get video status failed");
 348         //SETTING_TRACE("pics_videos_status = %f", dTotal);
 349         pics_videos_status.dTotal += dTotal;
 350
 351         //SETTING_TRACE("pics_videos_status = %f", pics_videos_status.dTotal);
 352
 353         ad->pics_videos_status = pics_videos_status;
 354 }
 355
 356 static void __setting_storage_main_downloads_status_get(void *data)
 357 {
 358         SETTING_TRACE_BEGIN;
 359         setting_retm_if(data == NULL, "Data parameter is NULL");
 360         SettingStorageUG *ad = (SettingStorageUG *) data;
 361
 362         double dTotal = 0.0;
 363         int ret = SETTING_RETURN_SUCCESS;
 364         Setting_Storage_Status downloads_status;
 365
 366         dTotal = __setting_storage_main_folder_size_get(SETTING_STORAGE_DOWNLOADS_PATH);
 367         setting_retm_if(ret == SETTING_RETURN_FAIL, "get pictures status failed");
 368         downloads_status.dTotal = dTotal;
 369
 370         //SETTING_TRACE("downloads_status = %f", dTotal);
 371
 372         ad->downloads_status = downloads_status;
 373 }
 374
 375 static bool __setting_storage_main_media_item_cb(media_info_h media, void *data)
 376 {
 377         SETTING_TRACE_BEGIN;
 378         setting_retvm_if(media == NULL, true, "media is NULL");
 379         setting_retvm_if(data == NULL, true, "Data parameter is NULL");
 380         SettingStorageUG *ad = (SettingStorageUG *) data;
 381
 382         media_content_type_e media_type = 0;
 383         unsigned long long size = 0;
 384
 385         media_info_get_media_type(media, &media_type);
 386         //SETTING_TRACE("media_type : [%d]", media_type);
 387
 388         if(media_type == MEDIA_CONTENT_TYPE_MUSIC) {
 389                 SETTING_TRACE("MEDIA_CONTENT_TYPE_MUSIC");
 390
 391                 media_info_get_size(media, &size);
 392                 //SETTING_TRACE("size : [%lld]", size);
 393                 ad->audio_status.dTotal += size;
 394         } else {
 395                 SETTING_TRACE("Other Content");
 396         }
 397
 398         return true;
 399 }
 400
 401 static void __setting_storage_main_audio_status_get(void *data)
 402 {
 403         SETTING_TRACE_BEGIN;
 404         setting_retm_if(data == NULL, "Data parameter is NULL");
 405         SettingStorageUG *ad = (SettingStorageUG *) data;
 406
 407         ad->audio_status.dTotal = 0;
 408
 409         int ret = MEDIA_CONTENT_ERROR_NONE;
 410         filter_h filter = NULL;
 411
 412         /*Set Filter*/
 413         char *condition = "MEDIA_TYPE=3";       /*0-image, 1-video, 2-sound, 3-music, 4-other*/
 414
 415         ret = media_filter_create(&filter);
 416         if(ret != MEDIA_CONTENT_ERROR_NONE) {
 417                 SETTING_TRACE("Fail to create filter");
 418                 return;
 419         }
 420
 421         ret = media_filter_set_condition(filter, condition, MEDIA_CONTENT_COLLATE_DEFAULT);
 422         if(ret != MEDIA_CONTENT_ERROR_NONE) {
 423                 media_filter_destroy(filter);
 424                 SETTING_TRACE("Fail to set condition");
 425                 return;
 426         }
 427
 428         ret = media_filter_set_order(filter, MEDIA_CONTENT_ORDER_ASC, MEDIA_TITLE, MEDIA_CONTENT_COLLATE_NOCASE);
 429         if(ret != MEDIA_CONTENT_ERROR_NONE) {
 430                 media_filter_destroy(filter);
 431                 SETTING_TRACE("Fail to set order");
 432                 return;
 433         }
 434
 435         ret = media_info_foreach_media_from_db(filter, __setting_storage_main_media_item_cb, ad);
 436         if(ret != MEDIA_CONTENT_ERROR_NONE) {
 437                 media_filter_destroy(filter);
 438                 SETTING_TRACE("Fail to get media");
 439                 return;
 440         }
 441 }
 442
 443 static int __setting_storage_main_miscellaneous_list_get(char *path, Eina_List **dir_list, Eina_List **file_list)
 444 {
 445         SETTING_TRACE_BEGIN;
 446         setting_retvm_if(NULL == path, SETTING_RETURN_FAIL, "path is NULL");
 447
 448         DIR *pDir = NULL;
 449         struct dirent *ent = NULL;
 450         char childpath[SETTING_STORAGE_CHILDPATH_LEN] = {0,};
 451
 452         pDir = opendir(path);
 453         setting_retvm_if(NULL == pDir, SETTING_RETURN_FAIL, "pDir is NULL");
 454
 455         while ((ent = readdir(pDir)) != NULL) {
 456                 if (safeStrCmp(ent->d_name, ".") == 0
 457                         || safeStrCmp(ent->d_name, "..") == 0
 458                         || safeStrCmp(ent->d_name, ".tmp_download") == 0
 459                         || safeStrCmp(ent->d_name, ".video-hub") == 0
 460                         || safeStrCmp(ent->d_name, "Camera") == 0
 461                         || safeStrCmp(ent->d_name, "Downloads") == 0
 462                         || safeStrCmp(ent->d_name, "Images") == 0
 463                         || safeStrCmp(ent->d_name, "Others") == 0
 464                         || safeStrCmp(ent->d_name, "Sounds") == 0
 465                         || safeStrCmp(ent->d_name, "Videos") == 0
 466                         || safeStrCmp(ent->d_name, "lost+found") == 0) {
 467                         continue;
 468                 }
 469                 /*only deal with dirs and regular files*/
 470                 if ((ent->d_type & DT_DIR) == 0 && (ent->d_type & DT_REG) == 0) {
 471                         continue;
 472                 }
 473
 474                 Node_Info *pNode = (Node_Info *)malloc(sizeof(Node_Info));
 475
 476                 if (pNode == NULL) {
 477                         continue;
 478                 }
 479
 480                 memset(pNode, 0, sizeof(Node_Info));
 481                 /*get path*/
 482                 g_strlcpy(pNode->path, path, (gsize) sizeof(pNode->path));
 483
 484                 /*get name*/
 485                 g_strlcpy(pNode->name, ent->d_name, (gsize) sizeof(pNode->name));
 486
 487                 /*get size*/
 488                 int copiednum = g_sprintf(childpath, "%s/%s", path, ent->d_name);
 489                 if (copiednum < 0) {
 490                         FREE(pNode);
 491                         continue;
 492                 }
 493                 if (setting_storage_file_stat_get(childpath, &pNode) == SETTING_RETURN_FAIL) {
 494                         FREE(pNode);
 495                         continue;
 496                 }
 497
 498                 if (ent->d_type & DT_DIR) {
 499                         *dir_list = eina_list_append(*dir_list, pNode);
 500                 } else {
 501                         *file_list = eina_list_append(*file_list, pNode);
 502                 }
 503         }
 504         closedir(pDir);
 505
 506         return SETTING_RETURN_SUCCESS;
 507 }
 508
 509 /**
 510   * Miscellaneous files is all directories files under /opt/media/ except below default directories:
 511   * ++++++++++++++++++++++++++++++++++++++++++++++++
 512   *  -sh-4.1# ls -all
 513   *  total 56
 514   *  drwxrwxrwx 11 app  app   4096 Jan  4 12:42 .
 515   *  drwxr-xr-x 20 root root  4096 Jan  7 10:09 ..
 516   *  drwxr-xr-x  2 root root  4096 Jan  4 08:46 .tmp_download
 517   *  drwxr-xr-x  2 app  app   4096 Jan  4 08:47 .video-hub
 518   *  drwxrwxrwx  2 app  app   4096 Oct  5       2012 Camera
 519   *  drwxrwxrwx  3 app  app   4096 Jan  4 08:46 Downloads
 520   *  drwxrwxrwx  2 app  app   4096 Oct  5       2012 Images
 521   *  drwxrwxrwx  2 app  app   4096 Oct  5       2012 Others
 522   *  drwxrwxrwx  3 app  app   4096 Oct  5       2012 Sounds
 523   *  drwxrwxrwx  2 app  app   4096 Oct  5       2012 Videos
 524   *  drwxrwxrwx  2 app  app  16384 Oct  5       2012 lost+found
 525   * ++++++++++++++++++++++++++++++++++++++++++++++++
 526   */
 527 static void __setting_storage_main_miscellaneous_size_get(void *data)
 528 {
 529         SETTING_TRACE_BEGIN;
 530         setting_retm_if(data == NULL, "Data parameter is NULL");
 531         SettingStorageUG *ad = (SettingStorageUG *) data;
 532
 533         unsigned long size = 0;
 534         Eina_List *file_list = NULL;
 535         Eina_List *dir_list = NULL;
 536
 537         char *path = SETTING_STORAGE_MEDIA_PATH;
 538
 539         if (ecore_file_is_dir(path)) {
 540                 int ret = SETTING_RETURN_FAIL;
 541                 ret = __setting_storage_main_miscellaneous_list_get(path, &dir_list, &file_list);
 542
 543                 if (ret == SETTING_RETURN_SUCCESS) {
 544                         int i = 0;
 545                         int dir_list_len =  setting_storage_list_len_get(dir_list);
 546                         int file_list_len = setting_storage_list_len_get(file_list);
 547                         SETTING_TRACE("dir_list_len is [%d] file_list_len is [%d]", dir_list_len, file_list_len);
 548                         for (i = 0; i < file_list_len; i++) {
 549                                 Node_Info *pNode = NULL;
 550                                 pNode = (Node_Info *)eina_list_nth(file_list, i);
 551                                 if (pNode == NULL)
 552                                         continue;
 553                                 size += pNode->size;
 554                                 SETTING_TRACE("path is [%s], name is [%s]", pNode->path, pNode->name);
 555                         }
 556                         for (i = 0; i < dir_list_len; i++) {
 557                                 Node_Info *pNode = NULL;
 558                                 char *full_path = NULL;
 559                                 pNode = (Node_Info *)eina_list_nth(dir_list, i);
 560                                 if (pNode == NULL)
 561                                         continue;
 562                                 full_path =  g_strconcat(pNode->path, "/", pNode->name, NULL);
 563                                 SETTING_TRACE("full_path is [%s]", full_path);
 564                                 size += (__setting_storage_main_folder_size_get(full_path));
 565                                 FREE(full_path);
 566                         }
 567                 }
 568         }
 569
 570         if (file_list) {
 571                 eina_list_free(file_list);
 572                 file_list = NULL;
 573         }
 574
 575         if (dir_list) {
 576                 eina_list_free(dir_list);
 577                 dir_list = NULL;
 578         }
 579
 580         ad->others_status.dTotal = size;
 581 }
 582
 583 static void __setting_storage_main_apps_list_free(void *data)
 584 {
 585         setting_retm_if(data == NULL, "Data parameter is NULL");
 586         SettingStorageUG *ad = (SettingStorageUG *) data;
 587
 588         Eina_List *l = NULL;
 589         App_Info *app_info;
 590         EINA_LIST_FOREACH (ad->apps_list, l, app_info)
 591         {
 592                 G_FREE(app_info->pkg_name);
 593                 G_FREE(app_info->pkg_type);
 594                 FREE(app_info);
 595         }
 596         eina_list_free(ad->apps_list);
 597         ad->apps_list = NULL;
 598 }
 599
 600 static ail_cb_ret_e __setting_storage_main_appinfo_func_cb(const ail_appinfo_h ail_info, void *data)
 601 {
 602         setting_retvm_if(data == NULL, AIL_CB_RET_CONTINUE, "Data parameter is NULL");
 603         SettingStorageUG *ad = (SettingStorageUG *) data;
 604
 605         char *pkg_name = NULL;
 606         char *pkg_type = NULL;
 607
 608         ail_appinfo_get_str(ail_info, AIL_PROP_PACKAGE_STR, &pkg_name);
 609         setting_retvm_if(pkg_name == NULL, AIL_CB_RET_CONTINUE, "get pkg_name failed");
 610
 611         ail_appinfo_get_str(ail_info, AIL_PROP_X_SLP_PACKAGETYPE_STR, &pkg_type);
 612         setting_retvm_if(pkg_type == NULL, AIL_CB_RET_CONTINUE, "get pkg_type failed");
 613
 614         App_Info *app_info = (App_Info*)calloc(1, sizeof(App_Info));
 615         setting_retvm_if(app_info == NULL, AIL_CB_RET_CONTINUE, "failed to calloc");
 616
 617         app_info->pkg_name = (char *)g_strdup(pkg_name);
 618         app_info->pkg_type = (char *)g_strdup(pkg_type);
 619         ad->apps_list = eina_list_append(ad->apps_list, app_info);
 620         return AIL_CB_RET_CONTINUE;
 621 }
 622
 623 static void __setting_storage_main_applications_list_get(void *data)
 624 {
 625         SETTING_TRACE_BEGIN;
 626         setting_retm_if(data == NULL, "Data parameter is NULL");
 627         SettingStorageUG *ad = (SettingStorageUG *) data;
 628
 629         __setting_storage_main_apps_list_free(ad);
 630
 631         /* get app_info from AIL */
 632         ail_filter_h filter_rpm = NULL;
 633         ail_filter_h filter_wrt = NULL;
 634         ail_filter_h filter_tpk = NULL;
 635
 636         ail_filter_new(&filter_rpm);
 637         ail_filter_new(&filter_wrt);
 638         ail_filter_new(&filter_tpk);
 639
 640         ail_filter_add_str(filter_rpm, AIL_PROP_X_SLP_PACKAGETYPE_STR, RPM_PREFIX);
 641         ail_filter_add_str(filter_wrt, AIL_PROP_X_SLP_PACKAGETYPE_STR, WRT_PREFIX);
 642         ail_filter_add_str(filter_tpk, AIL_PROP_X_SLP_PACKAGETYPE_STR, TPK_PREFIX);
 643
 644         ail_filter_list_appinfo_foreach(filter_rpm, __setting_storage_main_appinfo_func_cb, (void*)ad);
 645         ail_filter_list_appinfo_foreach(filter_wrt, __setting_storage_main_appinfo_func_cb, (void*)ad);
 646         ail_filter_list_appinfo_foreach(filter_tpk, __setting_storage_main_appinfo_func_cb, (void*)ad);
 647
 648         ail_filter_destroy(filter_rpm);
 649         ail_filter_destroy(filter_wrt);
 650         ail_filter_destroy(filter_tpk);
 651 }
 652
 653 static void __setting_storage_main_applications_status_get(void *data)
 654 {
 655         SETTING_TRACE_BEGIN;
 656         setting_retm_if(data == NULL, "Data parameter is NULL");
 657         SettingStorageUG *ad = (SettingStorageUG *) data;
 658
 659         __setting_storage_main_applications_list_get(ad);
 660
 661         ad->apps_status.dTotal = 0;
 662
 663         Eina_List *l = NULL;
 664         App_Info *app_info;
 665         EINA_LIST_FOREACH (ad->apps_list, l, app_info)
 666         {
 667                 //SETTING_TRACE("pkg_name: %s ", app_info->pkg_name);
 668                 //SETTING_TRACE("pkg_type: %s", app_info->pkg_type);
 669                 pkgmgr_info *pkg_info = pkgmgr_info_new(app_info->pkg_type, app_info->pkg_name);
 670                 if (!pkg_info) {
 671                         SETTING_TRACE("pkg_info is null, couldn't get the sizes");
 672                         app_info->total_size = 0;
 673                 } else {
 674                         char *buf = NULL;
 675                         buf = pkgmgr_info_get_string(pkg_info, STR_INSTALLED_SIZE);
 676                         if (buf) {
 677                                 //SETTING_TRACE("size : %s", buf);
 678                                 app_info->total_size = atoi(buf);
 679                                 G_FREE(buf);
 680                         } else {
 681                                 app_info->total_size = 0;
 682                         }
 683                         pkgmgr_info_free(pkg_info);
 684                 }
 685
 686                 ad->apps_status.dTotal += app_info->total_size;
 687         }
 688
 689         char apps_desc[SETTING_STORAGE_MAX_STR_LEN + 1] = {0,};
 690         int ret = __setting_storage_status_size_transition(ad->apps_status.dTotal, apps_desc);
 691         setting_retm_if(ret == SETTING_RETURN_FAIL, "failed to transform");
 692
 693         G_FREE(ad->apps->sub_desc);
 694         ad->apps->sub_desc = (char *)g_strdup(apps_desc);
 695         elm_object_item_data_set(ad->apps->item, ad->apps);
 696         elm_genlist_item_update(ad->apps->item);
 697
 698         elm_object_item_data_set(ad->internal->item, ad->internal);
 699         elm_genlist_item_update(ad->internal->item);
 700
 701         if (ad->pop_progress) {
 702                 evas_object_del(ad->pop_progress);
 703                 ad->pop_progress = NULL;
 704         }
 705 }
 706
 707 static Eina_Bool __setting_storage_main_timer_cb(void *data)
 708 {
 709         SETTING_TRACE_BEGIN;
 710         setting_retvm_if(data == NULL, ECORE_CALLBACK_CANCEL, "data is NULL");
 711         SettingStorageUG *ad = (SettingStorageUG *)data;
 712
 713         __setting_storage_main_applications_status_get(ad);
 714         return ECORE_CALLBACK_CANCEL;
 715 }
 716
 717 static void __setting_storage_main_launch_ug_destroy_cb(ui_gadget_h ug, void *priv)
 718 {
 719         SETTING_TRACE_BEGIN;
 720         /* restore the '<-' button on the navigate bar */
 721         retm_if(priv == NULL, "priv is NULL");
 722         SettingStorageUG *ad = (SettingStorageUG *) priv;
 723         if (ug) {
 724                 ug_destroy(ug);
 725         }
 726         Elm_Object_Item *navi_it = elm_naviframe_top_item_get(ad->navibar);
 727         retm_if(navi_it == NULL, "navi_it is NULL");
 728         Evas_Object *back_btn = elm_object_item_part_content_get(navi_it, "prev_btn");
 729
 730         if (back_btn != NULL) {
 731                 elm_object_style_set(back_btn, NAVI_BACK_BUTTON_STYLE); /* take into effect */
 732         }
 733
 734         if (ad->pop_progress) {
 735                 evas_object_del(ad->pop_progress);
 736                 ad->pop_progress = NULL;
 737         }
 738         ad->pop_progress = setting_create_popup_with_progressbar(ad, ad->win_get,
 739                                  "pending_list",
 740                                  NULL, NULL, NULL, 0, TRUE, TRUE);
 741
 742         if(ad->timer) {
 743                 ecore_timer_del(ad->timer);
 744                 ad->timer = NULL;
 745         }
 746         ad->timer = ecore_timer_add(2, (Ecore_Task_Cb)__setting_storage_main_timer_cb, ad);
 747 }
 748
 749 static void __setting_storage_main_launch_ug_layout_cb(ui_gadget_h ug, enum ug_mode mode, void *priv)
 750 {
 751         SETTING_TRACE_BEGIN;
 752         retm_if(priv == NULL, "priv is NULL");
 753         SettingStorageUG *ad = (SettingStorageUG *) priv;
 754         Evas_Object *base = NULL;
 755         base = (Evas_Object *) ug_get_layout(ug);
 756         retm_if(base == NULL, "base is NULL");
 757
 758         switch (mode) {
 759         case UG_MODE_FULLVIEW:
 760                 evas_object_size_hint_weight_set(base, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
 761                 elm_win_resize_object_add(ad->win_get, base);
 762                 evas_object_show(base);
 763                 break;
 764         default:
 765                 /* do nothing */
 766                 break;
 767         }
 768 }
 769
 770 static void __setting_storage_main_launch_manage_app_ug(void *data)
 771 {
 772         SETTING_TRACE_BEGIN;
 773         /* error check */
 774         retm_if(data == NULL, "Data parameter is NULL");
 775
 776         SettingStorageUG *ad = (SettingStorageUG *) data;
 777
 778         service_h svc;
 779         if (service_create(&svc)) {
 780                 return;
 781         }
 782
 783         service_add_extra_data(svc, "viewtype", "manage-applications");
 784
 785         struct ug_cbs *cbs = (struct ug_cbs *)calloc(1, sizeof(struct ug_cbs));
 786         if (!cbs) {
 787                 SETTING_TRACE_ERROR("calloc failed");
 788                 service_destroy(svc);
 789                 return;
 790         }
 791         cbs->layout_cb = __setting_storage_main_launch_ug_layout_cb;
 792         cbs->result_cb = NULL;
 793         cbs->destroy_cb = __setting_storage_main_launch_ug_destroy_cb;
 794         cbs->priv = (void *)ad;
 795
 796         ui_gadget_h ug = ug_create(ad->ug, "setting-manage-applications-efl", UG_MODE_FULLVIEW, svc, cbs);
 797         if (NULL == ug) {       /* error handling */
 798                 SETTING_TRACE_ERROR("NULL == ug");
 799         }
 800
 801         //bundle_free(b);
 802         service_destroy(svc);
 803         FREE(cbs);
 804 }
 805
 806 static void __setting_storage_main_app_launch(char *app_name)
 807 {
 808         SETTING_TRACE_BEGIN;
 809         setting_retm_if(app_name == NULL, "app_name is NULL");
 810
 811         app_launcher(app_name);
 812 }
 813
 814 static void __setting_storage_main_Gendial_mouse_up_cb(void *data, Evas_Object *obj, void *event_info)
 815 {
 816         SETTING_TRACE_BEGIN;
 817         /* error check */
 818         setting_retm_if(data == NULL, "Data parameter is NULL");
 819         Elm_Object_Item *item = (Elm_Object_Item *) event_info;
 820         elm_genlist_item_selected_set(item, 0);
 821         Setting_GenGroupItem_Data *list_item = (Setting_GenGroupItem_Data *) elm_object_item_data_get(item);
 822
 823         SettingStorageUG *ad = (SettingStorageUG *) data;
 824
 825         SETTING_TRACE("clicking item[%s]", _(list_item->keyStr));
 826
 827         if (isEmulBin()) {
 828                 if (!safeStrCmp(SETTING_STORAGE_DEFAULT_STORAGE_STR, list_item->keyStr)) {
 829                         setting_view_change(&setting_view_storage_main,
 830                                             &setting_view_storage_default_storage, ad);
 831                 } else if (!safeStrCmp(SETTING_STORAGE_MISCES_STR, list_item->keyStr)) {
 832                         setting_view_change(&setting_view_storage_main,
 833                                             &setting_view_storage_miscellaneous_files, ad);
 834                 } else {
 835                         // do nothing now
 836                 }
 837         } else {
 838                 if (!safeStrCmp("IDS_ST_BODY_APPLICATIONS", list_item->keyStr)) {
 839                         __setting_storage_main_launch_manage_app_ug(ad);
 840                 } else if (!safeStrCmp(SETTING_STORAGE_DEFAULT_STORAGE_STR, list_item->keyStr)) {
 841                         setting_view_change(&setting_view_storage_main,
 842                                             &setting_view_storage_default_storage, ad);
 843                 } else if (!safeStrCmp(SETTING_STORAGE_PICS_STR, list_item->keyStr)) {
 844                         __setting_storage_main_app_launch("org.tizen.gallery");
 845                 } else if (!safeStrCmp(SETTING_STORAGE_DOWNS_STR, list_item->keyStr)) {
 846                         __setting_storage_main_app_launch("org.tizen.download-manager");
 847                 } else if (!safeStrCmp(SETTING_STORAGE_AUDIO_STR, list_item->keyStr)) {
 848                         __setting_storage_main_app_launch("org.tizen.music-player");
 849                 } else if (!safeStrCmp(SETTING_STORAGE_MISCES_STR, list_item->keyStr)) {
 850                         setting_view_change(&setting_view_storage_main,
 851                                             &setting_view_storage_miscellaneous_files, ad);
 852                 } else {
 853                         // do nothing now
 854                 }
 855         }
 856 }
 857
 858 static int __setting_storage_main_check_mmc_status()
 859 {
 860         int ret = 0;
 861         struct stat parent_stat, mount_stat;
 862
 863         ret = stat(SETTING_STORAGE_MMC_PATH, &mount_stat);
 864         setting_retvm_if(ret != 0, -1, "get stat error : /opt/storage/sdcard");
 865
 866         ret = stat(SETTING_STORAGE_MMC_PARENT_PATH, &parent_stat);
 867         setting_retvm_if(ret != 0, -1, "get stat error : /opt/storage/sdcard/..");
 868
 869         /* Does not mounted, same st_dev */
 870         if(mount_stat.st_dev == parent_stat.st_dev) {
 871                 return 0;
 872         } else {        /* MMC mounted, diff st_dev */
 873                 return 1;
 874         }
 875 }
 876
 877 static void __setting_storage_main_sd_card_info_get(char* szTotal, char* szAvail)
 878 {
 879         int mmc_status = __setting_storage_main_check_mmc_status();
 880         setting_retm_if(mmc_status == -1, "check mmc status failed");
 881
 882         /* Does not mounted, same st_dev */
 883         if (mmc_status == 0) {
 884                 snprintf(szTotal, SETTING_STORAGE_MAX_STR_LEN, "%s", _("IDS_ST_HEADER_UNAVAILABLE"));
 885                 snprintf(szAvail, SETTING_STORAGE_MAX_STR_LEN, "%s", _("IDS_ST_HEADER_UNAVAILABLE"));
 886         }
 887         /*  MMC mounted, diff st_dev */
 888         else {
 889                 double dTotal = 0.0;
 890                 double dAvail = 0.0;
 891
 892                 int ret = SETTING_RETURN_SUCCESS;
 893                 ret = __setting_storage_main_fs_stat(&dTotal, &dAvail, SETTING_STORAGE_MMC_PATH);
 894                 setting_retm_if(ret == SETTING_RETURN_FAIL, "get sd card size detail failed");
 895
 896                 ret = __setting_storage_status_size_transition(dTotal, szTotal);
 897                 setting_retm_if(ret == SETTING_RETURN_FAIL, "__setting_storage_status_size_transition failed");
 898
 899                 ret = __setting_storage_status_size_transition(dAvail, szAvail);
 900                 setting_retm_if(ret == SETTING_RETURN_FAIL, "__setting_storage_status_size_transition failed");
 901
 902                 SETTING_TRACE("Total[%s], Avail[%s]", szTotal, szAvail);
 903         }
 904 }
 905
 906 static int __setting_storage_main_mmc_content_init(void *data, setting_storage_mmc_cb cb)
 907 {
 908         SETTING_TRACE_BEGIN;
 909         setting_retvm_if(NULL == data, SETTING_RETURN_FAIL, "data is NULL");
 910         setting_retvm_if(NULL == cb, SETTING_RETURN_FAIL, "cb is NULL");
 911         SettingStorageUG *ad = (SettingStorageUG *)data;
 912         if (ad->mmc_content == NULL) {
 913                 ad->mmc_content = (struct mmc_contents *)calloc(1, sizeof(struct mmc_contents *));
 914                 if (ad->mmc_content == NULL ) {
 915                         SETTING_TRACE_ERROR("calloc failed");
 916                         return SETTING_RETURN_FAIL;
 917                 }
 918         }
 919         ad->mmc_content->mmc_cb = cb;
 920         ad->mmc_content->user_data = ad;
 921         return SETTING_RETURN_SUCCESS;
 922 }
 923
 924 static void __setting_storage_status_sd_card_popup_format_response_cb(void *data,
 925                                                          Evas_Object *obj, void *event_info)
 926 {
 927         SETTING_TRACE_BEGIN;
 928         setting_retm_if(data == NULL, "Data parameter is NULL");
 929         SettingStorageUG *ad = (SettingStorageUG *)data;
 930
 931         if (ad->popup) {
 932                 evas_object_del(ad->popup);
 933                 ad->popup = NULL;
 934         }
 935
 936         char sd_total[SETTING_STORAGE_MAX_STR_LEN] = { 0, };
 937         char sd_available[SETTING_STORAGE_MAX_STR_LEN] = { 0, };
 938         __setting_storage_main_sd_card_info_get(sd_total, sd_available);
 939
 940         if (ad->sd_total) {
 941                 G_FREE(ad->sd_total->sub_desc);
 942                 ad->sd_total->sub_desc = (char *)g_strdup(sd_total);
 943                 elm_object_item_data_set(ad->sd_total->item, ad->sd_total);
 944                 elm_genlist_item_update(ad->sd_total->item);
 945         }
 946         if (ad->sd_available) {
 947                 G_FREE(ad->sd_available->sub_desc);
 948                 ad->sd_available->sub_desc = (char *)g_strdup(sd_available);
 949                 elm_object_item_data_set(ad->sd_available->item, ad->sd_available);
 950                 elm_genlist_item_update(ad->sd_available->item);
 951         }
 952 }
 953
 954 static void __setting_storage_status_sd_card_popup_response_cb(void *data,
 955                                                          Evas_Object *obj, void *event_info)
 956 {
 957         SETTING_TRACE_BEGIN;
 958         setting_retm_if(data == NULL, "Data parameter is NULL");
 959         SettingStorageUG *ad = (SettingStorageUG *)data;
 960
 961         if (ad->popup) {
 962                 evas_object_del(ad->popup);
 963                 ad->popup = NULL;
 964         }
 965 }
 966
 967 static void __setting_storage_main_sd_card_mount_cb(int val, void *data)
 968 {
 969         SETTING_TRACE_BEGIN;
 970         setting_retm_if(data == NULL, "Data parameter is NULL");
 971         SettingStorageUG *ad = (SettingStorageUG *) data;
 972
 973         if (ad->popup) {
 974                 evas_object_del(ad->popup);
 975                 ad->popup = NULL;
 976         }
 977
 978         char *desc = NULL;
 979         if (val == SETTING_STORAGE_SYSMAN_REQUEST_SUCCESS) {
 980                 /* do nothing */
 981                 SETTING_TRACE("mount success");
 982                 return;
 983         } else if (val == SETTING_STORAGE_SYSMAN_REQUEST_MOUNT_ALREADY) {
 984                 desc = _(SETTING_STORAGE_SD_CARD_MOUNT_ALREADY_DESC);
 985         } else {
 986                 desc = _("IDS_COM_POP_FAILED");
 987         }
 988
 989         ad->popup = setting_create_popup_without_btn(ad, ad->win_get, NULL, desc,
 990                                  __setting_storage_status_sd_card_popup_response_cb,
 991                                  SETTING_STORAGE_POPUP_TIMER, FALSE, FALSE);
 992 }
 993
 994 static void __setting_storage_main_sd_card_unmount_cb(int val, void *data)
 995 {
 996         SETTING_TRACE_BEGIN;
 997         setting_retm_if(data == NULL, "Data parameter is NULL");
 998         SettingStorageUG *ad = (SettingStorageUG *) data;
 999
1000         if (ad->popup) {
1001                 evas_object_del(ad->popup);
1002                 ad->popup = NULL;
1003         }
1004
1005         if (val == SETTING_STORAGE_SYSMAN_REQUEST_SUCCESS) {
1006                 /* do nothing */
1007                 SETTING_TRACE("unmount success");
1008                 return;
1009         } else {
1010                 ad->popup = setting_create_popup_without_btn(ad, ad->win_get, NULL, _("IDS_COM_POP_FAILED"),
1011                                          __setting_storage_status_sd_card_popup_response_cb,
1012                                          SETTING_STORAGE_POPUP_TIMER, FALSE, FALSE);
1013         }
1014 }
1015
1016 static void __setting_storage_main_sd_card_mount_unmount(void *data)
1017 {
1018         SETTING_TRACE_BEGIN;
1019         setting_retm_if(data == NULL, "Data parameter is NULL");
1020         SettingStorageUG *ad = (SettingStorageUG *)data;
1021
1022         int mmc_status = __setting_storage_main_check_mmc_status();
1023         setting_retm_if(mmc_status == -1, "check mmc status failed");
1024
1025         if (ad->popup) {
1026                 evas_object_del(ad->popup);
1027                 ad->popup = NULL;
1028         }
1029
1030         /* Show progressbar popup */
1031         ad->popup = setting_create_popup_with_progressbar(ad, ad->win_get,
1032                                                  "pending_list", NULL, NULL,
1033                                                  __setting_storage_status_sd_card_popup_response_cb,
1034                                                  SETTING_STORAGE_PROGRESSBAR_TIMEOUT, TRUE, TRUE);
1035
1036         int ret = -1;
1037         /* Does not mounted, same st_dev */
1038         if (mmc_status == 0) {
1039                 ret = __setting_storage_main_mmc_content_init(ad, __setting_storage_main_sd_card_mount_cb);
1040                 if (ret == SETTING_RETURN_FAIL) {
1041                         SETTING_TRACE_ERROR("__setting_storage_main_mmc_content_init fail");
1042                         if (ad->popup) {
1043                                 evas_object_del(ad->popup);
1044                                 ad->popup = NULL;
1045                         }
1046                         ad->popup = setting_create_popup_without_btn(ad, ad->win_get,
1047                                                  NULL, _("IDS_COM_POP_FAILED"),
1048                                                  __setting_storage_status_sd_card_popup_response_cb,
1049                                                  SETTING_STORAGE_POPUP_TIMER, FALSE, FALSE);
1050                         return;
1051                 }
1052                 ret = sysman_request_mount_mmc(ad->mmc_content);
1053                 if (ret == -1) {
1054                         SETTING_TRACE_ERROR("fail to call sysman_request_mount_mmc");
1055                 }
1056         }
1057         /*  MMC mounted, diff st_dev */
1058         else {
1059                 ret = __setting_storage_main_mmc_content_init(ad, __setting_storage_main_sd_card_unmount_cb);
1060                 if (ret == SETTING_RETURN_FAIL) {
1061                         SETTING_TRACE_ERROR("__setting_storage_main_sd_card_unmount_cb fail");
1062                         if (ad->popup) {
1063                                 evas_object_del(ad->popup);
1064                                 ad->popup = NULL;
1065                         }
1066                         ad->popup = setting_create_popup_without_btn(ad, ad->win_get,
1067                                                  NULL, _("IDS_COM_POP_FAILED"),
1068                                                  __setting_storage_status_sd_card_popup_response_cb,
1069                                                  SETTING_STORAGE_POPUP_TIMER, FALSE, FALSE);
1070                         return;
1071                 }
1072
1073                 ret = sysman_request_unmount_mmc(ad->mmc_content,
1074                                                  MNT_FORCE);    /*  1 = MNT_FORCE */
1075                 if (ret == -1) {
1076                         SETTING_TRACE_ERROR("fail to call sysman_request_unmount_mmc");
1077                 }
1078         }
1079
1080         /*  if fail, popup failed info */
1081         if (ret == -1) {
1082                 if (ad->popup) {
1083                         evas_object_del(ad->popup);
1084                         ad->popup = NULL;
1085                 }
1086                 ad->popup = setting_create_popup_without_btn(ad, ad->win_get,
1087                                                  NULL, _("IDS_COM_POP_FAILED"),
1088                                                  __setting_storage_status_sd_card_popup_response_cb,
1089                                                  SETTING_STORAGE_POPUP_TIMER, FALSE, FALSE);
1090         }
1091 }
1092
1093
1094 static void __setting_storage_main_sd_card_format_cb(int val, void *data)
1095 {
1096         SETTING_TRACE_BEGIN;
1097         setting_retm_if(data == NULL, "Data parameter is NULL");
1098         SettingStorageUG *ad = (SettingStorageUG *) data;
1099
1100         if (ad->popup) {
1101                 evas_object_del(ad->popup);
1102                 ad->popup = NULL;
1103         }
1104
1105         if (val == SETTING_STORAGE_SYSMAN_REQUEST_SUCCESS) {
1106                 ad->popup = setting_create_popup_without_btn(ad, ad->win_get, NULL, _("IDS_COM_POP_SUCCESS"),
1107                                          __setting_storage_status_sd_card_popup_format_response_cb,
1108                                          SETTING_STORAGE_POPUP_TIMER, FALSE, FALSE);
1109
1110         } else {
1111                 ad->popup = setting_create_popup_without_btn(ad, ad->win_get, NULL, _("IDS_COM_POP_FAILED"),
1112                                          __setting_storage_status_sd_card_popup_response_cb,
1113                                          SETTING_STORAGE_POPUP_TIMER, FALSE, FALSE);
1114         }
1115 }
1116
1117 static void __setting_storage_main_sd_card_format_popup_yes(void *data)
1118 {
1119         SETTING_TRACE_BEGIN;
1120         setting_retm_if(data == NULL, "Data parameter is NULL");
1121         SettingStorageUG *ad = (SettingStorageUG *) data;
1122
1123         if (ad->popup) {
1124                 evas_object_del(ad->popup);
1125                 ad->popup = NULL;
1126         }
1127
1128         /* Show Formatting..... popup */
1129         ad->popup = setting_create_popup_with_progressbar(ad, ad->win_get,
1130                                                  "list_process", _("IDS_ST_POP_MSG_FORMATTING"),
1131                                                  NULL, __setting_storage_status_sd_card_popup_response_cb,
1132                                                  SETTING_STORAGE_PROGRESSBAR_TIMEOUT, TRUE, TRUE);
1133
1134         int ret = __setting_storage_main_mmc_content_init(ad, __setting_storage_main_sd_card_format_cb);
1135         if (ret == SETTING_RETURN_FAIL) {
1136                 SETTING_TRACE_ERROR("__setting_storage_main_mmc_content_init fail");
1137                 if (ad->popup) {
1138                         evas_object_del(ad->popup);
1139                         ad->popup = NULL;
1140                 }
1141                 ad->popup = setting_create_popup_without_btn(ad, ad->win_get,
1142                                                  NULL, _("IDS_COM_POP_FAILED"),
1143                                                  __setting_storage_status_sd_card_popup_response_cb,
1144                                                  SETTING_STORAGE_POPUP_TIMER, FALSE, FALSE);
1145                 return;
1146         }
1147
1148         ret = sysman_request_format_mmc(ad->mmc_content);
1149         /*  if fail, destory popup */
1150         if (ret == -1) {
1151                 SETTING_TRACE_ERROR("fail to call sysman_request_format_mmc");
1152                 if (ad->popup) {
1153                         evas_object_del(ad->popup);
1154                         ad->popup = NULL;
1155                 }
1156                 ad->popup = setting_create_popup_without_btn(ad, ad->win_get,
1157                                                  NULL, _("IDS_COM_POP_FAILED"),
1158                                                  __setting_storage_status_sd_card_popup_response_cb,
1159                                                  SETTING_STORAGE_POPUP_TIMER, FALSE, FALSE);
1160         }
1161 }
1162
1163 static void __setting_storage_main_sd_card_format_popup_no(void *data)
1164 {
1165         SETTING_TRACE_BEGIN;
1166         setting_retm_if(data == NULL, "Data parameter is NULL");
1167         SettingStorageUG *ad = (SettingStorageUG *) data;
1168
1169         if (ad->popup) {
1170                 evas_object_del(ad->popup);
1171                 ad->popup = NULL;
1172         }
1173 }
1174
1175 static void __setting_storage_main_sd_card_ask_format_resp_cb(void *data, Evas_Object *obj, void *event_info)
1176 {
1177         SETTING_TRACE_BEGIN;
1178         setting_retm_if(data == NULL, "Data parameter is NULL");
1179         int response_type = btn_type(obj);
1180         if (POPUP_RESPONSE_OK == response_type) {
1181                 __setting_storage_main_sd_card_format_popup_yes(data);
1182         } else if (POPUP_RESPONSE_CANCEL == response_type) {
1183                 __setting_storage_main_sd_card_format_popup_no(data);
1184         }
1185 }
1186
1187 static void __setting_storage_main_sd_card_format_popup_create(void *data)
1188 {
1189         SETTING_TRACE_BEGIN;
1190         setting_retm_if(data == NULL, "Data parameter is NULL");
1191         SettingStorageUG *ad = (SettingStorageUG *) data;
1192
1193         if (ad->popup) {
1194                 evas_object_del(ad->popup);
1195                 ad->popup = NULL;
1196         }
1197
1198         ad->popup = setting_create_popup_with_btn(ad, ad->win_get, NULL,
1199                                          _(SETTING_STORAGE_FORMAT_ASK_MSG),
1200                                          __setting_storage_main_sd_card_ask_format_resp_cb, 0,
1201                                          2, _("IDS_COM_SK_YES"),_("IDS_COM_SK_NO"));
1202 }
1203
1204 static void __setting_storage_main_mouse_up_Gendial_list_cb(void *data, Evas_Object *obj,
1205                                                void *event_info)
1206 {
1207         SETTING_TRACE_BEGIN;
1208         setting_retm_if(data == NULL, "Data parameter is NULL");
1209         setting_retm_if(event_info == NULL, "Invalid argument: event info is NULL");
1210
1211         SettingStorageUG *ad = (SettingStorageUG *) data;
1212         Elm_Object_Item *item = (Elm_Object_Item *) event_info;
1213         elm_genlist_item_selected_set(item, 0);
1214         Setting_GenGroupItem_Data *list_item = (Setting_GenGroupItem_Data *) elm_object_item_data_get(item);
1215
1216         SETTING_TRACE("clicking item[%s]", _(list_item->keyStr));
1217         if (list_item == ad->sd_mount) {
1218                 __setting_storage_main_sd_card_mount_unmount(ad);
1219         } else if (list_item == ad->sd_format) {
1220                 __setting_storage_main_sd_card_format_popup_create(ad);
1221         }
1222 }
1223
1224 static void __setting_storage_main_sd_card_info_append(void* data)
1225 {
1226         SETTING_TRACE_BEGIN;
1227         setting_retm_if(data == NULL, "Data parameter is NULL");
1228         SettingStorageUG *ad = (SettingStorageUG *) data;
1229
1230         /* remove the sd info items */
1231         if (ad->sd_mount) {
1232                 elm_object_item_del(ad->sd_mount->item);
1233                 ad->sd_mount = NULL;
1234         }
1235         if (ad->sd_total) {
1236                 elm_object_item_del(ad->sd_total->item);
1237                 ad->sd_total = NULL;
1238         }
1239         if (ad->sd_available) {
1240                 elm_object_item_del(ad->sd_available->item);
1241                 ad->sd_available = NULL;
1242         }
1243         if (ad->sd_format) {
1244                 elm_object_item_del(ad->sd_format->item);
1245                 ad->sd_format = NULL;
1246         }
1247
1248         int mmc_mode = VCONFKEY_SYSMAN_MMC_REMOVED;
1249         int ret = vconf_get_int(VCONFKEY_SYSMAN_MMC_STATUS, &mmc_mode);
1250         setting_retm_if(ret != 0, "Get vconf failed");
1251
1252         if (mmc_mode == VCONFKEY_SYSMAN_MMC_REMOVED) {
1253                 ad->sd_mount = setting_create_Gendial_field_def(ad->genlist, &(ad->itc_2text_2), NULL,
1254                                              ad, SWALLOW_Type_INVALID, NULL,
1255                                              NULL, 0, SETTING_STORAGE_MOUNT_STR,
1256                                              _(SETTING_STORAGE_INSERT_STR),
1257                                              NULL);
1258                 if (ad->sd_mount) {
1259                         setting_disable_genlist_item(ad->sd_mount->item);
1260                 }
1261         } else if (mmc_mode == VCONFKEY_SYSMAN_MMC_INSERTED_NOT_MOUNTED) {
1262                 ad->sd_mount = setting_create_Gendial_field_def(ad->genlist, &(ad->itc_2text_2),
1263                                              __setting_storage_main_mouse_up_Gendial_list_cb,
1264                                              ad, SWALLOW_Type_INVALID, NULL,
1265                                              NULL, 0, SETTING_STORAGE_MOUNT_STR,
1266                                              _(SETTING_STORAGE_INSERT_STR),
1267                                              NULL);
1268         } else if (mmc_mode == VCONFKEY_SYSMAN_MMC_MOUNTED) {
1269                 char sd_total[SETTING_STORAGE_MAX_STR_LEN] = { 0, };
1270                 char sd_available[SETTING_STORAGE_MAX_STR_LEN] = { 0, };
1271                 __setting_storage_main_sd_card_info_get(sd_total, sd_available);
1272
1273                 ad->sd_total = setting_create_Gendial_field_def(ad->genlist, &(ad->itc_2text_2), NULL,
1274                                                      ad, SWALLOW_Type_INVALID, NULL,
1275                                                      NULL, 0, "IDS_ST_BODY_TOTAL_SPACE",
1276                                                      sd_total,
1277                                                      NULL);
1278                 if (ad->sd_total) {
1279                         ad->sd_total->userdata = ad;
1280                         elm_genlist_item_select_mode_set(ad->sd_total->item, ELM_OBJECT_SELECT_MODE_DISPLAY_ONLY);
1281                 } else {
1282                         SETTING_TRACE_ERROR("ad->sd_total is NULL");
1283                 }
1284
1285                 ad->sd_available = setting_create_Gendial_field_def(ad->genlist, &(ad->itc_2text_2), NULL,
1286                                                      ad, SWALLOW_Type_INVALID, NULL,
1287                                                      NULL, 0, "IDS_ST_BODY_AVAILABLE_SPACE",
1288                                                      sd_available,
1289                                                      NULL);
1290                 if (ad->sd_available) {
1291                         ad->sd_available->userdata = ad;
1292                         elm_genlist_item_select_mode_set(ad->sd_available->item, ELM_OBJECT_SELECT_MODE_DISPLAY_ONLY);
1293                 } else {
1294                         SETTING_TRACE_ERROR("ad->sd_available is NULL");
1295                 }
1296
1297                 ad->sd_mount = setting_create_Gendial_field_def(ad->genlist, &(ad->itc_1text),
1298                                                      __setting_storage_main_mouse_up_Gendial_list_cb,
1299                                                      ad, SWALLOW_Type_INVALID, NULL,
1300                                                      NULL, 0, "IDS_ST_BODY_UNMOUNT_SD_CARD", NULL,
1301                                                      NULL);
1302                 if (ad->sd_mount) {
1303                         ad->sd_mount->userdata = ad;
1304                 } else {
1305                         SETTING_TRACE_ERROR("ad->sd_mount is NULL");
1306                 }
1307
1308                 ad->sd_format = setting_create_Gendial_field_def(ad->genlist, &(ad->itc_1text),
1309                                                      __setting_storage_main_mouse_up_Gendial_list_cb,
1310                                                      ad, SWALLOW_Type_INVALID, NULL,
1311                                                      NULL, 0,
1312                                                      "IDS_ST_BODY_FORMAT_SD_CARD",
1313                                                      NULL, NULL);
1314                 if (ad->sd_format) {
1315                         ad->sd_format->userdata = ad;
1316                 } else {
1317                         SETTING_TRACE_ERROR("ad->sd_format is NULL");
1318                 }
1319         } else {
1320                 SETTING_TRACE_ERROR("error status of sd card");
1321         }
1322
1323         Elm_Object_Item *item = NULL;
1324         item = elm_genlist_item_append(ad->genlist, &itc_bottom_seperator, NULL, NULL,
1325                                 ELM_GENLIST_ITEM_NONE, NULL, NULL);
1326         elm_genlist_item_select_mode_set(item, ELM_OBJECT_SELECT_MODE_DISPLAY_ONLY);
1327 }
1328
1329 static void __setting_storage_vconf_change_cb(keynode_t *key, void *data)
1330 {
1331         SETTING_TRACE_BEGIN;
1332         setting_retm_if(NULL == key, "key is NULL");
1333         setting_retm_if(NULL == data, "data is NULL");
1334         SettingStorageUG *ad = (SettingStorageUG *)data;
1335         int status = vconf_keynode_get_int(key);
1336         char *vconf_name = vconf_keynode_get_name(key);
1337
1338         if (!safeStrCmp(vconf_name, VCONFKEY_SYSMAN_MMC_STATUS)) {
1339                 SETTING_TRACE("status:%d", status);
1340                 /* remove last item -> seperator */
1341                 Elm_Object_Item *last_item = NULL;
1342                 last_item = elm_genlist_last_item_get(ad->genlist);
1343                 if (last_item) {
1344                         elm_object_item_del(last_item);
1345                 }
1346                 __setting_storage_main_sd_card_info_append(ad);
1347         }
1348 }
1349
1350 /* ***************************************************
1351  *
1352  *basic func
1353  *
1354  ***************************************************/
1355 static int setting_storage_main_create(void *cb)
1356 {
1357         SETTING_TRACE_BEGIN;
1358         /* error check */
1359         retv_if(cb == NULL, SETTING_GENERAL_ERR_NULL_DATA_PARAMETER);
1360
1361         SettingStorageUG *ad = (SettingStorageUG *) cb;
1362
1363         int ret = SETTING_RETURN_SUCCESS;
1364
1365         ret = media_content_connect();
1366         if(ret == MEDIA_CONTENT_ERROR_NONE) {
1367                 SETTING_TRACE("media_content_connect is success");
1368         } else {
1369                 SETTING_TRACE_ERROR("media_content_connect is failed");
1370                 return SETTING_RETURN_FAIL;
1371         }
1372
1373         retvm_if(ad->win_main_layout == NULL, SETTING_DRAW_ERR_FAIL_LOAD_EDJ,
1374                  "win_main_layout is NULL");
1375
1376         ad->ly_main =
1377             setting_create_layout_navi_bar_genlist(ad->win_main_layout,
1378                                                    ad->win_get,
1379                                                    _(KeyStr_Storage),
1380                                                    _("IDS_COM_BODY_BACK"),
1381                                                    NULL,
1382                                                    __setting_storage_main_click_softkey_back_cb,
1383                                                    NULL,
1384                                                    ad, &ad->genlist, &ad->navibar);
1385
1386         ad->itc_2text_1icon_4.item_style = "dialogue/2text.1icon.4";
1387         ad->itc_2text_1icon_4.func.text_get = __gl_text_get;
1388         ad->itc_2text_1icon_4.func.content_get = __gl_content_get;
1389         ad->itc_2text_1icon_4.func.state_get = NULL;
1390         ad->itc_2text_1icon_4.func.del = __gl_del;
1391
1392         __setting_storage_main_internal_storage_status_get(ad);
1393
1394         __setting_storage_main_pictures_videos_status_get(ad);
1395
1396         __setting_storage_main_downloads_status_get(ad);
1397
1398         __setting_storage_main_audio_status_get(ad);
1399
1400         __setting_storage_main_miscellaneous_size_get(ad);
1401
1402         Elm_Object_Item *item = NULL;
1403
1404         bool is_emulator = isEmulBin();
1405
1406         if (!is_emulator) {
1407                 item = elm_genlist_item_append(ad->genlist, &itc_seperator, NULL, NULL,
1408                                         ELM_GENLIST_ITEM_NONE, NULL, NULL);
1409                 elm_genlist_item_select_mode_set(item, ELM_OBJECT_SELECT_MODE_DISPLAY_ONLY);
1410
1411                 /* Default storage */
1412                 setting_create_Gendial_field_def(ad->genlist, &(ad->itc_1text),
1413                                          __setting_storage_main_Gendial_mouse_up_cb,
1414                                          ad, SWALLOW_Type_INVALID, NULL, NULL,
1415                                          0, SETTING_STORAGE_DEFAULT_STORAGE_STR,
1416                                          NULL, NULL);
1417         }
1418
1419         setting_create_Gendial_field_titleItem(ad->genlist, &(ad->itc_group_item),
1420                                                SETTING_STORAGE_INTERNAL_STORAGE_STR,
1421                                                NULL);
1422
1423         /* Total space */
1424         char total_desc[SETTING_STORAGE_MAX_STR_LEN + 1] = {0,};
1425         ret = __setting_storage_status_size_transition(ad->internal_status.dTotal, total_desc);
1426         setting_retvm_if(ret == SETTING_RETURN_FAIL, SETTING_RETURN_FAIL, "failed to transform")
1427
1428         /* status */
1429         ad->internal = (Setting_GenGroupItem_Data *) calloc(1, sizeof(Setting_GenGroupItem_Data));
1430         setting_retvm_if(!ad->internal, SETTING_RETURN_FAIL, "calloc failed");
1431
1432         if (ad->internal) {
1433                 ad->internal->userdata = ad;
1434                 ad->internal->keyStr = (char *)g_strdup(total_desc);
1435                 ad->internal->item = elm_genlist_item_append(ad->genlist, &(ad->itc_2text_1icon_4), ad->internal, NULL,
1436                                             ELM_GENLIST_ITEM_NONE, NULL, NULL);
1437                 elm_genlist_item_select_mode_set(ad->internal->item, ELM_OBJECT_SELECT_MODE_DISPLAY_ONLY);
1438         } else {
1439                 SETTING_TRACE_ERROR("ad->internal is NULL");
1440                 return SETTING_RETURN_FAIL;
1441         }
1442
1443         /* Applications */
1444         ad->apps_status.dTotal = 0; /* initial value */
1445         char apps_desc[SETTING_STORAGE_MAX_STR_LEN + 1] = {0,};
1446         ret = __setting_storage_status_size_transition(ad->apps_status.dTotal, apps_desc);
1447         setting_retvm_if(ret == SETTING_RETURN_FAIL, SETTING_RETURN_FAIL, "failed to transform")
1448
1449         ad->apps = setting_create_Gendial_field_def(ad->genlist, &(ad->itc_2text_1icon_3),
1450                                              __setting_storage_main_Gendial_mouse_up_cb,
1451                                              ad, SWALLOW_Type_INVALID, SETTING_STORAGE_APPS_ICON_PATH,
1452                                              NULL, 0, "IDS_ST_BODY_APPLICATIONS",
1453                                              apps_desc, NULL);
1454         if (ad->apps) {
1455                 ad->apps->userdata = ad;
1456                 if (is_emulator) {
1457                         elm_genlist_item_select_mode_set(ad->apps->item, ELM_OBJECT_SELECT_MODE_DISPLAY_ONLY);
1458                 }
1459         } else {
1460                 SETTING_TRACE_ERROR("ad->apps is NULL");
1461                 return SETTING_RETURN_FAIL;
1462         }
1463
1464         /* Pictures, Videos */
1465         char pics_videos_desc[SETTING_STORAGE_MAX_STR_LEN + 1] = {0,};
1466         ret = __setting_storage_status_size_transition(ad->pics_videos_status.dTotal, pics_videos_desc);
1467         setting_retvm_if(ret == SETTING_RETURN_FAIL, SETTING_RETURN_FAIL, "failed to transform")
1468         ad->pics_videos = setting_create_Gendial_field_def(ad->genlist, &(ad->itc_2text_1icon_3),
1469                                              __setting_storage_main_Gendial_mouse_up_cb,
1470                                              ad, SWALLOW_Type_INVALID, SETTING_STORAGE_PICS_ICON_PATH,
1471                                              NULL, 0, SETTING_STORAGE_PICS_STR,
1472                                              pics_videos_desc, NULL);
1473         if (ad->pics_videos) {
1474                 ad->pics_videos->userdata = ad;
1475                 if (is_emulator) {
1476                         elm_genlist_item_select_mode_set(ad->pics_videos->item, ELM_OBJECT_SELECT_MODE_DISPLAY_ONLY);
1477                 }
1478         } else {
1479                 SETTING_TRACE_ERROR("ad->pics_videos is NULL");
1480                 return SETTING_RETURN_FAIL;
1481         }
1482
1483         /* Downloads */
1484         char downloads_desc[SETTING_STORAGE_MAX_STR_LEN + 1] = {0,};
1485         ret = __setting_storage_status_size_transition(ad->downloads_status.dTotal, downloads_desc);
1486         setting_retvm_if(ret == SETTING_RETURN_FAIL, SETTING_RETURN_FAIL, "failed to transform")
1487         ad->downloads = setting_create_Gendial_field_def(ad->genlist, &(ad->itc_2text_1icon_3),
1488                                              __setting_storage_main_Gendial_mouse_up_cb,
1489                                              ad, SWALLOW_Type_INVALID, SETTING_STORAGE_DOWNS_ICON_PATH,
1490                                              NULL, 0, SETTING_STORAGE_DOWNS_STR,
1491                                              downloads_desc,
1492                                              NULL);
1493         if (ad->downloads) {
1494                 ad->downloads->userdata = ad;
1495                 if (is_emulator) {
1496                         elm_genlist_item_select_mode_set(ad->downloads->item, ELM_OBJECT_SELECT_MODE_DISPLAY_ONLY);
1497                 }
1498         } else {
1499                 SETTING_TRACE_ERROR("ad->downloads is NULL");
1500                 return SETTING_RETURN_FAIL;
1501         }
1502
1503         /* Audio */
1504         char audio_desc[SETTING_STORAGE_MAX_STR_LEN + 1] = {0,};
1505         ret = __setting_storage_status_size_transition(ad->audio_status.dTotal, audio_desc);
1506         setting_retvm_if(ret == SETTING_RETURN_FAIL, SETTING_RETURN_FAIL, "failed to transform")
1507         ad->audio = setting_create_Gendial_field_def(ad->genlist, &(ad->itc_2text_1icon_3),
1508                                              __setting_storage_main_Gendial_mouse_up_cb,
1509                                              ad, SWALLOW_Type_INVALID, SETTING_STORAGE_AUDIO_ICON_PATH,
1510                                              NULL, 0, SETTING_STORAGE_AUDIO_STR,
1511                                              audio_desc,
1512                                              NULL);
1513         if (ad->audio) {
1514                 ad->audio->userdata = ad;
1515
1516                 if (is_emulator) {
1517                         elm_genlist_item_select_mode_set(ad->audio->item, ELM_OBJECT_SELECT_MODE_DISPLAY_ONLY);
1518                 }
1519         } else {
1520                 SETTING_TRACE_ERROR("ad->audio is NULL");
1521                 return SETTING_RETURN_FAIL;
1522         }
1523
1524         /* Miscellaneous files */
1525         char others_desc[SETTING_STORAGE_MAX_STR_LEN + 1] = {0,};
1526         ret = __setting_storage_status_size_transition(ad->others_status.dTotal, others_desc);
1527         setting_retvm_if(ret == SETTING_RETURN_FAIL, SETTING_RETURN_FAIL, "failed to transform")
1528
1529         ad->others = setting_create_Gendial_field_def(ad->genlist, &(ad->itc_2text_1icon_3),
1530                                              __setting_storage_main_Gendial_mouse_up_cb,
1531                                              ad, SWALLOW_Type_INVALID, SETTING_STORAGE_MISCES_ICON_PATH,
1532                                              NULL, 0, SETTING_STORAGE_MISCES_STR,
1533                                              others_desc, NULL);
1534         if (ad->others) {
1535                 ad->others->userdata = ad;
1536         } else {
1537                 SETTING_TRACE_ERROR("ad->others is NULL");
1538                 return SETTING_RETURN_FAIL;
1539         }
1540
1541         /* Available */
1542         char avail_desc[SETTING_STORAGE_MAX_STR_LEN + 1] = {0,};
1543         ret = __setting_storage_status_size_transition(ad->internal_status.dAvail, avail_desc);
1544         setting_retvm_if(ret == SETTING_RETURN_FAIL, SETTING_RETURN_FAIL, "failed to transform")
1545
1546         ad->avail = setting_create_Gendial_field_def(ad->genlist, &(ad->itc_2text_1icon_3), NULL,
1547                                              ad, SWALLOW_Type_INVALID, SETTING_STORAGE_AVAIL_ICON_PATH,
1548                                              NULL, 0, SETTING_STORAGE_AVAIL_STR,
1549                                              avail_desc, NULL);
1550         if (ad->avail) {
1551                 ad->avail->userdata = ad;
1552                 elm_genlist_item_select_mode_set(ad->avail->item, ELM_OBJECT_SELECT_MODE_DISPLAY_ONLY);
1553         } else {
1554                 SETTING_TRACE_ERROR("ad->avail is NULL");
1555                 return SETTING_RETURN_FAIL;
1556         }
1557
1558         if (!is_emulator) {
1559 #if DISABLED_CODE
1560                 /* Format USB storage */
1561                 setting_create_Gendial_field_def(ad->genlist, &(ad->itc_1text), NULL,
1562                                                      ad, SWALLOW_Type_INVALID, NULL,
1563                                                      NULL, 0,
1564                                                      SETTING_STORAGE_FORMAT_STR,
1565                                                      NULL, NULL);
1566
1567                 setting_create_Gendial_field_def(ad->genlist, &(ad->itc_bg_1icon), NULL,
1568                                                  ad, SWALLOW_Type_LAYOUT_SPECIALIZTION_X,
1569                                                  NULL, NULL, 0, SETTING_STORAGE_FORMAT_DESC_STR, NULL,
1570                                                  NULL);
1571 #endif
1572
1573                 /* SD card info */
1574                 setting_create_Gendial_field_titleItem(ad->genlist, &(ad->itc_group_item),
1575                                                "IDS_ST_BODY_SD_CARD", NULL);
1576                 __setting_storage_main_sd_card_info_append(ad);
1577
1578                 ret = vconf_notify_key_changed(VCONFKEY_SYSMAN_MMC_STATUS,
1579                                 __setting_storage_vconf_change_cb, ad);
1580                 if (ret != 0) {
1581                         SETTING_TRACE_ERROR("call vconf_notify_key_changed failed");
1582                 }
1583         } else {
1584                 item = elm_genlist_item_append(ad->genlist, &itc_bottom_seperator, NULL, NULL,
1585                                         ELM_GENLIST_ITEM_NONE, NULL, NULL);
1586                 elm_genlist_item_select_mode_set(item, ELM_OBJECT_SELECT_MODE_DISPLAY_ONLY);
1587         }
1588
1589         if(ad->timer) {
1590                 ecore_timer_del(ad->timer);
1591                 ad->timer = NULL;
1592         }
1593         ad->timer = ecore_timer_add(2, (Ecore_Task_Cb)__setting_storage_main_timer_cb, ad);
1594
1595         setting_view_storage_main.is_create = 1;
1596         return SETTING_RETURN_SUCCESS;
1597 }
1598
1599 static int setting_storage_main_destroy(void *cb)
1600 {
1601         /* error check */
1602         retv_if(cb == NULL, SETTING_GENERAL_ERR_NULL_DATA_PARAMETER);
1603
1604         SettingStorageUG *ad = (SettingStorageUG *) cb;
1605
1606         int ret = media_content_disconnect();
1607         if (ret == MEDIA_CONTENT_ERROR_NONE) {
1608                 SETTING_TRACE("media_content_disconnect is success");
1609         } else {
1610                 SETTING_TRACE_ERROR("media_content_disconnect is failed");
1611         }
1612
1613         if (ad->pop_progress) {
1614                 evas_object_del(ad->pop_progress);
1615                 ad->pop_progress = NULL;
1616         }
1617
1618         if(ad->timer) {
1619                 ecore_timer_del(ad->timer);
1620                 ad->timer = NULL;
1621         }
1622
1623         __setting_storage_main_apps_list_free(ad);
1624
1625         if (!isEmulBin()) {
1626                 ret = vconf_ignore_key_changed(VCONFKEY_SYSMAN_MMC_STATUS,
1627                                 __setting_storage_vconf_change_cb);
1628                 if (ret != 0) {
1629                         SETTING_TRACE_ERROR("call vconf_ignore_key_changed failed");
1630                 }
1631         }
1632
1633         if (ad->popup) {
1634                 evas_object_del(ad->popup);
1635                 ad->popup = NULL;
1636         }
1637
1638         if (ad->ly_main != NULL) {
1639                 evas_object_del(ad->ly_main);
1640                 setting_view_storage_main.is_create = 0;
1641         }
1642
1643         return SETTING_RETURN_SUCCESS;
1644 }
1645
1646 static int setting_storage_main_update(void *cb)
1647 {
1648         SETTING_TRACE_BEGIN;
1649         /* error check */
1650         retv_if(cb == NULL, SETTING_GENERAL_ERR_NULL_DATA_PARAMETER);
1651
1652         SettingStorageUG *ad = (SettingStorageUG *) cb;
1653
1654         __setting_storage_main_miscellaneous_size_get(ad);
1655
1656         char others_desc[SETTING_STORAGE_MAX_STR_LEN + 1] = {0,};
1657         int ret = __setting_storage_status_size_transition(ad->others_status.dTotal, others_desc);
1658         setting_retvm_if(ret == SETTING_RETURN_FAIL, SETTING_RETURN_FAIL, "failed to transform")
1659
1660         G_FREE(ad->others->sub_desc);
1661         ad->others->sub_desc = (char *)g_strdup(others_desc);
1662         elm_object_item_data_set(ad->others->item, ad->others);
1663         elm_genlist_item_update(ad->others->item);
1664
1665         if (ad->ly_main != NULL) {
1666                 evas_object_show(ad->ly_main);
1667         }
1668
1669         return SETTING_RETURN_SUCCESS;
1670 }
1671
1672 static int setting_storage_main_cleanup(void *cb)
1673 {
1674         /* error check */
1675         retv_if(cb == NULL, SETTING_GENERAL_ERR_NULL_DATA_PARAMETER);
1676
1677         SettingStorageUG *ad = (SettingStorageUG *) cb;
1678
1679         if (ad->ly_main != NULL) {
1680                 evas_object_hide(ad->ly_main);
1681         }
1682
1683         return SETTING_RETURN_SUCCESS;
1684 }
1685
1686 /* ***************************************************
1687  *
1688  *call back func
1689  *
1690  ***************************************************/
1691
1692 static void __setting_storage_main_click_softkey_back_cb(void *data, Evas_Object *obj,
1693                                         void *event_info)
1694 {
1695         /* error check */
1696         ret_if(data == NULL);
1697
1698         SettingStorageUG *ad = (SettingStorageUG *) data;
1699         /* Send destroy request */
1700         ug_destroy_me(ad->ug);
1701 }