setting-storage/src/setting-storage.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 #ifndef UG_MODULE_API
  20 #define UG_MODULE_API __attribute__ ((visibility("default")))
  21 #endif
  22
  23 #include <efl_extension.h>
  24 #include <media_content.h>
  25
  26 #include "setting-cfg.h"
  27 #include "setting-storage-main.h"
  28 #include "setting-storage-default.h"
  29 #include "setting-storage-miscellaneous.h"
  30 #include "setting-storage.h"
  31
  32 typedef enum {
  33     STORAGEUG_KEYWORD_NONE = 0,
  34     STORAGEUG_KEYWORD_MAIN_SYS_MEM,
  35     STORAGEUG_KEYWORD_MAIN_APPS,
  36     STORAGEUG_KEYWORD_MAIN_PICS,
  37     STORAGEUG_KEYWORD_MAIN_AUDIO,
  38     STORAGEUG_KEYWORD_MAIN_MISCES,
  39     STORAGEUG_KEYWORD_MAIN_AVAIL,
  40     STORAGEUG_KEYWORD_MAIN_SD_CARD,
  41
  42     STORAGEUG_KEYWORD_DEFAULT = 100,
  43     STORAGEUG_KEYWORD_DEFAULT_BT,
  44     STORAGEUG_KEYWORD_DEFAULT_WIFI,
  45     STORAGEUG_KEYWORD_DEFAULT_NFC,
  46     STORAGEUG_KEYWORD_DEFAULT_APP,
  47     STORAGEUG_KEYWORD_MAX
  48 } STORAGEUG_KEYWORD;
  49
  50 typedef struct {
  51         char *key_name;
  52         int keynum;
  53 } storageUg_search_data;
  54
  55 static void _storageUg_vconf_change_cb(keynode_t *key, void *data)
  56 {
  57         char *vconf_name;
  58         SettingStorageUG *ad = data;
  59
  60         ret_if(data == NULL);
  61
  62         vconf_name = vconf_keynode_get_name(key);
  63         if (NULL == vconf_name)
  64                 return;
  65
  66         if (ad->pie_it)
  67                 elm_genlist_item_update(ad->pie_it);
  68 }
  69
  70 static inline void _storageUg_listen_vconf(SettingStorageUG *storageUG)
  71 {
  72         int ret;
  73         const char *FONT_SIZE = VCONFKEY_SETAPPL_ACCESSIBILITY_FONT_SIZE;
  74         const char *FONT_NAME = VCONFKEY_SETAPPL_ACCESSIBILITY_FONT_NAME;
  75
  76         ret = vconf_notify_key_changed(FONT_SIZE, _storageUg_vconf_change_cb, storageUG);
  77         warn_if(ret < 0, "vconf_notify_key_changed(%s) Fail(%d)", FONT_SIZE, ret);
  78
  79         ret = vconf_notify_key_changed(FONT_NAME, _storageUg_vconf_change_cb, storageUG);
  80         warn_if(ret < 0, "vconf_notify_key_changed(%s) Fail(%d)", FONT_NAME, ret);
  81 }
  82
  83 static inline void _storageUg_ignore_vconf()
  84 {
  85         int ret;
  86         const char *FONT_SIZE = VCONFKEY_SETAPPL_ACCESSIBILITY_FONT_SIZE;
  87         const char *FONT_NAME = VCONFKEY_SETAPPL_ACCESSIBILITY_FONT_NAME;
  88
  89         ret = vconf_ignore_key_changed(FONT_SIZE, _storageUg_vconf_change_cb);
  90         warn_if(ret < 0, "vconf_ignore_key_changed(%s) Fail(%d)", FONT_SIZE, ret);
  91
  92         ret = vconf_ignore_key_changed(FONT_NAME, _storageUg_vconf_change_cb);
  93         warn_if(ret < 0, "vconf_ignore_key_changed(%s) Fail(%d)", FONT_NAME, ret);
  94 }
  95
  96 static inline void storageUg_init_itcs(SettingStorageUG *ad)
  97 {
  98         setting_create_Gendial_itc("dialogue/2text.3/expandable", &(ad->itc_2text_3_parent));
  99         setting_create_Gendial_itc("dialogue/1text.1icon/expandable2",
 100                                    &(ad->itc_1icon_1text_sub));
 101         setting_create_Gendial_itc("dialogue/2text.3", &(ad->itc_2text_2));
 102         setting_create_Gendial_itc(SETTING_GENLIST_GROUP_INDEX_STYLE, &(ad->itc_group_item));
 103         setting_create_Gendial_itc("2line.top.4", &(ad->itc_2text_1icon_3));
 104         setting_create_Gendial_itc("dialogue/1text", &(ad->itc_1text));
 105         setting_create_Gendial_itc("1text.1icon.3", &(ad->itc_1text_1icon));
 106         setting_create_Gendial_itc("1icon", &(ad->itc_pie));
 107         ad->itc_pie.func.content_get = storageUg_main_pie_item_get_icon;
 108         ad->itc_pie.func.del = NULL;
 109         setting_create_Gendial_itc("1icon/no_padding_line", &(ad->itc_notice));
 110         ad->itc_notice.func.content_get = storageUg_default_notice_get_icon;
 111         ad->itc_notice.func.del = NULL;
 112
 113         setting_create_Gendial_itc(SETTING_GENLIST_2LINE_STYLE, &(ad->itc_color_item));
 114         ad->itc_color_item.func.content_get = storageUg_color_item_content_get;
 115         ad->itc_color_item.func.del = NULL;
 116 }
 117
 118 static void storageUg_navi_back(void *data, Evas_Object *obj, void *event_info)
 119 {
 120         SettingStorageUG *ad = data;
 121
 122         ret_if(NULL == data);
 123         ret_if(NULL != ad->del_worker);
 124         retm_if(ad->sd_request || ad->usb_request, "sd_request(%d), usb_request(%d)",
 125                 ad->sd_request, ad->usb_request);
 126
 127         elm_naviframe_item_pop(obj);
 128 }
 129
 130 static inline Evas_Object *storageUg_create_navi(Evas_Object *parent,
 131                                                  SettingStorageUG *ad)
 132 {
 133         Evas_Object *navi;
 134
 135         retv_if(NULL == parent, NULL);
 136
 137         navi = elm_naviframe_add(parent);
 138         elm_naviframe_prev_btn_auto_pushed_set(navi, EINA_FALSE);
 139
 140         eext_object_event_callback_add(navi, EEXT_CALLBACK_BACK, storageUg_navi_back, ad);
 141         eext_object_event_callback_add(navi, EEXT_CALLBACK_MORE, eext_naviframe_more_cb, ad);
 142
 143         evas_object_show(navi);
 144         return navi;
 145 }
 146
 147 static inline void storageUg_move_view(STORAGEUG_KEYWORD keynum,
 148                                        SettingStorageUG *ad)
 149 {
 150         Setting_GenGroupItem_Data *item_data;
 151
 152         retm_if(keynum <= STORAGEUG_KEYWORD_NONE || STORAGEUG_KEYWORD_MAX <= keynum,
 153                 "keynum(%d) is Invalid", keynum);
 154
 155         switch (keynum) {
 156                 case STORAGEUG_KEYWORD_MAIN_SYS_MEM:
 157                         item_data = ad->sys_mem;
 158                         break;
 159                 case STORAGEUG_KEYWORD_MAIN_APPS:
 160                         item_data = ad->apps;
 161                         break;
 162                 case STORAGEUG_KEYWORD_MAIN_PICS:
 163                         item_data = ad->pics_videos;
 164                         break;
 165                 case STORAGEUG_KEYWORD_MAIN_AUDIO:
 166                         item_data = ad->audio;
 167                         break;
 168                 case STORAGEUG_KEYWORD_MAIN_MISCES:
 169                         item_data = ad->misces;
 170                         break;
 171                 case STORAGEUG_KEYWORD_MAIN_AVAIL:
 172                         item_data = ad->avail;
 173                         break;
 174                 case STORAGEUG_KEYWORD_MAIN_SD_CARD:
 175                         item_data = ad->sd_card;
 176                         break;
 177                 case STORAGEUG_KEYWORD_DEFAULT_BT:
 178                         item_data = ad->data_bt;
 179                         break;
 180                 case STORAGEUG_KEYWORD_DEFAULT_WIFI:
 181                         item_data = ad->data_wifidirect;
 182                         break;
 183                 case STORAGEUG_KEYWORD_DEFAULT_NFC:
 184                         item_data = ad->data_nfc;
 185                         break;
 186                 case STORAGEUG_KEYWORD_DEFAULT_APP:
 187                         item_data = ad->data_installapp;
 188                         break;
 189                 default:
 190                         item_data = NULL;
 191                         break;
 192         }
 193
 194         if (item_data && item_data->item) {
 195                 if (STORAGEUG_KEYWORD_DEFAULT < keynum)
 196                         elm_genlist_item_expanded_set(item_data->item, TRUE);
 197                 else
 198                         elm_genlist_item_bring_in(item_data->item, ELM_GENLIST_ITEM_SCROLLTO_MIDDLE);
 199         }
 200 }
 201
 202 static void *setting_storageUg_on_create(ui_gadget_h ug, enum ug_mode mode,
 203                                          app_control_h service, void *priv)
 204 {
 205         SETTING_TRACE_BEGIN;
 206         int ret;
 207         char *caller = NULL;
 208         SettingStorageUG *ad = priv;
 209         char *search_keyword = NULL;
 210         const char *GENLIST_edj = EDJDIR"/setting-genlist.edj";
 211         STORAGEUG_KEYWORD keyword_val = STORAGEUG_KEYWORD_NONE;
 212
 213         SETTING_TRACE(" -----> [TIME-1] before ");
 214         appcore_measure_start();
 215
 216         retvm_if(NULL == ug || NULL == priv, NULL, "ug=%p, priv=%p is Invalid", ug, priv);
 217
 218         ad->ug = ug;
 219         ad->win = ug_get_window();
 220         ad->lo_parent = ug_get_parent_layout(ug);
 221         if (NULL == ad->lo_parent) {
 222                 SETTING_TRACE_ERROR("ug_get_parent_layout(ug) Fail");
 223                 return NULL;
 224         }
 225
 226         ret = media_content_connect();
 227         if (MEDIA_CONTENT_ERROR_NONE != ret) {
 228                 SETTING_TRACE_ERROR("media_content_connect() Fail(%d)", ret);
 229                 /*return NULL; */
 230         }
 231
 232         app_control_get_extra_data(service, "caller", &caller);
 233         app_control_get_extra_data(service, "keyword", &search_keyword);
 234         if (NULL == caller)
 235                 elm_theme_extension_add(NULL, GENLIST_edj);
 236
 237         /* add listening */
 238         _storageUg_listen_vconf(ad);
 239
 240         storageUg_main_init(ad);
 241         storageUg_default_init(ad);
 242         storageUg_misc_init(ad);
 243
 244         setting_view_node_table_intialize();
 245         setting_view_node_table_register(ad->main_view, NULL);
 246         setting_view_node_table_register(ad->default_view, ad->main_view);
 247         setting_view_node_table_register(ad->misces_view, ad->main_view);
 248
 249         storageUg_init_itcs(ad);
 250
 251         ad->lo_main = setting_create_win_layout(ad->win);
 252         ad->navi = storageUg_create_navi(ad->lo_main, ad);
 253         if (NULL == ad->navi) {
 254                 SETTING_TRACE_ERROR("calloc() Fail");
 255                 return NULL;
 256         }
 257         elm_object_part_content_set(ad->lo_main, "elm.swallow.content", ad->navi);
 258
 259         if (search_keyword)
 260                 keyword_val = atoi(search_keyword);
 261
 262         if (STORAGEUG_KEYWORD_DEFAULT <= keyword_val && keyword_val < STORAGEUG_KEYWORD_MAX)
 263                 setting_view_create(ad->default_view, ad);
 264         else
 265                 setting_view_create(ad->main_view, ad);
 266
 267         if (keyword_val)
 268                 storageUg_move_view(keyword_val, ad);
 269
 270         free(caller);
 271         free(search_keyword);
 272
 273         SETTING_TRACE(" -----> [TIME-2] it took %d msec ", appcore_measure_time());
 274         appcore_measure_start();
 275
 276         return ad->lo_main;
 277 }
 278
 279 static void setting_storageUg_on_destroy(ui_gadget_h ug, app_control_h service,
 280                                          void *priv)
 281 {
 282         SETTING_TRACE_BEGIN;
 283         int ret;
 284         SettingStorageUG *storageUG = priv;
 285
 286         retm_if(NULL == ug || NULL == priv, "ug=%p, priv=%p is Invalid", ug, priv);
 287
 288         FREE(storageUG->usb_otg_path);
 289
 290         _storageUg_ignore_vconf();
 291
 292         ret = media_content_disconnect();
 293         warn_if(ret != MEDIA_CONTENT_ERROR_NONE, "media_content_disconnect Fail");
 294
 295         if (storageUG->main_view->is_create)
 296                 setting_view_destroy(storageUG->main_view, storageUG);
 297         if (storageUG->default_view->is_create)
 298                 setting_view_destroy(storageUG->default_view, storageUG);
 299
 300         if (storageUG->lo_main) {
 301                 evas_object_del(storageUG->lo_main);
 302                 storageUG->lo_main = NULL;
 303         }
 304 }
 305
 306 static void setting_storageUg_on_resume(ui_gadget_h ug, app_control_h service,
 307                                         void *priv)
 308 {
 309         SETTING_TRACE_BEGIN;
 310         SettingStorageUG *storageUG = priv;
 311
 312         retm_if(NULL == ug || NULL == priv, "ug=%p, priv=%p is Invalid", ug, priv);
 313
 314         if (storageUG->main_view->is_create)
 315                 setting_view_update(storageUG->main_view, storageUG);
 316
 317
 318 }
 319
 320
 321 static void setting_storageUg_on_event(ui_gadget_h ug, enum ug_event event,
 322                                        app_control_h service, void *priv)
 323 {
 324         SETTING_TRACE_BEGIN;
 325         SettingStorageUG *storageUG = priv;
 326
 327         retm_if(NULL == ug || NULL == priv, "ug=%p, priv=%p is Invalid", ug, priv);
 328
 329         switch (event) {
 330                 case UG_EVENT_LOW_MEMORY:
 331                         break;
 332                 case UG_EVENT_LOW_BATTERY:
 333                         break;
 334                 case UG_EVENT_LANG_CHANGE:
 335                         if (storageUG->navi)
 336                                 setting_navi_items_update(storageUG->navi);
 337                         break;
 338                 case UG_EVENT_ROTATE_PORTRAIT:
 339                 case UG_EVENT_ROTATE_PORTRAIT_UPSIDEDOWN:
 340                 case UG_EVENT_ROTATE_LANDSCAPE:
 341                 case UG_EVENT_ROTATE_LANDSCAPE_UPSIDEDOWN:
 342                         /*
 343                            if (storageUG->application_desp)
 344                            elm_genlist_item_update(storageUG->application_desp->item);
 345                            */
 346                         break;
 347                 case UG_EVENT_REGION_CHANGE:
 348                         break;
 349                 default:
 350                         break;
 351         }
 352 }
 353
 354 static void setting_storageUg_on_key_event(ui_gadget_h ug,
 355                                            enum ug_key_event event, app_control_h service, void *priv)
 356 {
 357         if (!ug)
 358                 return;
 359
 360         switch (event) {
 361                 case UG_KEY_EVENT_END:
 362                         ug_destroy_me(ug);
 363                         break;
 364                 default:
 365                         break;
 366         }
 367 }
 368
 369 static void setting_storageUg_on_start(ui_gadget_h ug, app_control_h app_control, void *priv)
 370 {
 371         SETTING_TRACE_BEGIN;
 372         SettingStorageUG *storageUG = priv;
 373
 374         retm_if(NULL == ug || NULL == priv, "ug=%p, priv=%p is Invalid", ug, priv);
 375
 376         SETTING_TRACE(" -----> [TIME-3] it took %d msec to finish on_Start ", appcore_measure_time());
 377 }
 378
 379 UG_MODULE_API int UG_MODULE_INIT(struct ug_module_ops *ops)
 380 {
 381         SettingStorageUG *storageUG;
 382
 383         retv_if(NULL == ops, -1);
 384
 385         storageUG = calloc(1, sizeof(SettingStorageUG));
 386         if (NULL == storageUG) {
 387                 SETTING_TRACE_ERROR("calloc() Fail");
 388                 return -1;
 389         }
 390
 391         ops->create = setting_storageUg_on_create;
 392         ops->start = setting_storageUg_on_start;
 393         ops->pause = NULL;
 394         ops->resume = setting_storageUg_on_resume;
 395         ops->destroy = setting_storageUg_on_destroy;
 396         ops->message = NULL;
 397         ops->event = setting_storageUg_on_event;
 398         ops->key_event = setting_storageUg_on_key_event;
 399         ops->priv = storageUG;
 400         ops->opt = UG_OPT_INDICATOR_ENABLE;
 401
 402         return 0;
 403 }
 404
 405
 406 UG_MODULE_API void UG_MODULE_EXIT(struct ug_module_ops *ops)
 407 {
 408         ret_if(NULL == ops);
 409
 410         FREE(ops->priv);
 411 }
 412
 413 UG_MODULE_API int setting_plugin_search_init(app_control_h service, void *priv,
 414                                              char **applocale)
 415 {
 416         int i;
 417         int size;
 418         char ug_args[STORAGEUG_MAX_STR_LEN];
 419         Setting_Cfg_Node_T *node;
 420         Eina_List **pplist = (Eina_List **)priv;
 421         const storageUg_search_data search_configs[] = {
 422                 /* key_name, view_type, keyword, action, data */
 423                 {STORAGEUG_STR_SYS_MEM, STORAGEUG_KEYWORD_MAIN_SYS_MEM},
 424                 {STORAGEUG_STR_APPS, STORAGEUG_KEYWORD_MAIN_APPS},
 425                 {STORAGEUG_STR_PICS, STORAGEUG_KEYWORD_MAIN_PICS},
 426                 {STORAGEUG_STR_AUDIO, STORAGEUG_KEYWORD_MAIN_AUDIO},
 427                 {STORAGEUG_STR_MISCES, STORAGEUG_KEYWORD_MAIN_MISCES},
 428                 {STORAGEUG_STR_AVAIL, STORAGEUG_KEYWORD_MAIN_AVAIL},
 429                 {STORAGEUG_STR_SD_CARD, STORAGEUG_KEYWORD_MAIN_SD_CARD},
 430                 {STORAGEUG_STR_DEF_STORAGE, STORAGEUG_KEYWORD_DEFAULT},
 431                 {STORAGEUG_STR_BT, STORAGEUG_KEYWORD_DEFAULT_BT},
 432                 {STORAGEUG_STR_WIFI, STORAGEUG_KEYWORD_DEFAULT_WIFI},
 433                 {STORAGEUG_STR_NFC, STORAGEUG_KEYWORD_DEFAULT_NFC},
 434                 {STORAGEUG_STR_INSTALLED_APP_B, STORAGEUG_KEYWORD_DEFAULT_APP}
 435         };
 436
 437         retv_if(NULL == priv, SETTING_GENERAL_ERR_NULL_DATA_PARAMETER);
 438         retv_if(NULL == applocale, SETTING_GENERAL_ERR_NULL_DATA_PARAMETER);
 439
 440         *applocale = strdup("setting:/usr/apps/org.tizen.setting/res/locale");
 441
 442         size = sizeof(search_configs) / sizeof(storageUg_search_data);
 443
 444         for (i = 0; i < size; i++) {
 445                 sprintf(ug_args, "keyword:%d", search_configs[i].keynum);
 446                 node = setting_plugin_search_item_subindex_add(
 447                            search_configs[i].key_name,
 448                            ug_args,
 449                            IMG_Storage,
 450                            Cfg_Item_View_Node,
 451                            NULL,
 452                            "Storage");
 453
 454                 *pplist = eina_list_append(*pplist, node);
 455         }
 456         return 0;
 457 }
 458