Blackberry - impostazioni dell'applicazione risparmiare / carico

Question

Lo so due modi per salvare / impostazioni di applicazione del carico:

• PersistentStore
• uso del file system (negozio, dal momento che SDCard è facoltativo)

Mi piacerebbe sapere che cosa sei practise di lavorare con le impostazioni delle applicazioni?

Uso PersistentStore per salvare / caricare le impostazioni delle applicazioni

  

L'archivio permanente fornisce un mezzo per oggetti di persistere attraverso reset del dispositivo. Un oggetto persistente è costituito da una coppia di valori-chiave. Quando un oggetto persistente è impegnata nella memoria permanente, il valore dell'oggetto è memorizzato nella memoria flash tramite una copia profonda. Il valore può essere recuperato in un secondo momento tramite il tasto.

Esempio di classe di supporto per la memorizzazione e il recupero delle impostazioni:

class PSOptions {
    private PersistentObject mStore;
    private LongHashtableCollection mSettings;
    private long KEY_URL = 0;
    private long KEY_ENCRYPT = 1;
    private long KEY_REFRESH_PERIOD = 2;

    public PSOptions() {
        // "AppSettings" = 0x71f1f00b95850cfeL
        mStore = PersistentStore.getPersistentObject(0x71f1f00b95850cfeL);
    }

    public String getUrl() {
        Object result = get(KEY_URL);
        return (null != result) ? (String) result : null;
    }

    public void setUrl(String url) {
        set(KEY_URL, url);
    }

    public boolean getEncrypt() {
        Object result = get(KEY_ENCRYPT);
        return (null != result) ? ((Boolean) result).booleanValue() : false;
    }

    public void setEncrypt(boolean encrypt) {
        set(KEY_ENCRYPT, new Boolean(encrypt));
    }

    public int getRefreshPeriod() {
        Object result = get(KEY_REFRESH_PERIOD);
        return (null != result) ? ((Integer) result).intValue() : -1;
    }

    public void setRefreshRate(int refreshRate) {
        set(KEY_REFRESH_PERIOD, new Integer(refreshRate));
    }

    private void set(long key, Object value) {
        synchronized (mStore) {
            mSettings = (LongHashtableCollection) mStore.getContents();
            if (null == mSettings) {
                mSettings = new LongHashtableCollection();
            }
            mSettings.put(key, value);
            mStore.setContents(mSettings);
            mStore.commit();
        }
    }

    private Object get(long key) {
        synchronized (mStore) {
            mSettings = (LongHashtableCollection) mStore.getContents();
            if (null != mSettings && mSettings.size() != 0) {
                return mSettings.get(key);
            } else {
                return null;
            }
        }
    }
}

schermata di esempio app http://img182.imageshack.us/img182/6348/ appsettings.png

Esempio di utilizzo:

class Scr extends MainScreen implements FieldChangeListener {
    PSOptions mOptions = new PSOptions();

    BasicEditField mUrl = new BasicEditField("Url:",
            "http://stackoverflow.com/");
    CheckboxField mEncrypt = new CheckboxField("Enable encrypt", false);
    GaugeField mRefresh = new GaugeField("Refresh period", 1, 60 * 10, 10,
            GaugeField.EDITABLE|FOCUSABLE);
    ButtonField mLoad = new ButtonField("Load settings",
            ButtonField.CONSUME_CLICK);
    ButtonField mSave = new ButtonField("Save settings",
            ButtonField.CONSUME_CLICK);

    public Scr() {
        add(mUrl);
        mUrl.setChangeListener(this);
        add(mEncrypt);
        mEncrypt.setChangeListener(this);
        add(mRefresh);
        mRefresh.setChangeListener(this);
        HorizontalFieldManager hfm = new HorizontalFieldManager(USE_ALL_WIDTH);
        add(hfm);
        hfm.add(mLoad);
        mLoad.setChangeListener(this);
        hfm.add(mSave);
        mSave.setChangeListener(this);
        loadSettings();
    }

    public void fieldChanged(Field field, int context) {
        if (field == mLoad) {
            loadSettings();
        } else if (field == mSave) {
            saveSettings();
        }
    }

    private void saveSettings() {
        mOptions.setUrl(mUrl.getText());
        mOptions.setEncrypt(mEncrypt.getChecked());
        mOptions.setRefreshRate(mRefresh.getValue());
    }

    private void loadSettings() {
        mUrl.setText(mOptions.getUrl());
        mEncrypt.setChecked(mOptions.getEncrypt());
        mRefresh.setValue(mOptions.getRefreshPeriod());
    }
}

Answer 1

3 ° opzione: Utilizzare i RMS per le impostazioni delle applicazioni semplici.

Anche se il vostro archivio permanente suggerito suona bello, non è compatibile con qualsiasi altro telefono Java, in modo che quando si ha alla porta la vostra applicazione si dovrà ricreare questa parte

Ho letto da qualche parte che la creazione di file sul filesystem stesso dovrebbe essere fatto solo in caso di immagini o video, in modo sostanzialmente il contenuto che l'utente può guardare in un altro modo pure.

Answer 2

Usiamo PersistentStore e posso confermare che i dati non attaccare intorno anche dopo disinstallare e reinstallare l'applicazione.

Aggiorna : da quanto ho capito, se persistono un oggetto non nativo (cioè si crea una sottoclasse di Hashtable e conservarla) allora tutte le app persistette dati saranno cancellati quando si disinstalla il app, dal momento che la classe persistente non ha più senso.