setting-storage/src/setting-storage-main.c

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