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