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

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