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 <sys/statvfs.h>
  24 #include <sys/stat.h>
  25 #include <sys/mount.h>
  26 #include <dirent.h>
  27 #include <glib.h>
  28 #include <glib/gprintf.h>
  29 #include <sysman.h>
  30
  31 static int setting_storage_main_create(void *cb);
  32 static int setting_storage_main_destroy(void *cb);
  33 static int setting_storage_main_update(void *cb);
  34 static int setting_storage_main_cleanup(void *cb);
  35
  36 static void __setting_storage_main_click_softkey_back_cb(void *data, Evas_Object *obj,
  37                                         void *event_info);
  38
  39 setting_view setting_view_storage_main = {
  40         .create = setting_storage_main_create,
  41         .destroy = setting_storage_main_destroy,
  42         .update = setting_storage_main_update,
  43         .cleanup = setting_storage_main_cleanup,
  44 };
  45
  46 static char *__gl_text_get(void *data, Evas_Object *obj, const char *part)
  47 {
  48         retv_if(!data, NULL);
  49         Setting_GenGroupItem_Data *item_data = data;
  50
  51         if (!safeStrCmp(part, "elm.text.1")) {
  52                 return (char *)g_strdup(item_data->keyStr);
  53         }
  54         return NULL;
  55 }
  56
  57 static Evas_Object *__gl_content_get(void *data, Evas_Object *obj, const char *part)
  58 {
  59         retv_if(!data, NULL);
  60         Setting_GenGroupItem_Data *item_data = data;
  61         SettingStorageUG *ad = (SettingStorageUG *) item_data->userdata;
  62
  63         int width = SETTING_STORAGE_ICON_WIDTH;
  64         int height = SETTING_STORAGE_ICON_HEIGHT;
  65         float temp_size = 0.0;
  66
  67         if (!safeStrCmp(part, "elm.icon")){
  68                 Evas_Object *status_box = NULL;
  69                 status_box = elm_box_add(obj);
  70                 retvm_if(status_box == NULL, NULL, "Cannot get box");
  71                 elm_box_horizontal_set(status_box, 1);
  72                 evas_object_size_hint_align_set(status_box, 0.0, EVAS_HINT_FILL);
  73                 evas_object_show(status_box);
  74
  75                 Evas *evas = evas_object_evas_get(obj);
  76
  77                 /* apps */
  78                 unsigned int apps_size = 0;
  79                 temp_size = ((float)ad->apps_status.dTotal / ad->internal_status.dTotal) * width;
  80                 if (temp_size < 1 && temp_size > 0) {
  81                         apps_size = 1;
  82                 } else {
  83                         apps_size = (unsigned int)temp_size;
  84                 }
  85                 if (apps_size > 0) {
  86                         Evas_Object *apps = NULL;
  87                         apps = evas_object_image_add(evas);
  88                         evas_object_size_hint_weight_set(apps, 0.0, EVAS_HINT_EXPAND);
  89                         evas_object_image_load_size_set(apps, apps_size, height);
  90                         evas_object_image_file_set(apps, SETTING_STORAGE_APPS_ICON_PATH, NULL);
  91                         evas_object_image_fill_set(apps, 0, 0, apps_size, height);
  92                         evas_object_size_hint_min_set(apps, apps_size, height);
  93                         evas_object_show(apps);
  94                         elm_box_pack_end(status_box, apps);
  95                 }
  96
  97                 /* pictures, videos */
  98                 unsigned int pics_videos_size = 0;
  99                 temp_size = ((float)ad->pics_videos_status.dTotal / ad->internal_status.dTotal) * width;
 100                 if (temp_size < 1 && temp_size > 0) {
 101                         pics_videos_size = 1;
 102                 } else {
 103                         pics_videos_size = (unsigned int)temp_size;
 104                 }
 105                 if (pics_videos_size > 0) {
 106                         Evas_Object *pics = NULL;
 107                         pics = evas_object_image_add(evas);
 108                         evas_object_size_hint_weight_set(pics, 0.0, EVAS_HINT_EXPAND);
 109                         evas_object_image_load_size_set(pics, pics_videos_size, height);
 110                         evas_object_image_file_set(pics, SETTING_STORAGE_PICS_ICON_PATH, NULL);
 111                         evas_object_image_fill_set(pics, 0, 0, pics_videos_size, height);
 112                         evas_object_size_hint_min_set(pics, pics_videos_size, height);
 113                         evas_object_show(pics);
 114                         elm_box_pack_end(status_box, pics);
 115                 }
 116
 117                 /* downloads */
 118                 unsigned int downloads_size = 0;
 119                 temp_size = ((float)ad->downloads_status.dTotal / ad->internal_status.dTotal) * width;
 120                 if (temp_size < 1 && temp_size > 0) {
 121                         downloads_size = 1;
 122                 } else {
 123                         downloads_size = (unsigned int)temp_size;
 124                 }
 125                 if (downloads_size > 0) {
 126                         Evas_Object *downs = NULL;
 127                         downs = evas_object_image_add(evas);
 128                         evas_object_size_hint_weight_set(downs, 0.0, EVAS_HINT_EXPAND);
 129                         evas_object_image_load_size_set(downs, downloads_size, height);
 130                         evas_object_image_file_set(downs, SETTING_STORAGE_DOWNS_ICON_PATH, NULL);
 131                         evas_object_image_fill_set(downs, 0, 0, downloads_size, height);
 132                         evas_object_size_hint_min_set(downs, downloads_size, height);
 133                         evas_object_show(downs);
 134                         elm_box_pack_end(status_box, downs);
 135                 }
 136
 137                 /* audio */
 138                 unsigned int audio_size = 0;
 139                 temp_size = ((float)ad->audio_status.dTotal / ad->internal_status.dTotal) * width;
 140                 if (temp_size < 1 && temp_size > 0) {
 141                         audio_size = 1;
 142                 } else {
 143                         audio_size = (unsigned int)temp_size;
 144                 }
 145                 if (audio_size > 0) {
 146                         Evas_Object *audio = NULL;
 147                         audio = evas_object_image_add(evas);
 148                         evas_object_size_hint_weight_set(audio, 0.0, EVAS_HINT_EXPAND);
 149                         evas_object_image_load_size_set(audio, audio_size, height);
 150                         evas_object_image_file_set(audio, SETTING_STORAGE_AUDIO_ICON_PATH, NULL);
 151                         evas_object_image_fill_set(audio, 0, 0, audio_size, height);
 152                         evas_object_size_hint_min_set(audio, audio_size, height);
 153                         evas_object_show(audio);
 154                         elm_box_pack_end(status_box, audio);
 155                 }
 156
 157                 /* Miscellaneous files */
 158                 unsigned int others_size = 0;
 159                 temp_size = ((float)ad->others_status.dTotal / ad->internal_status.dTotal) * width;
 160                 if (temp_size < 1 && temp_size > 0) {
 161                         others_size = 1;
 162                 } else {
 163                         others_size = (unsigned int)temp_size;
 164                 }
 165                 if (others_size > 0) {
 166                         Evas_Object *misc = NULL;
 167                         misc = evas_object_image_add(evas);
 168                         evas_object_size_hint_weight_set(misc, 0.0, EVAS_HINT_EXPAND);
 169                         evas_object_image_load_size_set(misc, others_size, height);
 170                         evas_object_image_file_set(misc, SETTING_STORAGE_MISCES_ICON_PATH, NULL);
 171                         evas_object_image_fill_set(misc, 0, 0, others_size, height);
 172                         evas_object_size_hint_min_set(misc, others_size, height);
 173                         evas_object_show(misc);
 174                         elm_box_pack_end(status_box, misc);
 175                 }
 176
 177                 /* available */
 178                 unsigned int avail_size = 0;
 179                 temp_size = ((float)ad->internal_status.dAvail / ad->internal_status.dTotal) * width;
 180                 if (temp_size < 1 && temp_size > 0) {
 181                         avail_size = 1;
 182                 } else {
 183                         avail_size = (unsigned int)temp_size;
 184                 }
 185                 if (avail_size > 0) {
 186                         Evas_Object *avail = NULL;
 187                         avail = evas_object_image_add(evas);
 188                         evas_object_size_hint_weight_set(avail, 0.0, EVAS_HINT_EXPAND);
 189                         evas_object_image_load_size_set(avail, avail_size, height);
 190                         evas_object_image_file_set(avail, SETTING_STORAGE_AVAIL_ICON_PATH, NULL);
 191                         evas_object_image_fill_set(avail, 0, 0, avail_size, height);
 192                         evas_object_size_hint_min_set(avail, avail_size, height);
 193                         evas_object_show(avail);
 194                         elm_box_pack_end(status_box, avail);
 195                 }
 196
 197                 return status_box;
 198         }
 199         return NULL;
 200 }
 201
 202 static void __gl_del(void *data, Evas_Object *obj)
 203 {
 204         /* SETTING_TRACE_BEGIN; */
 205         Setting_GenGroupItem_Data *item_data = (Setting_GenGroupItem_Data *) data;
 206         if (item_data) {
 207                 G_FREE(item_data->keyStr);
 208                 FREE(item_data);
 209         }
 210 }
 211
 212 static int __setting_storage_main_fs_stat(double *total, double *avail, const char *path)
 213 {
 214         SETTING_TRACE_BEGIN;
 215         setting_retvm_if(NULL == total || NULL == avail, SETTING_RETURN_FAIL, "Null output parameters");
 216
 217         struct statvfs s;
 218
 219         if (!statvfs(path, &s)) {
 220                 SETTING_TRACE("f_bsize = %ld f_blocks = %ld f_bavail = %ld f_frsize = %ld",
 221                      s.f_bsize, s.f_blocks, s.f_bavail, s.f_frsize);
 222                 *total = (double)s.f_frsize * s.f_blocks;
 223                 *avail = (double)s.f_bsize * s.f_bavail;
 224         } else {
 225                 return SETTING_RETURN_FAIL;
 226         }
 227
 228         return SETTING_RETURN_SUCCESS;
 229 }
 230
 231 static int __setting_storage_main_file_stat_get(const char *filename, Node_Info **node)
 232 {
 233         setting_retvm_if(!filename || !node, SETTING_RETURN_FAIL, "NULL input parameters");
 234         struct stat statbuf;
 235         if (stat(filename, &statbuf) == -1) {
 236                 SETTING_TRACE_ERROR("failed to call stat");
 237                 return SETTING_RETURN_FAIL;
 238         }
 239
 240         if (*node == NULL) {
 241                 SETTING_TRACE_ERROR("node is NULL");
 242                 return SETTING_RETURN_FAIL;
 243         }
 244
 245         (*node)->size = statbuf.st_size;
 246
 247         return SETTING_RETURN_SUCCESS;
 248 }
 249
 250 static int __setting_storage_main_file_list_get(char *path, Eina_List **dir_list, Eina_List **file_list)
 251 {
 252         SETTING_TRACE_BEGIN;
 253         setting_retvm_if(NULL == path, SETTING_RETURN_FAIL, "path is NULL");
 254
 255         DIR *pDir = NULL;
 256         struct dirent *ent = NULL;
 257         char childpath[SETTING_STORAGE_CHILDPATH_LEN] = {0,};
 258
 259         pDir = opendir(path);
 260         setting_retvm_if(NULL == pDir, SETTING_RETURN_FAIL, "pDir is NULL");
 261
 262         while ((ent = readdir(pDir)) != NULL) {
 263                 if (safeStrCmp(ent->d_name, ".") == 0 || safeStrCmp(ent->d_name, "..") == 0) {
 264                         continue;
 265                 }
 266                 /*only deal with dirs and regular files*/
 267                 if ((ent->d_type & DT_DIR) == 0 && (ent->d_type & DT_REG) == 0) {
 268                         continue;
 269                 }
 270
 271                 Node_Info *pNode = (Node_Info *)malloc(sizeof(Node_Info));
 272
 273                 if (pNode == NULL) {
 274                         continue;
 275                 }
 276
 277                 memset(pNode, 0, sizeof(Node_Info));
 278                 /*get path*/
 279                 g_strlcpy(pNode->path, path, (gsize) sizeof(pNode->path));
 280
 281                 /*get name*/
 282                 g_strlcpy(pNode->name, ent->d_name, (gsize) sizeof(pNode->name));
 283
 284                 /*get size*/
 285                 int copiednum = g_sprintf(childpath, "%s/%s", path, ent->d_name);
 286                 if (copiednum < 0) {
 287                         FREE(pNode);
 288                         continue;
 289                 }
 290                 if (__setting_storage_main_file_stat_get(childpath, &pNode) == SETTING_RETURN_FAIL) {
 291                         FREE(pNode);
 292                         continue;
 293                 }
 294
 295                 if (ent->d_type & DT_DIR) {
 296                         *dir_list = eina_list_append(*dir_list, pNode);
 297                 } else {
 298                         *file_list = eina_list_append(*file_list, pNode);
 299                 }
 300         }
 301         closedir(pDir);
 302
 303         return SETTING_RETURN_SUCCESS;
 304 }
 305
 306 static int __setting_storage_main_list_len_get(const Eina_List *list)
 307 {
 308         if (list == NULL)
 309                 return 0;
 310
 311         return eina_list_count(list);
 312 }
 313
 314 static long __setting_storage_main_folder_size_get(char *path)
 315 {
 316         SETTING_TRACE_BEGIN;
 317         setting_retvm_if(NULL == path, SETTING_RETURN_FAIL, "path is NULL");
 318
 319         unsigned long size = 0;
 320         Eina_List *file_list = NULL;
 321         Eina_List *dir_list = NULL;
 322
 323         if (ecore_file_is_dir(path)) {
 324                 int ret = SETTING_RETURN_FAIL;
 325                 ret = __setting_storage_main_file_list_get(path, &dir_list, &file_list);
 326
 327                 if (ret == SETTING_RETURN_SUCCESS) {
 328                         int i = 0;
 329                         int dir_list_len =  __setting_storage_main_list_len_get(dir_list);
 330                         int file_list_len = __setting_storage_main_list_len_get(file_list);
 331                         SETTING_TRACE("dir_list_len is [%d] file_list_len is [%d]", dir_list_len, file_list_len);
 332                         for (i = 0; i < file_list_len; i++) {
 333                                 Node_Info *pNode = NULL;
 334                                 pNode = (Node_Info *)eina_list_nth(file_list, i);
 335                                 if (pNode == NULL)
 336                                         continue;
 337                                 size += pNode->size;
 338                         }
 339                         for (i = 0; i < dir_list_len; i++) {
 340                                 Node_Info *pNode = NULL;
 341                                 char *full_path = NULL;
 342                                 pNode = (Node_Info *)eina_list_nth(dir_list, i);
 343                                 if (pNode == NULL)
 344                                         continue;
 345                                 full_path =  g_strconcat(pNode->path, "/", pNode->name, NULL);
 346                                 SETTING_TRACE("full_path is [%s]", full_path);
 347                                 size += (__setting_storage_main_folder_size_get(full_path));
 348                                 FREE(full_path);
 349                         }
 350                 }
 351         }
 352
 353         if (file_list) {
 354                 eina_list_free(file_list);
 355                 file_list = NULL;
 356         }
 357
 358         if (dir_list) {
 359                 eina_list_free(dir_list);
 360                 dir_list = NULL;
 361         }
 362
 363         return size;
 364 }
 365
 366 static int __setting_storage_status_size_transition(double size, char *size_desc)
 367 {
 368         SETTING_TRACE_BEGIN;
 369         SETTING_TRACE("size = %f", size);
 370         double tmp_size = 0.0;
 371         int ret = 0;
 372         if (size < SETTING_STORAGE_MEGABYTE_VALUE) {    // size < 1MB: show x.xKB
 373                 tmp_size = size / SETTING_STORAGE_KILOBYTE_VALUE;
 374                 ret = snprintf(size_desc, SETTING_STORAGE_MAX_STR_LEN, "%4.2lf%s", tmp_size, "KB");
 375                 retv_if(ret < 0, SETTING_RETURN_FAIL);
 376         } else if (size < SETTING_STORAGE_GIGABYTE_VALUE) {     // size < 1GB: show x.xMB
 377                 tmp_size = size / SETTING_STORAGE_MEGABYTE_VALUE;
 378                 ret = snprintf(size_desc, SETTING_STORAGE_MAX_STR_LEN, "%4.2lf%s", tmp_size, "MB");
 379                 retv_if(ret < 0, SETTING_RETURN_FAIL);
 380         } else { // 1G <= size: show x.xGB
 381                 tmp_size = size / SETTING_STORAGE_GIGABYTE_VALUE;
 382                 ret = snprintf(size_desc, SETTING_STORAGE_MAX_STR_LEN, "%4.2lf%s", tmp_size, "GB");
 383                 retv_if(ret < 0, SETTING_RETURN_FAIL);
 384         }
 385
 386         return SETTING_RETURN_SUCCESS;
 387 }
 388
 389
 390 static void __setting_storage_main_internal_storage_status_get(void *data)
 391 {
 392         SETTING_TRACE_BEGIN;
 393         setting_retm_if(data == NULL, "Data parameter is NULL");
 394         SettingStorageUG *ad = (SettingStorageUG *) data;
 395
 396         double dTotal = 0.0;
 397         double dAvail = 0.0;
 398         int ret = SETTING_RETURN_SUCCESS;
 399         Setting_Storage_Status internal_status;
 400
 401         ret = __setting_storage_main_fs_stat(&dTotal, &dAvail, SETTING_STORAGE_OPT_PATH);
 402         setting_retm_if(ret == SETTING_RETURN_FAIL, "get opt status failed");
 403         internal_status.dTotal = dTotal;
 404         internal_status.dAvail = dAvail;
 405
 406         dTotal = 0.0;
 407         dAvail = 0.0;
 408         ret = __setting_storage_main_fs_stat(&dTotal, &dAvail, SETTING_STORAGE_MEDIA_PATH);
 409         setting_retm_if(ret == SETTING_RETURN_FAIL, "get media status failed");
 410         internal_status.dTotal += dTotal;
 411         internal_status.dAvail += dAvail;
 412
 413         ad->internal_status = internal_status;
 414 }
 415
 416 static void __setting_storage_main_pictures_videos_status_get(void *data)
 417 {
 418         SETTING_TRACE_BEGIN;
 419         setting_retm_if(data == NULL, "Data parameter is NULL");
 420         SettingStorageUG *ad = (SettingStorageUG *) data;
 421
 422         double dTotal = 0.0;
 423         int ret = SETTING_RETURN_SUCCESS;
 424         Setting_Storage_Status pics_videos_status;
 425
 426         dTotal = __setting_storage_main_folder_size_get(SETTING_STORAGE_PICTURES_PATH);
 427         setting_retm_if(ret == SETTING_RETURN_FAIL, "get pictures status failed");
 428         pics_videos_status.dTotal = dTotal;
 429         //SETTING_TRACE("pics_videos_status = %f", dTotal);
 430
 431         dTotal = 0.0;
 432         dTotal = __setting_storage_main_folder_size_get(SETTING_STORAGE_VIDEOS_PATH);
 433         setting_retm_if(ret == SETTING_RETURN_FAIL, "get video status failed");
 434         //SETTING_TRACE("pics_videos_status = %f", dTotal);
 435         pics_videos_status.dTotal += dTotal;
 436
 437         //SETTING_TRACE("pics_videos_status = %f", pics_videos_status.dTotal);
 438
 439         ad->pics_videos_status = pics_videos_status;
 440 }
 441
 442 static void __setting_storage_main_downloads_status_get(void *data)
 443 {
 444         SETTING_TRACE_BEGIN;
 445         setting_retm_if(data == NULL, "Data parameter is NULL");
 446         SettingStorageUG *ad = (SettingStorageUG *) data;
 447
 448         double dTotal = 0.0;
 449         int ret = SETTING_RETURN_SUCCESS;
 450         Setting_Storage_Status downloads_status;
 451
 452         dTotal = __setting_storage_main_folder_size_get(SETTING_STORAGE_DOWNLOADS_PATH);
 453         setting_retm_if(ret == SETTING_RETURN_FAIL, "get pictures status failed");
 454         downloads_status.dTotal = dTotal;
 455
 456         //SETTING_TRACE("downloads_status = %f", dTotal);
 457
 458         ad->downloads_status = downloads_status;
 459 }
 460
 461 static void __setting_storage_main_audio_status_get(void *data)
 462 {
 463         SETTING_TRACE_BEGIN;
 464         setting_retm_if(data == NULL, "Data parameter is NULL");
 465         SettingStorageUG *ad = (SettingStorageUG *) data;
 466
 467         double dTotal = 0.0;
 468         int ret = SETTING_RETURN_SUCCESS;
 469         Setting_Storage_Status audio_status;
 470
 471         dTotal = __setting_storage_main_folder_size_get(SETTING_STORAGE_AUDIO_PATH);
 472         setting_retm_if(ret == SETTING_RETURN_FAIL, "get audio status failed");
 473         audio_status.dTotal = dTotal;
 474
 475         //SETTING_TRACE("audio_status = %f", dTotal);
 476
 477         ad->audio_status = audio_status;
 478 }
 479
 480 static void __setting_storage_main_launch_ug_destroy_cb(ui_gadget_h ug, void *priv)
 481 {
 482         SETTING_TRACE_BEGIN;
 483         /* restore the '<-' button on the navigate bar */
 484         retm_if(priv == NULL, "priv is NULL");
 485         SettingStorageUG *ad = (SettingStorageUG *) priv;
 486         if (ug) {
 487                 ug_destroy(ug);
 488         }
 489         Elm_Object_Item *navi_it = elm_naviframe_top_item_get(ad->navibar);
 490         retm_if(navi_it == NULL, "navi_it is NULL");
 491         Evas_Object *back_btn = elm_object_item_part_content_get(navi_it, "prev_btn");
 492
 493         if (back_btn != NULL) {
 494                 elm_object_style_set(back_btn, NAVI_BACK_BUTTON_STYLE); /* take into effect */
 495         }
 496 }
 497
 498 static void __setting_storage_main_launch_ug_layout_cb(ui_gadget_h ug, enum ug_mode mode, void *priv)
 499 {
 500         SETTING_TRACE_BEGIN;
 501         retm_if(priv == NULL, "priv is NULL");
 502         SettingStorageUG *ad = (SettingStorageUG *) priv;
 503         Evas_Object *base = NULL;
 504         base = (Evas_Object *) ug_get_layout(ug);
 505         retm_if(base == NULL, "base is NULL");
 506
 507         switch (mode) {
 508         case UG_MODE_FULLVIEW:
 509                 evas_object_size_hint_weight_set(base, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
 510                 elm_win_resize_object_add(ad->win_get, base);
 511                 evas_object_show(base);
 512                 break;
 513         default:
 514                 /* do nothing */
 515                 break;
 516         }
 517 }
 518
 519 static void __setting_storage_main_launch_manage_app_ug(void *data)
 520 {
 521         SETTING_TRACE_BEGIN;
 522         /* error check */
 523         retm_if(data == NULL, "Data parameter is NULL");
 524
 525         SettingStorageUG *ad = (SettingStorageUG *) data;
 526
 527         service_h svc;
 528         if (service_create(&svc)) {
 529                 return;
 530         }
 531
 532         service_add_extra_data(svc, "viewtype", "manage-applications");
 533
 534         struct ug_cbs *cbs = (struct ug_cbs *)calloc(1, sizeof(struct ug_cbs));
 535         if (!cbs) {
 536                 SETTING_TRACE_ERROR("calloc failed");
 537                 service_destroy(svc);
 538                 return;
 539         }
 540         cbs->layout_cb = __setting_storage_main_launch_ug_layout_cb;
 541         cbs->result_cb = NULL;
 542         cbs->destroy_cb = __setting_storage_main_launch_ug_destroy_cb;
 543         cbs->priv = (void *)ad;
 544
 545         ui_gadget_h ug = ug_create(ad->ug, "setting-manage-applications-efl", UG_MODE_FULLVIEW, svc, cbs);
 546         if (NULL == ug) {       /* error handling */
 547                 SETTING_TRACE_ERROR("NULL == ug");
 548         }
 549
 550         //bundle_free(b);
 551         service_destroy(svc);
 552         FREE(cbs);
 553 }
 554
 555 static void __setting_storage_main_app_launch(char *app_name)
 556 {
 557         SETTING_TRACE_BEGIN;
 558         setting_retm_if(app_name == NULL, "app_name is NULL");
 559
 560         #if 0
 561         if(aul_app_is_running((const char *)app_name)) {
 562                 SETTING_TRACE_DEBUG("%s is already launched.", app_name);
 563                 aul_open_app((const char *)app_name);
 564         } else {
 565                 SETTING_TRACE_DEBUG("%s will be launched. ", app_name);
 566                 aul_launch_app((const char *)app_name, NULL);
 567         }
 568         #else
 569                 app_launcher(app_name);
 570         #endif
 571 }
 572
 573 static void __setting_storage_main_Gendial_mouse_up_cb(void *data, Evas_Object *obj, void *event_info)
 574 {
 575         SETTING_TRACE_BEGIN;
 576         /* error check */
 577         setting_retm_if(data == NULL, "Data parameter is NULL");
 578         Elm_Object_Item *item = (Elm_Object_Item *) event_info;
 579         elm_genlist_item_selected_set(item, 0);
 580         Setting_GenGroupItem_Data *list_item = (Setting_GenGroupItem_Data *) elm_object_item_data_get(item);
 581
 582         SettingStorageUG *ad = (SettingStorageUG *) data;
 583
 584         SETTING_TRACE("clicking item[%s]", _(list_item->keyStr));
 585
 586         if (!safeStrCmp("IDS_ST_BODY_APPLICATIONS", list_item->keyStr)) {
 587                 __setting_storage_main_launch_manage_app_ug(ad);
 588         } else if (!safeStrCmp(SETTING_STORAGE_DEFAULT_STORAGE_STR, list_item->keyStr)) {
 589                 setting_view_change(&setting_view_storage_main,
 590                                     &setting_view_storage_default_storage, ad);
 591         } else if (!safeStrCmp(SETTING_STORAGE_PICS_STR, list_item->keyStr)) {
 592                 __setting_storage_main_app_launch("org.tizen.gallery");
 593         } else if (!safeStrCmp(SETTING_STORAGE_DOWNS_STR, list_item->keyStr)) {
 594                 __setting_storage_main_app_launch("org.tizen.download-manager");
 595         } else if (!safeStrCmp(SETTING_STORAGE_AUDIO_STR, list_item->keyStr)) {
 596                 __setting_storage_main_app_launch("org.tizen.music-player");
 597         } else if (!safeStrCmp(SETTING_STORAGE_MISCES_STR, list_item->keyStr)) {
 598                 setting_view_change(&setting_view_storage_main,
 599                                     &setting_view_storage_miscellaneous_files, ad);
 600         } else {
 601                 // do nothing now
 602         }
 603 }
 604
 605 static int __setting_storage_main_check_mmc_status()
 606 {
 607         int ret = 0;
 608         struct stat parent_stat, mount_stat;
 609
 610         ret = stat(SETTING_STORAGE_MMC_PATH, &mount_stat);
 611         setting_retvm_if(ret != 0, -1, "get stat error : /opt/storage/sdcard");
 612
 613         ret = stat(SETTING_STORAGE_MMC_PARENT_PATH, &parent_stat);
 614         setting_retvm_if(ret != 0, -1, "get stat error : /opt/storage/sdcard/..");
 615
 616         /* Does not mounted, same st_dev */
 617         if(mount_stat.st_dev == parent_stat.st_dev) {
 618                 return 0;
 619         } else {        /* MMC mounted, diff st_dev */
 620                 return 1;
 621         }
 622 }
 623
 624 static void __setting_storage_main_sd_card_info_get(char* szTotal, char* szAvail)
 625 {
 626         int mmc_status = __setting_storage_main_check_mmc_status();
 627         setting_retm_if(mmc_status == -1, "check mmc status failed");
 628
 629         /* Does not mounted, same st_dev */
 630         if (mmc_status == 0) {
 631                 snprintf(szTotal, SETTING_STORAGE_MAX_STR_LEN, "%s", _("IDS_ST_HEADER_UNAVAILABLE"));
 632                 snprintf(szAvail, SETTING_STORAGE_MAX_STR_LEN, "%s", _("IDS_ST_HEADER_UNAVAILABLE"));
 633         }
 634         /*  MMC mounted, diff st_dev */
 635         else {
 636                 double dTotal = 0.0;
 637                 double dAvail = 0.0;
 638
 639                 int ret = SETTING_RETURN_SUCCESS;
 640                 ret = __setting_storage_main_fs_stat(&dTotal, &dAvail, SETTING_STORAGE_MMC_PATH);
 641                 setting_retm_if(ret == SETTING_RETURN_FAIL, "get sd card size detail failed");
 642
 643                 ret = __setting_storage_status_size_transition(dTotal, szTotal);
 644                 setting_retm_if(ret == SETTING_RETURN_FAIL, "__setting_storage_status_size_transition failed");
 645
 646                 ret = __setting_storage_status_size_transition(dAvail, szAvail);
 647                 setting_retm_if(ret == SETTING_RETURN_FAIL, "__setting_storage_status_size_transition failed");
 648
 649                 SETTING_TRACE("Total[%s], Avail[%s]", szTotal, szAvail);
 650         }
 651 }
 652
 653 static int __setting_storage_main_mmc_content_init(void *data, setting_storage_mmc_cb cb)
 654 {
 655         SETTING_TRACE_BEGIN;
 656         setting_retvm_if(NULL == data, SETTING_RETURN_FAIL, "data is NULL");
 657         setting_retvm_if(NULL == cb, SETTING_RETURN_FAIL, "cb is NULL");
 658         SettingStorageUG *ad = (SettingStorageUG *)data;
 659         if (ad->mmc_content == NULL) {
 660                 ad->mmc_content = (struct mmc_contents *)calloc(1, sizeof(struct mmc_contents *));
 661                 if (ad->mmc_content == NULL ) {
 662                         SETTING_TRACE_ERROR("calloc failed");
 663                         return SETTING_RETURN_FAIL;
 664                 }
 665         }
 666         ad->mmc_content->mmc_cb = cb;
 667         ad->mmc_content->user_data = ad;
 668         return SETTING_RETURN_SUCCESS;
 669 }
 670
 671 static void __setting_storage_status_sd_card_popup_format_response_cb(void *data,
 672                                                          Evas_Object *obj, void *event_info)
 673 {
 674         SETTING_TRACE_BEGIN;
 675         setting_retm_if(data == NULL, "Data parameter is NULL");
 676         SettingStorageUG *ad = (SettingStorageUG *)data;
 677
 678         if (ad->popup) {
 679                 evas_object_del(ad->popup);
 680                 ad->popup = NULL;
 681         }
 682
 683         char sd_total[SETTING_STORAGE_MAX_STR_LEN] = { 0, };
 684         char sd_available[SETTING_STORAGE_MAX_STR_LEN] = { 0, };
 685         __setting_storage_main_sd_card_info_get(sd_total, sd_available);
 686
 687         if (ad->sd_total) {
 688                 G_FREE(ad->sd_total->sub_desc);
 689                 ad->sd_total->sub_desc = (char *)g_strdup(sd_total);
 690                 elm_object_item_data_set(ad->sd_total->item, ad->sd_total);
 691                 elm_genlist_item_update(ad->sd_total->item);
 692         }
 693         if (ad->sd_available) {
 694                 G_FREE(ad->sd_available->sub_desc);
 695                 ad->sd_available->sub_desc = (char *)g_strdup(sd_available);
 696                 elm_object_item_data_set(ad->sd_available->item, ad->sd_available);
 697                 elm_genlist_item_update(ad->sd_available->item);
 698         }
 699 }
 700
 701 static void __setting_storage_status_sd_card_popup_response_cb(void *data,
 702                                                          Evas_Object *obj, void *event_info)
 703 {
 704         SETTING_TRACE_BEGIN;
 705         setting_retm_if(data == NULL, "Data parameter is NULL");
 706         SettingStorageUG *ad = (SettingStorageUG *)data;
 707
 708         if (ad->popup) {
 709                 evas_object_del(ad->popup);
 710                 ad->popup = NULL;
 711         }
 712 }
 713
 714 static void __setting_storage_main_sd_card_mount_cb(int val, void *data)
 715 {
 716         SETTING_TRACE_BEGIN;
 717         setting_retm_if(data == NULL, "Data parameter is NULL");
 718         SettingStorageUG *ad = (SettingStorageUG *) data;
 719
 720         if (ad->popup) {
 721                 evas_object_del(ad->popup);
 722                 ad->popup = NULL;
 723         }
 724
 725         char *desc = NULL;
 726         if (val == SETTING_STORAGE_SYSMAN_REQUEST_SUCCESS) {
 727                 /* do nothing */
 728                 SETTING_TRACE("mount success");
 729                 return;
 730         } else if (val == SETTING_STORAGE_SYSMAN_REQUEST_MOUNT_ALREADY) {
 731                 desc = _(SETTING_STORAGE_SD_CARD_MOUNT_ALREADY_DESC);
 732         } else {
 733                 desc = _("IDS_COM_POP_FAILED");
 734         }
 735
 736         ad->popup = setting_create_popup_without_btn(ad, ad->win_get, NULL, desc,
 737                                  __setting_storage_status_sd_card_popup_response_cb,
 738                                  SETTING_STORAGE_POPUP_TIMER, FALSE, FALSE);
 739 }
 740
 741 static void __setting_storage_main_sd_card_unmount_cb(int val, void *data)
 742 {
 743         SETTING_TRACE_BEGIN;
 744         setting_retm_if(data == NULL, "Data parameter is NULL");
 745         SettingStorageUG *ad = (SettingStorageUG *) data;
 746
 747         if (ad->popup) {
 748                 evas_object_del(ad->popup);
 749                 ad->popup = NULL;
 750         }
 751
 752         if (val == SETTING_STORAGE_SYSMAN_REQUEST_SUCCESS) {
 753                 /* do nothing */
 754                 SETTING_TRACE("unmount success");
 755                 return;
 756         } else {
 757                 ad->popup = setting_create_popup_without_btn(ad, ad->win_get, NULL, _("IDS_COM_POP_FAILED"),
 758                                          __setting_storage_status_sd_card_popup_response_cb,
 759                                          SETTING_STORAGE_POPUP_TIMER, FALSE, FALSE);
 760         }
 761 }
 762
 763 static void __setting_storage_main_sd_card_mount_unmount(void *data)
 764 {
 765         SETTING_TRACE_BEGIN;
 766         setting_retm_if(data == NULL, "Data parameter is NULL");
 767         SettingStorageUG *ad = (SettingStorageUG *)data;
 768
 769         int mmc_status = __setting_storage_main_check_mmc_status();
 770         setting_retm_if(mmc_status == -1, "check mmc status failed");
 771
 772         if (ad->popup) {
 773                 evas_object_del(ad->popup);
 774                 ad->popup = NULL;
 775         }
 776
 777         /* Show progressbar popup */
 778         ad->popup = setting_create_popup_with_progressbar(ad, ad->win_get,
 779                                                  "pending_list", NULL, NULL,
 780                                                  __setting_storage_status_sd_card_popup_response_cb,
 781                                                  SETTING_STORAGE_PROGRESSBAR_TIMEOUT, TRUE, TRUE);
 782
 783         int ret = -1;
 784         /* Does not mounted, same st_dev */
 785         if (mmc_status == 0) {
 786                 ret = __setting_storage_main_mmc_content_init(ad, __setting_storage_main_sd_card_mount_cb);
 787                 if (ret == SETTING_RETURN_FAIL) {
 788                         SETTING_TRACE_ERROR("__setting_storage_main_mmc_content_init fail");
 789                         if (ad->popup) {
 790                                 evas_object_del(ad->popup);
 791                                 ad->popup = NULL;
 792                         }
 793                         ad->popup = setting_create_popup_without_btn(ad, ad->win_get,
 794                                                  NULL, _("IDS_COM_POP_FAILED"),
 795                                                  __setting_storage_status_sd_card_popup_response_cb,
 796                                                  SETTING_STORAGE_POPUP_TIMER, FALSE, FALSE);
 797                         return;
 798                 }
 799                 ret = sysman_request_mount_mmc(ad->mmc_content);
 800                 if (ret == -1) {
 801                         SETTING_TRACE_ERROR("fail to call sysman_request_mount_mmc");
 802                 }
 803         }
 804         /*  MMC mounted, diff st_dev */
 805         else {
 806                 ret = __setting_storage_main_mmc_content_init(ad, __setting_storage_main_sd_card_unmount_cb);
 807                 if (ret == SETTING_RETURN_FAIL) {
 808                         SETTING_TRACE_ERROR("__setting_storage_main_sd_card_unmount_cb fail");
 809                         if (ad->popup) {
 810                                 evas_object_del(ad->popup);
 811                                 ad->popup = NULL;
 812                         }
 813                         ad->popup = setting_create_popup_without_btn(ad, ad->win_get,
 814                                                  NULL, _("IDS_COM_POP_FAILED"),
 815                                                  __setting_storage_status_sd_card_popup_response_cb,
 816                                                  SETTING_STORAGE_POPUP_TIMER, FALSE, FALSE);
 817                         return;
 818                 }
 819
 820                 ret = sysman_request_unmount_mmc(ad->mmc_content,
 821                                                  MNT_FORCE);    /*  1 = MNT_FORCE */
 822                 if (ret == -1) {
 823                         SETTING_TRACE_ERROR("fail to call sysman_request_unmount_mmc");
 824                 }
 825         }
 826
 827         /*  if fail, popup failed info */
 828         if (ret == -1) {
 829                 if (ad->popup) {
 830                         evas_object_del(ad->popup);
 831                         ad->popup = NULL;
 832                 }
 833                 ad->popup = setting_create_popup_without_btn(ad, ad->win_get,
 834                                                  NULL, _("IDS_COM_POP_FAILED"),
 835                                                  __setting_storage_status_sd_card_popup_response_cb,
 836                                                  SETTING_STORAGE_POPUP_TIMER, FALSE, FALSE);
 837         }
 838 }
 839
 840
 841 static void __setting_storage_main_sd_card_format_cb(int val, void *data)
 842 {
 843         SETTING_TRACE_BEGIN;
 844         setting_retm_if(data == NULL, "Data parameter is NULL");
 845         SettingStorageUG *ad = (SettingStorageUG *) data;
 846
 847         if (ad->popup) {
 848                 evas_object_del(ad->popup);
 849                 ad->popup = NULL;
 850         }
 851
 852         if (val == SETTING_STORAGE_SYSMAN_REQUEST_SUCCESS) {
 853                 ad->popup = setting_create_popup_without_btn(ad, ad->win_get, NULL, _("IDS_COM_POP_SUCCESS"),
 854                                          __setting_storage_status_sd_card_popup_format_response_cb,
 855                                          SETTING_STORAGE_POPUP_TIMER, FALSE, FALSE);
 856
 857         } else {
 858                 ad->popup = setting_create_popup_without_btn(ad, ad->win_get, NULL, _("IDS_COM_POP_FAILED"),
 859                                          __setting_storage_status_sd_card_popup_response_cb,
 860                                          SETTING_STORAGE_POPUP_TIMER, FALSE, FALSE);
 861         }
 862 }
 863
 864 static void __setting_storage_main_sd_card_format_popup_yes(void *data)
 865 {
 866         SETTING_TRACE_BEGIN;
 867         setting_retm_if(data == NULL, "Data parameter is NULL");
 868         SettingStorageUG *ad = (SettingStorageUG *) data;
 869
 870         if (ad->popup) {
 871                 evas_object_del(ad->popup);
 872                 ad->popup = NULL;
 873         }
 874
 875         /* Show Formatting..... popup */
 876         ad->popup = setting_create_popup_with_progressbar(ad, ad->win_get,
 877                                                  "list_process", _("IDS_ST_POP_MSG_FORMATTING"),
 878                                                  NULL, __setting_storage_status_sd_card_popup_response_cb,
 879                                                  SETTING_STORAGE_PROGRESSBAR_TIMEOUT, TRUE, TRUE);
 880
 881         int ret = __setting_storage_main_mmc_content_init(ad, __setting_storage_main_sd_card_format_cb);
 882         if (ret == SETTING_RETURN_FAIL) {
 883                 SETTING_TRACE_ERROR("__setting_storage_main_mmc_content_init fail");
 884                 if (ad->popup) {
 885                         evas_object_del(ad->popup);
 886                         ad->popup = NULL;
 887                 }
 888                 ad->popup = setting_create_popup_without_btn(ad, ad->win_get,
 889                                                  NULL, _("IDS_COM_POP_FAILED"),
 890                                                  __setting_storage_status_sd_card_popup_response_cb,
 891                                                  SETTING_STORAGE_POPUP_TIMER, FALSE, FALSE);
 892                 return;
 893         }
 894
 895         ret = sysman_request_format_mmc(ad->mmc_content);
 896         /*  if fail, destory popup */
 897         if (ret == -1) {
 898                 SETTING_TRACE_ERROR("fail to call sysman_request_format_mmc");
 899                 if (ad->popup) {
 900                         evas_object_del(ad->popup);
 901                         ad->popup = NULL;
 902                 }
 903                 ad->popup = setting_create_popup_without_btn(ad, ad->win_get,
 904                                                  NULL, _("IDS_COM_POP_FAILED"),
 905                                                  __setting_storage_status_sd_card_popup_response_cb,
 906                                                  SETTING_STORAGE_POPUP_TIMER, FALSE, FALSE);
 907         }
 908 }
 909
 910 static void __setting_storage_main_sd_card_format_popup_no(void *data)
 911 {
 912         SETTING_TRACE_BEGIN;
 913         setting_retm_if(data == NULL, "Data parameter is NULL");
 914         SettingStorageUG *ad = (SettingStorageUG *) data;
 915
 916         if (ad->popup) {
 917                 evas_object_del(ad->popup);
 918                 ad->popup = NULL;
 919         }
 920 }
 921
 922 static void __setting_storage_main_sd_card_ask_format_resp_cb(void *data, Evas_Object *obj, void *event_info)
 923 {
 924         SETTING_TRACE_BEGIN;
 925         setting_retm_if(data == NULL, "Data parameter is NULL");
 926         int response_type = btn_type(obj);
 927         if (POPUP_RESPONSE_OK == response_type) {
 928                 __setting_storage_main_sd_card_format_popup_yes(data);
 929         } else if (POPUP_RESPONSE_CANCEL == response_type) {
 930                 __setting_storage_main_sd_card_format_popup_no(data);
 931         }
 932 }
 933
 934 static void __setting_storage_main_sd_card_format_popup_create(void *data)
 935 {
 936         SETTING_TRACE_BEGIN;
 937         setting_retm_if(data == NULL, "Data parameter is NULL");
 938         SettingStorageUG *ad = (SettingStorageUG *) data;
 939
 940         if (ad->popup) {
 941                 evas_object_del(ad->popup);
 942                 ad->popup = NULL;
 943         }
 944
 945         ad->popup = setting_create_popup_with_btn(ad, ad->win_get, NULL,
 946                                          _(SETTING_STORAGE_FORMAT_ASK_MSG),
 947                                          __setting_storage_main_sd_card_ask_format_resp_cb, 0,
 948                                          2, _("IDS_COM_SK_YES"),_("IDS_COM_SK_NO"));
 949 }
 950
 951 static void __setting_storage_main_mouse_up_Gendial_list_cb(void *data, Evas_Object *obj,
 952                                                void *event_info)
 953 {
 954         SETTING_TRACE_BEGIN;
 955         setting_retm_if(data == NULL, "Data parameter is NULL");
 956         setting_retm_if(event_info == NULL, "Invalid argument: event info is NULL");
 957
 958         SettingStorageUG *ad = (SettingStorageUG *) data;
 959         Elm_Object_Item *item = (Elm_Object_Item *) event_info;
 960         elm_genlist_item_selected_set(item, 0);
 961         Setting_GenGroupItem_Data *list_item = (Setting_GenGroupItem_Data *) elm_object_item_data_get(item);
 962
 963         SETTING_TRACE("clicking item[%s]", _(list_item->keyStr));
 964         if (list_item == ad->sd_mount) {
 965                 __setting_storage_main_sd_card_mount_unmount(ad);
 966         } else if (list_item == ad->sd_format) {
 967                 __setting_storage_main_sd_card_format_popup_create(ad);
 968         }
 969 }
 970
 971 static void __setting_storage_main_sd_card_info_append(void* data)
 972 {
 973         SETTING_TRACE_BEGIN;
 974         setting_retm_if(data == NULL, "Data parameter is NULL");
 975         SettingStorageUG *ad = (SettingStorageUG *) data;
 976
 977         /* remove the sd info items */
 978         if (ad->sd_mount) {
 979                 elm_object_item_del(ad->sd_mount->item);
 980                 ad->sd_mount = NULL;
 981         }
 982         if (ad->sd_total) {
 983                 elm_object_item_del(ad->sd_total->item);
 984                 ad->sd_total = NULL;
 985         }
 986         if (ad->sd_available) {
 987                 elm_object_item_del(ad->sd_available->item);
 988                 ad->sd_available = NULL;
 989         }
 990         if (ad->sd_format) {
 991                 elm_object_item_del(ad->sd_format->item);
 992                 ad->sd_format = NULL;
 993         }
 994
 995         int mmc_mode = VCONFKEY_SYSMAN_MMC_REMOVED;
 996         int ret = vconf_get_int(VCONFKEY_SYSMAN_MMC_STATUS, &mmc_mode);
 997         setting_retm_if(ret != 0, "Get vconf failed");
 998
 999         if (mmc_mode == VCONFKEY_SYSMAN_MMC_REMOVED) {
1000                 ad->sd_mount = setting_create_Gendial_field_def(ad->genlist, &(ad->itc_2text_2), NULL,
1001                                              ad, SWALLOW_Type_INVALID, NULL,
1002                                              NULL, 0, SETTING_STORAGE_MOUNT_STR,
1003                                              _(SETTING_STORAGE_INSERT_STR),
1004                                              NULL);
1005                 if (ad->sd_mount) {
1006                         setting_disable_genlist_item(ad->sd_mount->item);
1007                 }
1008         } else if (mmc_mode == VCONFKEY_SYSMAN_MMC_INSERTED_NOT_MOUNTED) {
1009                 ad->sd_mount = setting_create_Gendial_field_def(ad->genlist, &(ad->itc_2text_2),
1010                                              __setting_storage_main_mouse_up_Gendial_list_cb,
1011                                              ad, SWALLOW_Type_INVALID, NULL,
1012                                              NULL, 0, SETTING_STORAGE_MOUNT_STR,
1013                                              _(SETTING_STORAGE_INSERT_STR),
1014                                              NULL);
1015         } else if (mmc_mode == VCONFKEY_SYSMAN_MMC_MOUNTED) {
1016                 char sd_total[SETTING_STORAGE_MAX_STR_LEN] = { 0, };
1017                 char sd_available[SETTING_STORAGE_MAX_STR_LEN] = { 0, };
1018                 __setting_storage_main_sd_card_info_get(sd_total, sd_available);
1019
1020                 ad->sd_total = setting_create_Gendial_field_def(ad->genlist, &(ad->itc_2text_2), NULL,
1021                                                      ad, SWALLOW_Type_INVALID, NULL,
1022                                                      NULL, 0, "IDS_ST_BODY_TOTAL_SPACE",
1023                                                      sd_total,
1024                                                      NULL);
1025                 if (ad->sd_total) {
1026                         ad->sd_total->userdata = ad;
1027                         elm_genlist_item_select_mode_set(ad->sd_total->item, ELM_OBJECT_SELECT_MODE_DISPLAY_ONLY);
1028                 } else {
1029                         SETTING_TRACE_ERROR("ad->sd_total is NULL");
1030                 }
1031
1032                 ad->sd_available = setting_create_Gendial_field_def(ad->genlist, &(ad->itc_2text_2), NULL,
1033                                                      ad, SWALLOW_Type_INVALID, NULL,
1034                                                      NULL, 0, "IDS_ST_BODY_AVAILABLE_SPACE",
1035                                                      sd_available,
1036                                                      NULL);
1037                 if (ad->sd_available) {
1038                         ad->sd_available->userdata = ad;
1039                         elm_genlist_item_select_mode_set(ad->sd_available->item, ELM_OBJECT_SELECT_MODE_DISPLAY_ONLY);
1040                 } else {
1041                         SETTING_TRACE_ERROR("ad->sd_available is NULL");
1042                 }
1043
1044                 ad->sd_mount = setting_create_Gendial_field_def(ad->genlist, &(ad->itc_1text),
1045                                                      __setting_storage_main_mouse_up_Gendial_list_cb,
1046                                                      ad, SWALLOW_Type_INVALID, NULL,
1047                                                      NULL, 0, "IDS_ST_BODY_UNMOUNT_SD_CARD", NULL,
1048                                                      NULL);
1049                 if (ad->sd_mount) {
1050                         ad->sd_mount->userdata = ad;
1051                 } else {
1052                         SETTING_TRACE_ERROR("ad->sd_mount is NULL");
1053                 }
1054
1055                 ad->sd_format = setting_create_Gendial_field_def(ad->genlist, &(ad->itc_1text),
1056                                                      __setting_storage_main_mouse_up_Gendial_list_cb,
1057                                                      ad, SWALLOW_Type_INVALID, NULL,
1058                                                      NULL, 0,
1059                                                      "IDS_ST_BODY_FORMAT_SD_CARD",
1060                                                      NULL, NULL);
1061                 if (ad->sd_format) {
1062                         ad->sd_format->userdata = ad;
1063                 } else {
1064                         SETTING_TRACE_ERROR("ad->sd_format is NULL");
1065                 }
1066         } else {
1067                 SETTING_TRACE_ERROR("error status of sd card");
1068         }
1069
1070         Elm_Object_Item *item = NULL;
1071         item = elm_genlist_item_append(ad->genlist, &itc_bottom_seperator, NULL, NULL,
1072                                 ELM_GENLIST_ITEM_NONE, NULL, NULL);
1073         elm_genlist_item_select_mode_set(item, ELM_OBJECT_SELECT_MODE_DISPLAY_ONLY);
1074 }
1075
1076 static void __setting_storage_vconf_change_cb(keynode_t *key, void *data)
1077 {
1078         SETTING_TRACE_BEGIN;
1079         setting_retm_if(NULL == key, "key is NULL");
1080         setting_retm_if(NULL == data, "data is NULL");
1081         SettingStorageUG *ad = (SettingStorageUG *)data;
1082         int status = vconf_keynode_get_int(key);
1083         char *vconf_name = vconf_keynode_get_name(key);
1084
1085         if (!safeStrCmp(vconf_name, VCONFKEY_SYSMAN_MMC_STATUS)) {
1086                 SETTING_TRACE("status:%d", status);
1087                 /* remove last item -> seperator */
1088                 Elm_Object_Item *last_item = NULL;
1089                 last_item = elm_genlist_last_item_get(ad->genlist);
1090                 if (last_item) {
1091                         elm_object_item_del(last_item);
1092                 }
1093                 __setting_storage_main_sd_card_info_append(ad);
1094         }
1095 }
1096
1097 /* ***************************************************
1098  *
1099  *basic func
1100  *
1101  ***************************************************/
1102 static int setting_storage_main_create(void *cb)
1103 {
1104         SETTING_TRACE_BEGIN;
1105         /* error check */
1106         retv_if(cb == NULL, SETTING_GENERAL_ERR_NULL_DATA_PARAMETER);
1107
1108         SettingStorageUG *ad = (SettingStorageUG *) cb;
1109
1110         retvm_if(ad->win_main_layout == NULL, SETTING_DRAW_ERR_FAIL_LOAD_EDJ,
1111                  "win_main_layout is NULL");
1112
1113         int ret = SETTING_RETURN_SUCCESS;
1114
1115         ad->ly_main =
1116             setting_create_layout_navi_bar_genlist(ad->win_main_layout,
1117                                                    ad->win_get,
1118                                                    _(KeyStr_Storage),
1119                                                    _("IDS_COM_BODY_BACK"),
1120                                                    NULL,
1121                                                    __setting_storage_main_click_softkey_back_cb,
1122                                                    NULL,
1123                                                    ad, &ad->genlist, &ad->navibar);
1124
1125         ad->itc_2text_1icon_4.item_style = "dialogue/2text.1icon.4";
1126         ad->itc_2text_1icon_4.func.text_get = __gl_text_get;
1127         ad->itc_2text_1icon_4.func.content_get = __gl_content_get;
1128         ad->itc_2text_1icon_4.func.state_get = NULL;
1129         ad->itc_2text_1icon_4.func.del = __gl_del;
1130
1131         __setting_storage_main_internal_storage_status_get(ad);
1132
1133         __setting_storage_main_pictures_videos_status_get(ad);
1134
1135         __setting_storage_main_downloads_status_get(ad);
1136
1137         __setting_storage_main_audio_status_get(ad);
1138
1139         Elm_Object_Item *item = NULL;
1140
1141         if (!isEmulBin()) {
1142                 item = elm_genlist_item_append(ad->genlist, &itc_seperator, NULL, NULL,
1143                                         ELM_GENLIST_ITEM_NONE, NULL, NULL);
1144                 elm_genlist_item_select_mode_set(item, ELM_OBJECT_SELECT_MODE_DISPLAY_ONLY);
1145
1146                 /* Default storage */
1147                 setting_create_Gendial_field_def(ad->genlist, &(ad->itc_1text),
1148                                          __setting_storage_main_Gendial_mouse_up_cb,
1149                                          ad, SWALLOW_Type_INVALID, NULL, NULL,
1150                                          0, SETTING_STORAGE_DEFAULT_STORAGE_STR,
1151                                          NULL, NULL);
1152         }
1153
1154         setting_create_Gendial_field_titleItem(ad->genlist, &(ad->itc_group_item),
1155                                                SETTING_STORAGE_INTERNAL_STORAGE_STR,
1156                                                NULL);
1157
1158         /* Total space */
1159         char total_desc[SETTING_STORAGE_MAX_STR_LEN + 1] = {0,};
1160         ret = __setting_storage_status_size_transition(ad->internal_status.dTotal, total_desc);
1161         setting_retvm_if(ret == SETTING_RETURN_FAIL, SETTING_RETURN_FAIL, "failed to transform")
1162
1163         /* status */
1164         ad->internal = (Setting_GenGroupItem_Data *) calloc(1, sizeof(Setting_GenGroupItem_Data));
1165         setting_retvm_if(!ad->internal, SETTING_RETURN_FAIL, "calloc failed");
1166
1167         if (ad->internal) {
1168                 ad->internal->userdata = ad;
1169                 ad->internal->keyStr = (char *)g_strdup(total_desc);
1170                 ad->internal->item = elm_genlist_item_append(ad->genlist, &(ad->itc_2text_1icon_4), ad->internal, NULL,
1171                                             ELM_GENLIST_ITEM_NONE, NULL, NULL);
1172                 elm_genlist_item_select_mode_set(ad->internal->item, ELM_OBJECT_SELECT_MODE_DISPLAY_ONLY);
1173         } else {
1174                 SETTING_TRACE_ERROR("ad->internal is NULL");
1175                 return SETTING_RETURN_FAIL;
1176         }
1177
1178         /* Applications */
1179         ad->apps_status.dTotal = 230.45 * 1024 * 1024; /* for test*/
1180         char apps_desc[SETTING_STORAGE_MAX_STR_LEN + 1] = {0,};
1181         ret = __setting_storage_status_size_transition(ad->apps_status.dTotal, apps_desc);
1182         setting_retvm_if(ret == SETTING_RETURN_FAIL, SETTING_RETURN_FAIL, "failed to transform")
1183
1184         ad->apps = setting_create_Gendial_field_def(ad->genlist, &(ad->itc_2text_1icon_3),
1185                                              __setting_storage_main_Gendial_mouse_up_cb,
1186                                              ad, SWALLOW_Type_INVALID, SETTING_STORAGE_APPS_ICON_PATH,
1187                                              NULL, 0, "IDS_ST_BODY_APPLICATIONS",
1188                                              apps_desc, NULL);
1189         if (ad->apps) {
1190                 ad->apps->userdata = ad;
1191         } else {
1192                 SETTING_TRACE_ERROR("ad->apps is NULL");
1193                 return SETTING_RETURN_FAIL;
1194         }
1195
1196         /* Pictures, Videos */
1197         char pics_videos_desc[SETTING_STORAGE_MAX_STR_LEN + 1] = {0,};
1198         ret = __setting_storage_status_size_transition(ad->pics_videos_status.dTotal, pics_videos_desc);
1199         setting_retvm_if(ret == SETTING_RETURN_FAIL, SETTING_RETURN_FAIL, "failed to transform")
1200         ad->pics_videos = setting_create_Gendial_field_def(ad->genlist, &(ad->itc_2text_1icon_3),
1201                                              __setting_storage_main_Gendial_mouse_up_cb,
1202                                              ad, SWALLOW_Type_INVALID, SETTING_STORAGE_PICS_ICON_PATH,
1203                                              NULL, 0, SETTING_STORAGE_PICS_STR,
1204                                              pics_videos_desc, NULL);
1205         if (ad->pics_videos) {
1206                 ad->pics_videos->userdata = ad;
1207         } else {
1208                 SETTING_TRACE_ERROR("ad->pics_videos is NULL");
1209                 return SETTING_RETURN_FAIL;
1210         }
1211
1212         /* Downloads */
1213         char downloads_desc[SETTING_STORAGE_MAX_STR_LEN + 1] = {0,};
1214         ret = __setting_storage_status_size_transition(ad->downloads_status.dTotal, downloads_desc);
1215         setting_retvm_if(ret == SETTING_RETURN_FAIL, SETTING_RETURN_FAIL, "failed to transform")
1216         ad->downloads = setting_create_Gendial_field_def(ad->genlist, &(ad->itc_2text_1icon_3),
1217                                              __setting_storage_main_Gendial_mouse_up_cb,
1218                                              ad, SWALLOW_Type_INVALID, SETTING_STORAGE_DOWNS_ICON_PATH,
1219                                              NULL, 0, SETTING_STORAGE_DOWNS_STR,
1220                                              downloads_desc,
1221                                              NULL);
1222         if (ad->downloads) {
1223                 ad->downloads->userdata = ad;
1224         } else {
1225                 SETTING_TRACE_ERROR("ad->downloads is NULL");
1226                 return SETTING_RETURN_FAIL;
1227         }
1228
1229         /* Audio */
1230         char audio_desc[SETTING_STORAGE_MAX_STR_LEN + 1] = {0,};
1231         ret = __setting_storage_status_size_transition(ad->audio_status.dTotal, audio_desc);
1232         setting_retvm_if(ret == SETTING_RETURN_FAIL, SETTING_RETURN_FAIL, "failed to transform")
1233         ad->audio = setting_create_Gendial_field_def(ad->genlist, &(ad->itc_2text_1icon_3),
1234                                              __setting_storage_main_Gendial_mouse_up_cb,
1235                                              ad, SWALLOW_Type_INVALID, SETTING_STORAGE_AUDIO_ICON_PATH,
1236                                              NULL, 0, SETTING_STORAGE_AUDIO_STR,
1237                                              audio_desc,
1238                                              NULL);
1239         if (ad->audio) {
1240                 ad->audio->userdata = ad;
1241         } else {
1242                 SETTING_TRACE_ERROR("ad->audio is NULL");
1243                 return SETTING_RETURN_FAIL;
1244         }
1245
1246         /* Miscellaneous files */
1247         ad->others_status.dTotal = ad->internal_status.dTotal - ad->internal_status.dAvail
1248                                  - ad->apps_status.dTotal - ad->pics_videos_status.dTotal
1249                                  - ad->downloads_status.dTotal - ad->audio_status.dTotal;
1250         ad->others_status.dAvail = 0.0;
1251         char others_desc[SETTING_STORAGE_MAX_STR_LEN + 1] = {0,};
1252         ret = __setting_storage_status_size_transition(ad->others_status.dTotal, others_desc);
1253         setting_retvm_if(ret == SETTING_RETURN_FAIL, SETTING_RETURN_FAIL, "failed to transform")
1254
1255         ad->others = setting_create_Gendial_field_def(ad->genlist, &(ad->itc_2text_1icon_3),
1256                                              __setting_storage_main_Gendial_mouse_up_cb,
1257                                              ad, SWALLOW_Type_INVALID, SETTING_STORAGE_MISCES_ICON_PATH,
1258                                              NULL, 0, SETTING_STORAGE_MISCES_STR,
1259                                              others_desc, NULL);
1260         if (ad->others) {
1261                 ad->others->userdata = ad;
1262         } else {
1263                 SETTING_TRACE_ERROR("ad->others is NULL");
1264                 return SETTING_RETURN_FAIL;
1265         }
1266
1267         /* Available */
1268         char avail_desc[SETTING_STORAGE_MAX_STR_LEN + 1] = {0,};
1269         ret = __setting_storage_status_size_transition(ad->internal_status.dAvail, avail_desc);
1270         setting_retvm_if(ret == SETTING_RETURN_FAIL, SETTING_RETURN_FAIL, "failed to transform")
1271
1272         ad->avail = setting_create_Gendial_field_def(ad->genlist, &(ad->itc_2text_1icon_3), NULL,
1273                                              ad, SWALLOW_Type_INVALID, SETTING_STORAGE_AVAIL_ICON_PATH,
1274                                              NULL, 0, SETTING_STORAGE_AVAIL_STR,
1275                                              avail_desc, NULL);
1276         if (ad->avail) {
1277                 ad->avail->userdata = ad;
1278                 elm_genlist_item_select_mode_set(ad->avail->item, ELM_OBJECT_SELECT_MODE_DISPLAY_ONLY);
1279         } else {
1280                 SETTING_TRACE_ERROR("ad->avail is NULL");
1281                 return SETTING_RETURN_FAIL;
1282         }
1283
1284         if (!isEmulBin()) {
1285                 /* Format USB storage */
1286                 setting_create_Gendial_field_def(ad->genlist, &(ad->itc_1text), NULL,
1287                                                      ad, SWALLOW_Type_INVALID, NULL,
1288                                                      NULL, 0,
1289                                                      SETTING_STORAGE_FORMAT_STR,
1290                                                      NULL, NULL);
1291
1292                 setting_create_Gendial_field_def(ad->genlist, &(ad->itc_bg_1icon), NULL,
1293                                                  ad, SWALLOW_Type_LAYOUT_SPECIALIZTION_X,
1294                                                  NULL, NULL, 0, SETTING_STORAGE_FORMAT_DESC_STR, NULL,
1295                                                  NULL);
1296
1297                 /* SD card info */
1298                 setting_create_Gendial_field_titleItem(ad->genlist, &(ad->itc_group_item),
1299                                                "IDS_ST_BODY_SD_CARD", NULL);
1300                 __setting_storage_main_sd_card_info_append(ad);
1301
1302                 ret = vconf_notify_key_changed(VCONFKEY_SYSMAN_MMC_STATUS,
1303                                 __setting_storage_vconf_change_cb, ad);
1304                 if (ret != 0) {
1305                         SETTING_TRACE_ERROR("call vconf_notify_key_changed failed");
1306                 }
1307         } else {
1308                 item = elm_genlist_item_append(ad->genlist, &itc_bottom_seperator, NULL, NULL,
1309                                         ELM_GENLIST_ITEM_NONE, NULL, NULL);
1310                 elm_genlist_item_select_mode_set(item, ELM_OBJECT_SELECT_MODE_DISPLAY_ONLY);
1311         }
1312
1313         setting_view_storage_main.is_create = 1;
1314         return SETTING_RETURN_SUCCESS;
1315 }
1316
1317 static int setting_storage_main_destroy(void *cb)
1318 {
1319         /* error check */
1320         retv_if(cb == NULL, SETTING_GENERAL_ERR_NULL_DATA_PARAMETER);
1321
1322         SettingStorageUG *ad = (SettingStorageUG *) cb;
1323
1324         if (!isEmulBin()) {
1325                 int ret = vconf_ignore_key_changed(VCONFKEY_SYSMAN_MMC_STATUS,
1326                                 __setting_storage_vconf_change_cb);
1327                 if (ret != 0) {
1328                         SETTING_TRACE_ERROR("call vconf_ignore_key_changed failed");
1329                 }
1330         }
1331
1332         if (ad->popup) {
1333                 evas_object_del(ad->popup);
1334                 ad->popup = NULL;
1335         }
1336
1337         if (ad->ly_main != NULL) {
1338                 evas_object_del(ad->ly_main);
1339                 setting_view_storage_main.is_create = 0;
1340         }
1341
1342         return SETTING_RETURN_SUCCESS;
1343 }
1344
1345 static int setting_storage_main_update(void *cb)
1346 {
1347         SETTING_TRACE_BEGIN;
1348         /* error check */
1349         retv_if(cb == NULL, SETTING_GENERAL_ERR_NULL_DATA_PARAMETER);
1350
1351         SettingStorageUG *ad = (SettingStorageUG *) cb;
1352
1353         if (ad->ly_main != NULL) {
1354                 evas_object_show(ad->ly_main);
1355         }
1356
1357         return SETTING_RETURN_SUCCESS;
1358 }
1359
1360 static int setting_storage_main_cleanup(void *cb)
1361 {
1362         /* error check */
1363         retv_if(cb == NULL, SETTING_GENERAL_ERR_NULL_DATA_PARAMETER);
1364
1365         SettingStorageUG *ad = (SettingStorageUG *) cb;
1366
1367         if (ad->ly_main != NULL) {
1368                 evas_object_hide(ad->ly_main);
1369         }
1370
1371         return SETTING_RETURN_SUCCESS;
1372 }
1373
1374 /* ***************************************************
1375  *
1376  *call back func
1377  *
1378  ***************************************************/
1379
1380 static void __setting_storage_main_click_softkey_back_cb(void *data, Evas_Object *obj,
1381                                         void *event_info)
1382 {
1383         /* error check */
1384         ret_if(data == NULL);
1385
1386         SettingStorageUG *ad = (SettingStorageUG *) data;
1387         /* Send destroy request */
1388         ug_destroy_me(ad->ug);
1389 }