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