Blackberry - application settings save/load

Question

I know two ways to save/load application settings:

• use PersistentStore
• use filesystem (store, since SDCard is optional)

I'd like to know what are you're practicies of working with application settings?

Using PersistentStore to save/load application settings

The persistent store provides a means for objects to persist across device resets. A persistent object consists of a key-value pair. When a persistent object is committed to the persistent store, that object's value is stored in flash memory via a deep copy. The value can then be retrieved at a later point in time via the key.

Example of helper class for storing and retrieving settings:

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;
            }
        }
    }
}

sample app screen http://img182.imageshack.us/img182/6348/appsettings.png

Example of use:

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

3rd option: Use the RMS for simple app settings.

Although your suggested persistent store sounds nice, it is not compatible with any other java phone, so when you have to port your app you'll have to recreate this part

I read somewhere that creating files on the filesystem itself should only be done in case of pictures or video, so basically content which the user can look at at another way as well.

Answer 2

We use PersistentStore and I can confirm that the data does stick around even after uninstalling and reinstalling the app.

UPDATE: from what I understand, if you persist a non-native object (i.e. you create a subclass of Hashtable and store it) then all the app's persisted data WILL be erased when you uninstall your app, since the persisted class no longer has meaning.