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

   1 /*
   2  * setting
   3  *
   4  * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd.
   5  *
   6  * Licensed under the Apache License, Version 2.0 (the "License");
   7  * you may not use this file except in compliance with the License.
   8  * You may obtain a copy of the License at
   9  *
  10  * http://www.apache.org/licenses/LICENSE-2.0
  11  *
  12  * Unless required by applicable law or agreed to in writing, software
  13  * distributed under the License is distributed on an "AS IS" BASIS,
  14  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  15  * See the License for the specific language governing permissions and
  16  * limitations under the License.
  17  *
  18  */
  19 #include <glib.h>
  20
  21 #include <media_content.h>
  22
  23 #include "setting-common-general-func.h"
  24 #include "setting-storage-SD.h"
  25 #include "setting-storage-USB.h"
  26 #include "setting-storage-utils.h"
  27 #include "setting-storage-async-worker.h"
  28 #include "setting-storage-main.h"
  29
  30 #define SETTING_STORAGE_PIE_RECT_WIDTH (300 * WIDGET_SCALE_FACTOR)
  31 #define SETTING_STORAGE_PIE_RECT_SIZE (300 * WIDGET_SCALE_FACTOR)
  32 //#define SETTING_STORAGE_PIE_CYCLE_SIZE (294 * WIDGET_SCALE_FACTOR)
  33 #define SETTING_STORAGE_PIE_CYCLE_SIZE (123 * WIDGET_SCALE_FACTOR)
  34 #define SETTING_STORAGE_ITEM_LIST_SIZE (180 * WIDGET_SCALE_FACTOR)
  35
  36 #define SETTING_STORAGE_APPS_ICON_PATH SETTING_ICON_PATH"/A01-1_icon_color_applications.png"
  37 #define SETTING_STORAGE_PICS_ICON_PATH SETTING_ICON_PATH"/A01-1_icon_color_pictures.png"
  38 #define SETTING_STORAGE_AUDIO_ICON_PATH SETTING_ICON_PATH"/A01-1_icon_color_Audio.png"
  39 #define SETTING_STORAGE_MISCES_ICON_PATH SETTING_ICON_PATH"/A01-1_icon_color_miscellaneous_files.png"
  40 #define SETTING_STORAGE_AVAIL_ICON_PATH SETTING_ICON_PATH"/A01-1_icon_color_available.png"
  41 #define SETTING_STORAGE_SYS_ICON_PATH SETTING_ICON_PATH"/A01-1_icon_color_system.png"
  42
  43 const char *storageUg_MMC_stat = VCONFKEY_SYSMAN_MMC_STATUS;
  44 const char *storageUg_ENCRYPT_stat = VCONFKEY_SDE_CRYPTO_STATE;
  45
  46 static setting_view setting_view_storage_main;
  47
  48 static inline void storageUg_main_pie_graph_cairo(      Evas_Object *pie_image,
  49                 SettingStorageUG *ad)
  50 {
  51         cairo_t *cr;
  52         double total_size;
  53         int cairo_w, cairo_h;
  54         double account_size = 0.0;
  55         cairo_surface_t *cairo_surface;
  56         double apps_sz = 0, pics_sz = 0, audio_size = 0, misces_sz = 0, internal_sz = 0, system_sz = 0;
  57
  58         ret_if(NULL == ad);
  59
  60         cairo_h = cairo_w = SETTING_STORAGE_PIE_CYCLE_SIZE;
  61
  62         total_size = ad->sz_inter_total;
  63
  64         if (total_size == 0)
  65         {
  66                 apps_sz = 0;
  67                 pics_sz = 0;
  68                 audio_size = 0;
  69                 misces_sz = 0;
  70                 internal_sz = 0;
  71         }
  72         else
  73         {
  74                 /* system memory */
  75                 system_sz = ad->sz_sys / total_size;
  76                 if (system_sz > 1 || system_sz < 0)
  77                         system_sz = 1;
  78
  79                 /* apps */
  80                 apps_sz = ad->sz_apps / total_size;
  81                 if (apps_sz > 1 || apps_sz < 0)
  82                         apps_sz = 1;
  83
  84                 /* pics */
  85                 pics_sz = ad->sz_pics_videos / total_size;
  86                 if (pics_sz > 1 || pics_sz < 0)
  87                         pics_sz = 1;
  88
  89                 /* audio */
  90                 audio_size = ad->sz_audio / total_size;
  91                 if (audio_size > 1 || audio_size < 0)
  92                         audio_size = 1;
  93
  94                 /* Miscellaneous Files */
  95                 misces_sz = ad->sz_misces / total_size;
  96                 if (misces_sz > 1 || misces_sz < 0)
  97                         misces_sz = 1;
  98
  99                 /* internal */
 100                 internal_sz = ad->sz_inter_avail / total_size;
 101                 if (internal_sz > 1 || internal_sz < 0)
 102                         internal_sz = 1;
 103         }
 104
 105         if (ad->cr)
 106         {
 107                 cairo_destroy(ad->cr);
 108                 ad->cr = NULL;
 109         }
 110
 111         cairo_surface = cairo_image_surface_create(CAIRO_FORMAT_ARGB32, cairo_w, cairo_h);
 112         if (NULL == cairo_surface)
 113         {
 114                 SETTING_TRACE_ERROR("cairo_image_surface_create() Fail");
 115                 return;
 116         }
 117
 118         cr = cairo_create(cairo_surface);
 119         cairo_surface_destroy(cairo_surface);
 120
 121         //all, use avaliable color
 122         cairo_set_line_width(cr, 4);
 123         cairo_arc(cr, cairo_w/2, cairo_h/2, cairo_w/2, 0, 2*M_PI);
 124         cairo_set_source_rgba(cr, 235/255., 235/255., 235/255., 1);
 125         cairo_fill(cr);
 126
 127         //system memory
 128         account_size = 0.75;
 129         cairo_line_to(cr, cairo_w/2, cairo_h/2);
 130         cairo_arc_negative(cr, cairo_w/2, cairo_h/2, cairo_w/2, account_size*2*M_PI,
 131                         (account_size-system_sz)*2*M_PI);
 132         cairo_set_source_rgba(cr, 153/255., 66/255., 194/255., 1);
 133         cairo_fill(cr);
 134         account_size -= system_sz;
 135
 136         //app
 137         cairo_line_to(cr, cairo_w/2, cairo_h/2);
 138         cairo_arc_negative(cr, cairo_w/2, cairo_h/2, cairo_w/2, account_size*2*M_PI,
 139                         (account_size-apps_sz)*2*M_PI);
 140         cairo_set_source_rgba(cr, 255/255., 189/255., 8/255., 1);
 141         cairo_fill(cr);
 142         account_size -= apps_sz;
 143
 144         //pic
 145         cairo_line_to(cr, cairo_w/2, cairo_h/2);
 146         cairo_arc_negative(cr, cairo_w/2, cairo_h/2, cairo_w/2, account_size*2*M_PI,
 147                         (account_size-pics_sz)*2*M_PI);
 148         cairo_set_source_rgba(cr, 119/255., 222/255., 60/255., 1);
 149         cairo_fill(cr);
 150         account_size -= pics_sz;
 151
 152         //audio
 153         cairo_line_to(cr, cairo_w/2, cairo_h/2);
 154         cairo_arc_negative(cr, cairo_w/2, cairo_h/2, cairo_w/2, account_size*2*M_PI,
 155                         (account_size-audio_size)*2*M_PI);
 156         cairo_set_source_rgba(cr, 28/255., 140/255., 252/255., 1);
 157         cairo_fill(cr);
 158         account_size -= audio_size;
 159
 160         //miscellaneous files
 161         cairo_line_to(cr, cairo_w/2, cairo_h/2);
 162         cairo_arc_negative(cr, cairo_w/2, cairo_h/2, cairo_w/2, account_size*2*M_PI,
 163                         (account_size-misces_sz)*2*M_PI);
 164         cairo_set_source_rgba(cr, 52/255., 220/255., 250/255., 1);
 165         cairo_fill(cr);
 166         account_size -= misces_sz;
 167
 168         evas_object_image_size_set(pie_image, cairo_w, cairo_h);
 169         evas_object_image_data_set(pie_image, cairo_image_surface_get_data(cairo_surface));
 170         evas_object_image_fill_set(pie_image, 0, 0, cairo_w, cairo_h);
 171         evas_object_resize(pie_image, cairo_w, cairo_h);
 172         ad->cr = cr;
 173 }
 174
 175 static inline void storageUg_main_part_pie_graph_set(Evas_Object *parent,
 176                 const char* part, void *data)
 177 {
 178         Evas *evas;
 179         int cairo_w, cairo_h;
 180         Evas_Object *clip;
 181         Evas_Object *pie_image;
 182         SettingStorageUG *ad = data;
 183
 184         ret_if(parent == NULL);
 185         ret_if(data == NULL);
 186
 187         cairo_h = cairo_w = SETTING_STORAGE_PIE_CYCLE_SIZE;
 188
 189         evas = evas_object_evas_get(parent);
 190         if (NULL == evas)
 191         {
 192                 SETTING_TRACE_ERROR("evas_object_evas_get() Fail");
 193                 return;
 194         }
 195
 196         clip = evas_object_rectangle_add(evas);
 197         evas_object_color_set(clip, 255, 255, 255, 255);
 198         setting_resize_object(clip, cairo_w, cairo_h);
 199
 200         pie_image = evas_object_image_add(evas);
 201         evas_object_color_set(pie_image, 255, 255, 255, 250);
 202         evas_object_clip_set(pie_image, clip);
 203         evas_object_show(pie_image);
 204         elm_object_part_content_set(parent, part, pie_image);
 205
 206         storageUg_main_pie_graph_cairo(pie_image, ad);
 207 }
 208
 209 Evas_Object* storageUg_main_pie_item_get_icon(void *data, Evas_Object *obj,
 210                 const char *part)
 211 {
 212         int layout_w, layout_h;
 213         double used_size;
 214         Evas_Object *layout;
 215         SettingStorageUG *ad = data;
 216         char size_str[STORAGEUG_MAX_STR_LEN] = {0};
 217         char final_str[STORAGEUG_MAX_STR_LEN] = {0};
 218
 219         retv_if(NULL == obj, NULL);
 220         retv_if(NULL == data, NULL);
 221         retvm_if(safeStrCmp(part, "elm.icon"), NULL, "part(%s) Invaild", part);
 222
 223         layout_w = -1;
 224         layout_h = SETTING_STORAGE_PIE_RECT_SIZE;
 225
 226         layout = elm_layout_add(obj);
 227         elm_layout_file_set(layout, SETTING_THEME_EDJ_NAME, "storage_pie");
 228
 229         evas_object_size_hint_weight_set(layout, EVAS_HINT_EXPAND, 0.0);
 230
 231         //title
 232         elm_object_part_text_set(layout, "storage_title.text",
 233                         _(STORAGEUG_STR_INTERNAL_STORAGE));
 234
 235         storageUg_size_to_str(ad->sz_inter_avail, size_str, sizeof(size_str));
 236         snprintf(final_str, sizeof(final_str), "%s %s", size_str,
 237                         _(STORAGEUG_STR_AVAIL));
 238         elm_object_part_text_set(layout, "storage_total.text", final_str);
 239
 240         used_size = ad->sz_inter_total - ad->sz_inter_avail;
 241         storageUg_size_to_str(used_size, size_str, sizeof(size_str));
 242         snprintf(final_str, sizeof(final_str), "%s %s", size_str,
 243                         _(STORAGEUG_STR_USED));
 244         elm_object_part_text_set(layout, "storage_used.text", final_str);
 245
 246         //pie
 247         storageUg_main_part_pie_graph_set(layout, "pie_rect", ad);
 248         setting_resize_object(layout, layout_w, layout_h);
 249         evas_object_show(layout);
 250
 251         return layout;
 252 }
 253
 254 Evas_Object* storageUg_color_item_content_get(void *data, Evas_Object *obj,
 255                 const char *part)
 256 {
 257         ret_if(data == NULL);
 258         Setting_GenGroupItem_Data *list_item = data;
 259         int color = list_item->color;
 260         if (!strcmp(part, "elm.icon.1")) {
 261                 Evas_Object *layout = elm_layout_add(obj);
 262                 elm_layout_file_set(layout, SETTING_THEME_EDJ_NAME, "storage_elem");
 263
 264                 switch (color) {
 265                 case 1:
 266                         break;
 267                 case 2:
 268                         elm_object_signal_emit(layout, "elm,state,show,app", "elm");
 269                         break;
 270                 case 3:
 271                         elm_object_signal_emit(layout, "elm,state,show,pic", "elm");
 272                         break;
 273                 case 4:
 274                         elm_object_signal_emit(layout, "elm,state,show,audio", "elm");
 275                         break;
 276                 case 5:
 277                         elm_object_signal_emit(layout, "elm,state,show,misc", "elm");
 278                         break;
 279                 case 6:
 280                         elm_object_signal_emit(layout, "elm,state,show,avail", "elm");
 281                         break;
 282                 default:
 283                         break;
 284                 }
 285                 evas_object_show(layout);
 286                 return layout;
 287         }
 288
 289         return NULL;
 290 }
 291
 292 static void storageUg_main_sel(void *data, Evas_Object *obj, void *event_info)
 293 {
 294         SettingStorageUG *ad = data;
 295         Elm_Object_Item *item = event_info;
 296
 297         ret_if(data == NULL);
 298
 299         elm_genlist_item_selected_set(item, 0);
 300         Setting_GenGroupItem_Data *list_item = elm_object_item_data_get(item);
 301
 302         SETTING_TRACE("clicking item[%s]", list_item->keyStr);
 303
 304         if (!safeStrCmp(STORAGEUG_STR_APPS, list_item->keyStr))
 305                 storageUg_manage_app_ug(ad);
 306         else if (!safeStrCmp(STORAGEUG_STR_DEF_STORAGE, list_item->keyStr))
 307                 setting_view_change(ad->main_view, ad->default_view, ad);
 308         else if (!safeStrCmp(STORAGEUG_STR_PICS, list_item->keyStr))
 309                 app_launcher("org.tizen.gallery");
 310         else if (!safeStrCmp(STORAGEUG_STR_AUDIO, list_item->keyStr))
 311                 app_launcher("org.tizen.music-player-lite");
 312         else if (!safeStrCmp(STORAGEUG_STR_MISCES, list_item->keyStr))
 313                 setting_view_change(ad->main_view, ad->misces_view, ad);
 314 }
 315
 316 static Setting_GenGroupItem_Data* storageUg_main_append_group_mid_item(
 317                 SettingStorageUG *ad, int color, const char *key_str, const char *sub_str)
 318 {
 319         Setting_GenGroupItem_Data *item_data = NULL;
 320         item_data = (Setting_GenGroupItem_Data *) calloc(1, sizeof(Setting_GenGroupItem_Data));
 321         if (item_data) {
 322                 item_data->userdata = ad;
 323                 item_data->keyStr = (char *)g_strdup(key_str);
 324                 item_data->sub_desc = (char *)g_strdup(sub_str);
 325                 item_data->color = color;
 326                 item_data->item = elm_genlist_item_append(ad->gl_main, &(ad->itc_color_item), item_data, NULL,
 327                                             ELM_GENLIST_ITEM_NONE, storageUg_main_sel, ad);
 328         } else {
 329                 SETTING_TRACE_ERROR("item_data is NULL");
 330         }
 331
 332         return item_data;
 333 }
 334
 335 static inline void storageUg_main_dev_memory_detail(SettingStorageUG *ad)
 336 {
 337         char avail_desc[STORAGEUG_MAX_STR_LEN] = {0};
 338         char total_desc[STORAGEUG_MAX_STR_LEN] = {0};
 339
 340         /* memory total */
 341         storageUg_size_to_str(ad->sz_inter_total, total_desc, sizeof(total_desc));
 342         ad->total_space = setting_create_Gendial_field_def(ad->gl_main, &itc_2text_2,
 343                         NULL, ad, SWALLOW_Type_INVALID, NULL, NULL, 0, STORAGEUG_STR_TOTAL,
 344                         total_desc, NULL);
 345         ret_if(NULL == ad->total_space);
 346         ad->total_space->userdata = ad;
 347         ad->total_space->group_style = SETTING_GROUP_STYLE_TOP;
 348         elm_genlist_item_select_mode_set(ad->total_space->item,
 349                         ELM_OBJECT_SELECT_MODE_DISPLAY_ONLY);
 350
 351         /* system memory */
 352         ad->sys_mem = storageUg_main_append_group_mid_item(ad,
 353                         1, STORAGEUG_STR_SYS_MEM, STORAGEUG_STR_WAIT);
 354         ret_if(NULL == ad->sys_mem);
 355         elm_genlist_item_select_mode_set(ad->sys_mem->item, ELM_OBJECT_SELECT_MODE_DISPLAY_ONLY);
 356
 357         /* Applications */
 358         ad->apps = storageUg_main_append_group_mid_item(ad,
 359                         2, STORAGEUG_STR_APPS, STORAGEUG_STR_WAIT);
 360         ret_if(NULL == ad->apps);
 361
 362         /* Pictures, Videos */
 363         ad->pics_videos = storageUg_main_append_group_mid_item(ad,
 364                         3, STORAGEUG_STR_PICS, STORAGEUG_STR_WAIT);
 365         ret_if(NULL == ad->pics_videos);
 366
 367         /* Audio */
 368         ad->audio = storageUg_main_append_group_mid_item(ad,
 369                         4, STORAGEUG_STR_AUDIO, STORAGEUG_STR_WAIT);
 370         ret_if(NULL == ad->audio);
 371
 372         /* Miscellaneous files */
 373         ad->misces = storageUg_main_append_group_mid_item(ad,
 374                         5, STORAGEUG_STR_MISCES, STORAGEUG_STR_WAIT);
 375         ret_if(NULL == ad->misces);
 376
 377         /* Available */
 378         storageUg_size_to_str(ad->sz_inter_avail, avail_desc, sizeof(avail_desc));
 379         ad->avail = storageUg_main_append_group_mid_item(ad,
 380                         6, STORAGEUG_STR_AVAIL, avail_desc);
 381         ret_if(NULL == ad->avail);
 382         elm_genlist_item_select_mode_set(ad->avail->item, ELM_OBJECT_SELECT_MODE_DISPLAY_ONLY);
 383 }
 384
 385 static void storageUg_encrypt_change_cb(keynode_t *node, void *user_data)
 386 {
 387         char *str;
 388         SettingStorageUG *ad = user_data;
 389
 390         ret_if(NULL == user_data);
 391
 392         str = vconf_keynode_get_str(node);
 393         if(!safeStrCmp(str, "encryption_start") || !safeStrCmp(str, "decryption_start"))
 394         {
 395                 if (ad->sd_mount) setting_disable_genlist_item(ad->sd_mount->item);
 396                 if (ad->sd_format) setting_disable_genlist_item(ad->sd_format->item);
 397         }
 398         else
 399         {
 400                 if (ad->sd_mount) setting_enable_genlist_item(ad->sd_mount->item);
 401                 if (ad->sd_format) setting_enable_genlist_item(ad->sd_format->item);
 402         }
 403 }
 404
 405 static void storageUg_main_dev_memory_update(SettingStorageUG *ad)
 406 {
 407         char desc[STORAGEUG_MAX_STR_LEN] = {0};
 408
 409         ret_if(NULL == ad);
 410
 411         storageUg_get_internal_storage_status(&ad->sz_inter_total, &ad->sz_inter_avail);
 412
 413         /* update internal total size */
 414         storageUg_size_to_str(ad->sz_inter_total, desc, sizeof(desc));
 415         G_FREE(ad->total_space->sub_desc);
 416         ad->total_space->sub_desc = (char *)g_strdup(desc);
 417         elm_genlist_item_fields_update(ad->total_space->item, "elm.text.sub.left.bottom",
 418                         ELM_GENLIST_ITEM_FIELD_TEXT);
 419
 420         /* update internal available size */
 421         storageUg_size_to_str(ad->sz_inter_avail, desc, sizeof(desc));
 422         G_FREE(ad->avail->sub_desc);
 423         ad->avail->sub_desc = (char *)g_strdup(desc);
 424         elm_genlist_item_fields_update(ad->avail->item, "elm.text.sub.left.bottom",
 425                         ELM_GENLIST_ITEM_FIELD_TEXT);
 426
 427 }
 428
 429 static Eina_Bool storageUg_update_timer(void *data)
 430 {
 431         SETTING_TRACE_BEGIN;
 432         SettingStorageUG *ad = data;
 433
 434         retv_if(NULL == data, ECORE_CALLBACK_CANCEL);
 435
 436         storageUg_main_dev_memory_update(ad);
 437         SETTING_TRACE_DEBUG("ad->misces_view->is_create:%d",ad->misces_view->is_create);
 438         if (ad->misces_view->is_create){
 439                 setting_view_update(ad->misces_view, ad);
 440         }
 441         if (ad->size_worker)
 442                 storageUg_stop_async_worker(ad->size_worker);
 443         ad->size_worker = storageUg_start_async_worker(storageUg_get_internal_detail,
 444                         storageUg_get_internal_detail_cb, ad);
 445
 446
 447         ad->update_timer = NULL;
 448         SETTING_TRACE_END;
 449         return ECORE_CALLBACK_CANCEL;
 450 }
 451
 452 static void storageUg_main_update_media_data(SettingStorageUG *ad)
 453 {
 454         ret_if(NULL == ad);
 455
 456         if (ad->update_timer){
 457                 ecore_timer_del(ad->update_timer);
 458                 ad->update_timer = NULL;
 459         }
 460
 461         ad->update_timer = ecore_timer_add(0.5,storageUg_update_timer, ad);
 462 }
 463
 464 static void storageUg_media_filesys_changed_cb(
 465                 media_content_error_e error,
 466                 int pid,
 467                 media_content_db_update_item_type_e update_item,
 468                 media_content_db_update_type_e update_type,
 469                 media_content_type_e media_type,
 470                 char *uuid,
 471                 char *path,
 472                 char *mime_type,
 473                 void *user_data)
 474 {
 475         SETTING_TRACE_BEGIN;
 476         SettingStorageUG *ad = user_data;
 477
 478         ret_if(user_data == NULL);
 479
 480         storageUg_main_update_media_data(ad);
 481
 482         SETTING_TRACE_END;
 483 }
 484
 485 static Eina_Bool storageUg_main_back_cb(void *data, Elm_Object_Item *it)
 486 {
 487         SETTING_TRACE_BEGIN;
 488         SettingStorageUG *ad = data;
 489
 490         retv_if(data == NULL, EINA_TRUE);
 491
 492         if (ad->update_timer) {
 493                 ecore_timer_del(ad->update_timer);
 494                 ad->update_timer = NULL;
 495         }
 496
 497         if (ad->size_worker)
 498         {
 499                 if (storageUg_worker_is_running(ad->size_worker))
 500                 {
 501                         SETTING_TRACE("DO NOT Close Storage UI!!!!! <<------------");
 502                         return EINA_FALSE;
 503                 }
 504         } else {
 505                 SETTING_TRACE("ad->size_worker is NULL <<--------");
 506         }
 507
 508         ug_destroy_me(ad->ug);
 509         SETTING_TRACE_END;
 510         return EINA_TRUE;
 511 }
 512
 513 static inline Evas_Object* storageUg_main_genlist(Evas_Object *parent)
 514 {
 515         Evas_Object *genlist;
 516
 517         genlist = elm_genlist_add(parent);
 518         if (NULL == genlist)
 519         {
 520                 SETTING_TRACE_ERROR("elm_genlist_add() Fail");
 521                 return NULL;
 522         }
 523
 524         //elm_object_style_set(genlist, "dialogue");
 525         elm_genlist_block_count_set(genlist, 3);
 526         elm_genlist_mode_set(genlist, ELM_LIST_COMPRESS);
 527         evas_object_show(genlist);
 528
 529         evas_object_smart_callback_add(genlist, "realized", __gl_realized_cb, NULL);
 530
 531         return genlist;
 532 }
 533
 534 static int storageUg_main_create(void *data)
 535 {
 536         int ret;
 537         Elm_Object_Item *pie_item;
 538         SettingStorageUG *ad = data;
 539
 540         bindtextdomain(SETTING_PACKAGE, SETTING_LOCALEDIR);
 541
 542         retv_if(data == NULL, SETTING_GENERAL_ERR_NULL_DATA_PARAMETER);
 543         retv_if(NULL == ad->lo_parent, SETTING_DRAW_ERR_FAIL_LOAD_EDJ);
 544
 545         ad->gl_main = storageUg_main_genlist(ad->navi);
 546         setting_create_navi_bar_buttons(STORAGEUG_STR_STORAGE, STORAGEUG_STR_BACK, NULL,
 547                         NULL, (setting_call_back_func)storageUg_main_back_cb, NULL, NULL, ad,
 548                         ad->gl_main, ad->navi, NULL);
 549
 550         storageUg_get_internal_storage_status(&ad->sz_inter_total, &ad->sz_inter_avail);
 551
 552         /* storage pie view */
 553         pie_item = elm_genlist_item_append(ad->gl_main, &(ad->itc_pie),
 554                         ad, NULL, ELM_GENLIST_ITEM_NONE, NULL, NULL);
 555         elm_genlist_item_select_mode_set(pie_item, ELM_OBJECT_SELECT_MODE_DISPLAY_ONLY);
 556         ad->pie_it = pie_item;
 557
 558         storageUg_main_dev_memory_detail(ad);
 559
 560         if (ad->size_worker)
 561                 storageUg_stop_async_worker(ad->size_worker);
 562         ad->size_worker = storageUg_start_async_worker(storageUg_get_internal_detail,
 563                         storageUg_get_internal_detail_cb, ad);
 564
 565         storageUG_update_apps_info(ad);
 566
 567         storageUg_append_separator(ad->gl_main, ad);
 568         if (!isEmulBin())
 569         {
 570                 ret = vconf_get_int(storageUg_MMC_stat, &ad->mmc_status);
 571                 retvm_if(ret, SETTING_RETURN_FAIL, "vconf_get_int(%s) Fail", storageUg_MMC_stat);
 572
 573                 storageUg_append_separator(ad->gl_main, ad);
 574
 575                 /* Default storage */
 576                 setting_create_Gendial_field_def(ad->gl_main, &itc_1text,
 577                                 storageUg_main_sel, ad, SWALLOW_Type_INVALID, NULL, NULL, 0,
 578                                 STORAGEUG_STR_DEF_STORAGE, NULL, NULL);
 579
 580                 storageUg_append_separator(ad->gl_main, ad);
 581
 582                 /* SD */
 583                 ad->sd_card = setting_create_Gendial_field_titleItem(ad->gl_main,
 584                                 &itc_group_item, STORAGEUG_STR_SD_CARD, NULL);
 585                 storageUg_main_append_SD_info(ad);
 586
 587                 storageUg_append_separator(ad->gl_main, ad);
 588
 589                 ret = vconf_notify_key_changed(storageUg_MMC_stat, storageUg_SD_change_cb, ad);
 590                 warn_if(ret != 0, "vconf_notify_key_changed(%s) Fail", storageUg_MMC_stat);
 591
 592                 ret = vconf_notify_key_changed(storageUg_ENCRYPT_stat,
 593                                 storageUg_encrypt_change_cb, ad);
 594                 warn_if(ret != 0, "vconf_notify_key_changed(%s) Fail", storageUg_ENCRYPT_stat);
 595         }
 596
 597         /* usb otg storage*/
 598         ad->usb_otg_status = SETTING_STORAGE_USB_OTG_REMOVE;
 599
 600         storageUg_init_USB(ad);
 601
 602         setting_view_storage_main.is_create = 1;
 603
 604         media_content_set_db_updated_cb(storageUg_media_filesys_changed_cb, ad);
 605         SETTING_TRACE("-----------------------------------------------");
 606         SETTING_TRACE(" WIDGET_SCALE_FACTOR : %f",WIDGET_SCALE_FACTOR);
 607         SETTING_TRACE("-----------------------------------------------");
 608
 609         return SETTING_RETURN_SUCCESS;
 610 }
 611
 612 static int storageUg_main_destroy(void *data)
 613 {
 614         int ret;
 615         SettingStorageUG *ad = data;
 616
 617         retv_if(data == NULL, SETTING_GENERAL_ERR_NULL_DATA_PARAMETER);
 618
 619         setting_view_destroy(ad->misces_view, ad);
 620
 621         media_content_unset_db_updated_cb();
 622
 623         storageUg_deinit_USB();
 624
 625         ret = vconf_ignore_key_changed(storageUg_MMC_stat, storageUg_SD_change_cb);
 626         warn_if(ret, "vconf_ignore_key_changed(%s) Fail(%d)", storageUg_MMC_stat, ret);
 627         ret = vconf_ignore_key_changed(storageUg_ENCRYPT_stat, storageUg_encrypt_change_cb);
 628         warn_if(ret, "vconf_ignore_key_changed(%s) Fail(%d)", storageUg_ENCRYPT_stat, ret);
 629
 630         storageUg_stop_async_worker_all();
 631
 632         if (ad->update_idler)
 633         {
 634                 ecore_idler_del(ad->update_idler);
 635                 ad->update_idler = NULL;
 636         }
 637
 638         if (ad->update_timer){
 639                 ecore_timer_del(ad->update_timer);
 640                 ad->update_timer = NULL;
 641         }
 642
 643         if (ad->popup)
 644         {
 645                 evas_object_del(ad->popup);
 646                 ad->popup = NULL;
 647         }
 648         if(ad->cr)
 649         {
 650                 cairo_destroy(ad->cr);
 651                 ad->cr= NULL;
 652         }
 653         if (ad->pc)
 654         {
 655                 pkgmgr_client_free(ad->pc);
 656                 ad->pc = NULL;
 657         }
 658
 659         setting_view_storage_main.is_create = 0;
 660
 661         return SETTING_RETURN_SUCCESS;
 662 }
 663
 664 static int storageUg_main_update(void *data)
 665 {
 666         SettingStorageUG *ad = data;
 667
 668         retv_if(data == NULL, SETTING_GENERAL_ERR_NULL_DATA_PARAMETER);
 669
 670         storageUg_main_update_media_data(ad);
 671         storageUG_update_apps_info(ad);
 672
 673         if (ad->misces_list)
 674                 setting_view_update(ad->misces_view, ad);
 675         else
 676                 evas_object_show(ad->lo_main);
 677
 678         return SETTING_RETURN_SUCCESS;
 679 }
 680
 681 static int storageUg_main_cleanup(void *data)
 682 {
 683         return SETTING_RETURN_SUCCESS;
 684 }
 685
 686 void storageUg_main_init(SettingStorageUG *ad)
 687 {
 688         ret_if(NULL == ad);
 689         ret_if(ad->main_view);
 690
 691         setting_view_storage_main.create = storageUg_main_create;
 692         setting_view_storage_main.destroy = storageUg_main_destroy;
 693         setting_view_storage_main.update = storageUg_main_update;
 694         setting_view_storage_main.cleanup = storageUg_main_cleanup;
 695
 696         ad->main_view = &setting_view_storage_main;
 697 }