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