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