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