Android
Gedeelde voorkeuren

Invoering

Syntaxis

• Context methode

  • public SharedPreferences getSharedPreferences (tekenreeksnaam, int-modus)

• Activiteit methode

  • openbare SharedPreferences getPreferences ()

• SharedPreferences-methoden

  • public SharedPreferences.Editor edit ()
  • public boolean bevat ()
  • public Map <String,?> getAll ()
  • public boolean getBoolean (String key, boolean defValue)
  • public float getFloat (String key, float defValue)
  • public int getInt (String key, int defValue)
  • public long getLong (String key, long defValue)
  • public String getString (String key, String defValue)
  • public Set getStringSet (String-sleutel, Set defValues)
  • public void registerOnSharedPreferenceChangeListener (SharedPreferences.OnSharedPreferenceChangeListener luisteraar)
  • public void unregisterOnSharedPreferenceChangeListener (SharedPreferences.OnSharedPreferenceChangeListener luisteraar)

• SharedPreferences.Editor Methods

  • openbare nietigverklaring van toepassing ()
  • public boolean commit ()
  • public SharedPreferences.Editor clear ()
  • public SharedPreferences.Editor putBoolean (String key, boolean value)
  • public SharedPreferences.Editor putFloat (String key, float value)
  • public SharedPreferences.Editor putInt (String key, int value)
  • public SharedPreferences.Editor putLong (String-sleutel, lange waarde)
  • public SharedPreferences.Editor putString (String key, String value)
  • public SharedPreferences.Editor putStringSet (String-sleutel, waarden instellen)
  • public SharedPreferences.Editor remove (String-sleutel)

parameters

Opmerkingen

Lees en schrijf waarden naar SharedPreferences

public class MyActivity extends Activity {

    private static final String PREFS_FILE = "NameOfYourPrefrenceFile";
    // PREFS_MODE defines which apps can access the file
    private static final int PREFS_MODE = Context.MODE_PRIVATE;
    // you can use live template "key" for quickly creating keys
    private static final String KEY_BOOLEAN = "KEY_FOR_YOUR_BOOLEAN";
    private static final String KEY_STRING = "KEY_FOR_YOUR_STRING";
    private static final String KEY_FLOAT = "KEY_FOR_YOUR_FLOAT";
    private static final String KEY_INT = "KEY_FOR_YOUR_INT";
    private static final String KEY_LONG = "KEY_FOR_YOUR_LONG";

    @Override
    protected void onStart() {
        super.onStart();
    
        // Get the saved flag (or default value if it hasn't been saved yet)
        SharedPreferences settings = getSharedPreferences(PREFS_FILE, PREFS_MODE);
        // read a boolean value (default false)
        boolean booleanVal = settings.getBoolean(KEY_BOOLEAN, false);
        // read an int value (Default 0)
        int intVal = settings.getInt(KEY_INT, 0);
        // read a string value (default "my string")
        String str = settings.getString(KEY_STRING, "my string");
        // read a long value (default 123456)
        long longVal = settings.getLong(KEY_LONG, 123456);
        // read a float value (default 3.14f)
        float floatVal = settings.getFloat(KEY_FLOAT, 3.14f);
    }

    @Override
    protected void onStop() {
        super.onStop();
        
        // Save the flag
        SharedPreferences settings = getSharedPreferences(PREFS_FILE, PREFS_MODE);
        SharedPreferences.Editor editor = settings.edit();
        // write a boolean value
        editor.putBoolean(KEY_BOOLEAN, true);
        // write an integer value
        editor.putInt(KEY_INT, 123);
        // write a string
        editor.putString(KEY_STRING, "string value");
        // write a long value
        editor.putLong(KEY_LONG, 456876451);
        // write a float value
        editor.putFloat(KEY_FLOAT, 1.51f);
        editor.apply();
    }
}

getSharedPreferences() is een methode uit de klasse Context - welke Activity uitgebreid. Als u nodig hebt om toegang te krijgen tot de getSharedPreferences() methode van andere klassen, kunt u gebruik maken context.getSharedPreferences() met een Context Object reference van een Activity , View of Application .

Sleutels verwijderen

private static final String MY_PREF = "MyPref";

// ...

SharedPreferences prefs = ...;

// ...

SharedPreferences.Editor editor = prefs.edit();
editor.putString(MY_PREF, "value");
editor.remove(MY_PREF);
editor.apply();

Na de apply() , bevat prefs "sleutel" -> "waarde", naast wat het al bevatte. Hoewel het lijkt alsof ik "sleutel" heb toegevoegd en vervolgens heb verwijderd, gebeurt het verwijderen eigenlijk eerst. De wijzigingen in de Editor worden allemaal in één keer toegepast, niet in de volgorde waarin u ze hebt toegevoegd. Alle verwijderingen gebeuren voordat alle plaatsen.

Een instellingenscherm implementeren met SharedPreferences

Een gebruik van SharedPreferences is het implementeren van een scherm "Instellingen" in uw app, waar de gebruiker zijn voorkeuren / opties kan instellen. Soortgelijk:

Een PreferenceScreen slaat gebruikersvoorkeuren op in SharedPreferences . Om een PreferenceScreen te maken, hebt u een paar dingen nodig:

Een XML-bestand om de beschikbare opties te definiëren:

Dit gaat in /res/xml/preferences.xml en voor het bovenstaande instellingenscherm ziet het er zo uit:

<PreferenceScreen
    xmlns:android="http://schemas.android.com/apk/res/android">
    <PreferenceCategory
        android:title="General options">
        <CheckBoxPreference
            android:key = "silent_mode"
            android:defaultValue="false"
            android:title="Silent Mode"
            android:summary="Mute all sounds from this app" />

        <SwitchPreference
            android:key="awesome_mode"
            android:defaultValue="false"
            android:switchTextOn="Yes"
            android:switchTextOff="No"
            android:title="Awesome mode™"
            android:summary="Enable the Awesome Mode™ feature"/>

        <EditTextPreference
            android:key="custom_storage"
            android:defaultValue="/sdcard/data/"
            android:title="Custom storage location"
            android:summary="Enter the directory path where you want data to be saved. If it does not exist, it will be created."
            android:dialogTitle="Enter directory path (eg. /sdcard/data/ )"/>
    </PreferenceCategory>
</PreferenceScreen>

Dit definieert de beschikbare opties in het instellingenscherm. Er zijn veel andere soorten Preference opgesomd in de Android Developers-documentatie over de voorkeurklasse .

Vervolgens hebben we een activiteit nodig om onze gebruikersinterface voor voorkeuren te hosten . In dit geval is het vrij kort en ziet het er zo uit:

package com.example.preferences;

import android.preference.PreferenceActivity;
import android.os.Bundle;

public class PreferencesActivity extends PreferenceActivity {
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        addPreferencesFromResource(R.xml.preferences);
    }
}

Het breidt PreferenceActivity en biedt de gebruikersinterface voor het voorkeurenscherm. Het kan net als een normale activiteit worden gestart, in dit geval met iets als:

Intent i = new Intent(this, PreferencesActivity.class);
startActivity(i);

Vergeet niet PreferencesActivity toe te voegen aan je AndroidManifest.xml .

Het ophalen van de waarden van de voorkeuren in uw app is vrij eenvoudig. setDefaultValues() eerst setDefaultValues() aan om de standaardwaarden in te stellen die in uw XML zijn gedefinieerd en verkrijg vervolgens de standaard SharedPreferences . Een voorbeeld:

//set the default values we defined in the XML
PreferenceManager.setDefaultValues(this, R.xml.preferences, false);
SharedPreferences preferences = PreferenceManager.getDefaultSharedPreferences(this);
    
//get the values of the settings options
boolean silentMode = preferences.getBoolean("silent_mode", false);
boolean awesomeMode = preferences.getBoolean("awesome_mode", false);
    
String customStorage = preferences.getString("custom_storage", "");

Haal alle opgeslagen items uit een bepaald SharedPreferences-bestand op

De methode getAll() haalt alle waarden uit de voorkeuren. We kunnen het bijvoorbeeld gebruiken om de huidige inhoud van de SharedPreferences :

private static final String PREFS_FILE = "MyPrefs";

public static void logSharedPreferences(final Context context) {
    SharedPreferences sharedPreferences = context.getSharedPreferences(PREFS_FILE, Context.MODE_PRIVATE);
    Map<String, ?> allEntries = sharedPreferences.getAll();
    for (Map.Entry<String, ?> entry : allEntries.entrySet()) {
        final String key = entry.getKey();
        final Object value = entry.getValue();
        Log.d("map values", key + ": " + value);
    } 
}

De documentatie waarschuwt u voor het wijzigen van de Collection geretourneerd door getAll :

Houd er rekening mee dat u de verzameling die door deze methode wordt geretourneerd, niet mag wijzigen of de inhoud ervan mag wijzigen. De consistentie van uw opgeslagen gegevens is niet gegarandeerd als u dat doet.

Luisteren naar wijzigingen in SharedPreferences

SharedPreferences sharedPreferences = ...;
sharedPreferences.registerOnSharedPreferenceChangeListener(mOnSharedPreferenceChangeListener);


private final SharedPreferences.OnSharedPreferenceChangeListener mOnSharedPreferenceChangeListener = new SharedPreferences.OnSharedPreferenceChangeListener() {
    @Override
    public void onSharedPreferenceChanged(SharedPreferences sharedPreferences, String key) {
        //TODO
    }
}

Houd er rekening mee dat:

• De luisteraar zal alleen vuren als er waarde is toegevoegd of gewijzigd. Als dezelfde waarde wordt ingesteld, wordt deze niet aangeroepen;
• De luisteraar moet worden opgeslagen in een lidvariabele en NIET met een anonieme klasse, omdat registerOnSharedPreferenceChangeListener opslaat met een zwakke referentie, dus het zou vuilnis worden verzameld;
• In plaats van een lidvariabele te gebruiken, kan deze ook rechtstreeks door de klasse worden geïmplementeerd en vervolgens registerOnSharedPreferenceChangeListener(this); aanroepen registerOnSharedPreferenceChangeListener(this);
• Vergeet niet om de luisteraar af te melden wanneer dit niet langer nodig is met behulp van unregisterOnSharedPreferenceChangeListener .

Gegevens lezen en schrijven naar SharedPreferences met Singleton

Klasse SharedPreferences Manager (Singleton) om alle soorten gegevens te lezen en te schrijven.

import android.content.Context;
import android.content.SharedPreferences;
import android.util.Log;

import com.google.gson.Gson;

import java.lang.reflect.Type;

/**
 * Singleton Class for accessing SharedPreferences,
 * should be initialized once in the beginning by any application component using static
 * method initialize(applicationContext)
 */
public class SharedPrefsManager {
    
    private static final String TAG = SharedPrefsManager.class.getName();
    private SharedPreferences prefs;
    private static SharedPrefsManager uniqueInstance;
    public static final String PREF_NAME = "com.example.app";

    private SharedPrefsManager(Context appContext) {
        prefs = appContext.getSharedPreferences(PREF_NAME, Context.MODE_PRIVATE);
    }

    /**
     * Throws IllegalStateException if this class is not initialized
     *
     * @return unique SharedPrefsManager instance
     */
    public static SharedPrefsManager getInstance() {
        if (uniqueInstance == null) {
            throw new IllegalStateException(
                    "SharedPrefsManager is not initialized, call initialize(applicationContext) " +
                            "static method first");
        }
        return uniqueInstance;
    }

    /**
     * Initialize this class using application Context,
     * should be called once in the beginning by any application Component
     *
     * @param appContext application context
     */
    public static void initialize(Context appContext) {
        if (appContext == null) {
            throw new NullPointerException("Provided application context is null");
        }
        if (uniqueInstance == null) {
            synchronized (SharedPrefsManager.class) {
                if (uniqueInstance == null) {
                    uniqueInstance = new SharedPrefsManager(appContext);
                }
            }
        }
    }

    private SharedPreferences getPrefs() {
        return prefs;
    }

    /**
     * Clears all data in SharedPreferences
     */
    public void clearPrefs() {
        SharedPreferences.Editor editor = getPrefs().edit();
        editor.clear();
        editor.commit();
    }

    public void removeKey(String key) {
        getPrefs().edit().remove(key).commit();
    }

    public boolean containsKey(String key) {
        return getPrefs().contains(key);
    }

    public String getString(String key, String defValue) {
        return getPrefs().getString(key, defValue);
    }

    public String getString(String key) {
        return getString(key, null);
    }

    public void setString(String key, String value) {
        SharedPreferences.Editor editor = getPrefs().edit();
        editor.putString(key, value);
        editor.apply();
    }

    public int getInt(String key, int defValue) {
        return getPrefs().getInt(key, defValue);
    }

    public int getInt(String key) {
        return getInt(key, 0);
    }

    public void setInt(String key, int value) {
        SharedPreferences.Editor editor = getPrefs().edit();
        editor.putInt(key, value);
        editor.apply();
    }

    public long getLong(String key, long defValue) {
        return getPrefs().getLong(key, defValue);
    }

    public long getLong(String key) {
        return getLong(key, 0L);
    }

    public void setLong(String key, long value) {
        SharedPreferences.Editor editor = getPrefs().edit();
        editor.putLong(key, value);
        editor.apply();
    }

    public boolean getBoolean(String key, boolean defValue) {
        return getPrefs().getBoolean(key, defValue);
    }

    public boolean getBoolean(String key) {
        return getBoolean(key, false);
    }

    public void setBoolean(String key, boolean value) {
        SharedPreferences.Editor editor = getPrefs().edit();
        editor.putBoolean(key, value);
        editor.apply();
    }

    public boolean getFloat(String key) {
        return getFloat(key, 0f);
    }

    public boolean getFloat(String key, float defValue) {
        return getFloat(key, defValue);
    }

    public void setFloat(String key, Float value) {
        SharedPreferences.Editor editor = getPrefs().edit();
        editor.putFloat(key, value);
        editor.apply();
    }

    /**
     * Persists an Object in prefs at the specified key, class of given Object must implement Model
     * interface
     *
     * @param key         String
     * @param modelObject Object to persist
     * @param <M>         Generic for Object
     */
    public <M extends Model> void setObject(String key, M modelObject) {
        String value = createJSONStringFromObject(modelObject);
        SharedPreferences.Editor editor = getPrefs().edit();
        editor.putString(key, value);
        editor.apply();
    }

    /**
     * Fetches the previously stored Object of given Class from prefs
     *
     * @param key                String
     * @param classOfModelObject Class of persisted Object
     * @param <M>                Generic for Object
     * @return Object of given class
     */
    public <M extends Model> M getObject(String key, Class<M> classOfModelObject) {
        String jsonData = getPrefs().getString(key, null);
        if (null != jsonData) {
            try {
                Gson gson = new Gson();
                M customObject = gson.fromJson(jsonData, classOfModelObject);
                return customObject;
            } catch (ClassCastException cce) {
                Log.d(TAG, "Cannot convert string obtained from prefs into collection of type " +
                        classOfModelObject.getName() + "\n" + cce.getMessage());
            }
        }
        return null;
    }

    /**
     * Persists a Collection object in prefs at the specified key
     *
     * @param key            String
     * @param dataCollection Collection Object
     * @param <C>            Generic for Collection object
     */
    public <C> void setCollection(String key, C dataCollection) {
        SharedPreferences.Editor editor = getPrefs().edit();
        String value = createJSONStringFromObject(dataCollection);
        editor.putString(key, value);
        editor.apply();
    }

    /**
     * Fetches the previously stored Collection Object of given type from prefs
     *
     * @param key     String
     * @param typeOfC Type of Collection Object
     * @param <C>     Generic for Collection Object
     * @return Collection Object which can be casted
     */
    public <C> C getCollection(String key, Type typeOfC) {
        String jsonData = getPrefs().getString(key, null);
        if (null != jsonData) {
            try {
                Gson gson = new Gson();
                C arrFromPrefs = gson.fromJson(jsonData, typeOfC);
                return arrFromPrefs;
            } catch (ClassCastException cce) {
                Log.d(TAG, "Cannot convert string obtained from prefs into collection of type " +
                        typeOfC.toString() + "\n" + cce.getMessage());
            }
        }
        return null;
    }

    public void registerPrefsListener(SharedPreferences.OnSharedPreferenceChangeListener listener) {
        getPrefs().registerOnSharedPreferenceChangeListener(listener);
    }

    public void unregisterPrefsListener(

            SharedPreferences.OnSharedPreferenceChangeListener listener) {
        getPrefs().unregisterOnSharedPreferenceChangeListener(listener);
    }

    public SharedPreferences.Editor getEditor() {
        return getPrefs().edit();
    }

    private static String createJSONStringFromObject(Object object) {
        Gson gson = new Gson();
        return gson.toJson(object);
    } 
}

Model interface die wordt geïmplementeerd door klassen gaan naar Gson te proguard verwarring te voorkomen.

public interface Model {
    
}

Proguard regels voor het Model -interface:

-keep interface com.example.app.Model
-keep class * implements com.example.app.Model { *;}

Verschillende manieren om een object van SharedPreferences te instantiëren

U kunt op verschillende manieren toegang krijgen tot SharedPreferences:

Download het standaard SharedPreferences-bestand:

import android.preference.PreferenceManager;
SharedPreferences prefs = PreferenceManager.getDefaultSharedPreferences(this);

Download een specifiek SharedPreferences-bestand:

public static final String PREF_FILE_NAME = "PrefFile";
SharedPreferences prefs = getSharedPreferences(PREF_FILE_NAME, MODE_PRIVATE);

Download SharedPreferences van een andere app:

// Note that the other app must declare prefs as MODE_WORLD_WRITEABLE
final ArrayList<HashMap<String,String>> LIST = new ArrayList<HashMap<String,String>>();
Context contextOtherApp = createPackageContext("com.otherapp", Context.MODE_WORLD_WRITEABLE);
SharedPreferences prefs = contextOtherApp.getSharedPreferences("pref_file_name", Context.MODE_WORLD_READABLE); 

getPreferences (int) VS getSharedPreferences (String, int)

getPreferences(int)

geeft de voorkeuren terug die zijn opgeslagen met de klassennaam van Activity's class name zoals beschreven in de documenten :

Haal een SharedPreferences-object op voor toegang tot voorkeuren die privé zijn voor deze activiteit. Dit roept eenvoudig de onderliggende methode getSharedPreferences (String, int) op door de klassenaam van deze activiteit door te geven als de naam van de voorkeuren.

Tijdens het gebruik van de methode getSharedPreferences (tekenreeksnaam, int-modus) retourneert de methode de voorkeuren die zijn opgeslagen onder de opgegeven name . Zoals in de documenten:

Haal de inhoud van het voorkeurenbestand 'naam' op en houd deze vast, zodat een SharedPreferences wordt geretourneerd waarmee u de waarden kunt ophalen en wijzigen.

Dus als de waarde die wordt opgeslagen in de SharedPreferences in de hele app moet worden gebruikt, moet men getSharedPreferences (String name, int mode) met een vaste naam. Omdat het gebruik van getPreferences(int) de voorkeuren retourneert / opslaat die horen bij de Activity die het getPreferences(int) .

Commit versus Toepassen

De methode editor.apply() is asynchroon , terwijl editor.commit() synchroon is .

Uiteraard moet u ofwel apply() of commit() aanroepen.

SharedPreferences settings = getSharedPreferences(PREFS_FILE, MODE_PRIVATE);
SharedPreferences.Editor editor = settings.edit();
editor.putBoolean(PREF_CONST, true);
// This will asynchronously save the shared preferences without holding the current thread.
editor.apply();

SharedPreferences settings = getSharedPreferences(PREFS_FILE, MODE_PRIVATE);
SharedPreferences.Editor editor = settings.edit();
editor.putBoolean(PREF_CONST, true);
// This will synchronously save the shared preferences while holding the current thread until done and returning a success flag.
boolean result = editor.commit();

apply() is toegevoegd in 2.3 (API 9), het verbindt zich zonder een boolean terug te geven die op succes of mislukking wijst.

commit() retourneert true als het opslaan werkt, anders false.

apply() is toegevoegd omdat het Android-dev-team merkte dat bijna niemand kennis nam van de retourwaarde, dus apply is sneller omdat het asynchroon is.

In tegenstelling tot commit() , die zijn voorkeuren synchroon schrijft naar permanente opslag, brengt apply() de wijzigingen onmiddellijk door naar de SharedPreferences in het geheugen, maar start een asynchrone commit naar schijf en je wordt niet op de hoogte gebracht van eventuele fouten. Als een andere editor op deze SharedPreferences een reguliere commit() SharedPreferences terwijl een apply() nog openstaat, zal de commit() blokkeren totdat alle async commits (apply) zijn voltooid en alle andere sync commits die mogelijk in behandeling zijn.

Ondersteunde gegevenstypen in SharedPreferences

SharedPreferences kunt u alleen primitieve gegevenstypen opslaan ( boolean , float , long , int , String en string set ). U kunt geen complexere objecten opslaan in SharedPreferences , en als zodanig is het echt bedoeld als een plaats om gebruikersinstellingen of iets dergelijks op te slaan, het is niet bedoeld als een database om gebruikersgegevens te bewaren (zoals het opslaan van een takenlijst die een gebruiker bijvoorbeeld heeft gemaakt).

Om iets op te slaan in SharedPreferences u een sleutel en een waarde. De sleutel is hoe u kunt verwijzen naar wat u later hebt opgeslagen en de waardegegevens die u wilt opslaan.

    String keyToUseToFindLater = "High Score";
    int newHighScore = 12938;
    //getting SharedPreferences & Editor objects 
    SharedPreferences sharedPref = getActivity().getPreferences(Context.MODE_PRIVATE);
    SharedPreferences.Editor editor = sharedPref.edit();
    //saving an int in the SharedPreferences file
    editor.putInt(keyToUseToFindLater, newHighScore);
    editor.commit();

Gegevens opslaan, ophalen, verwijderen en wissen uit SharedPreferences

Maak SharedPreferences BuyyaPref

SharedPreferences pref = getApplicationContext().getSharedPreferences("BuyyaPref", MODE_PRIVATE); 
Editor editor = pref.edit();

Gegevens opslaan als KEY / VALUE-paar

editor.putBoolean("key_name1", true);           // Saving boolean - true/false
editor.putInt("key_name2", 10);        // Saving integer
editor.putFloat("key_name3", 10.1f);    // Saving float
editor.putLong("key_name4", 1000);      // Saving long
editor.putString("key_name5", "MyString");  // Saving string
 
// Save the changes in SharedPreferences
editor.commit(); // commit changes

Download SharedPreferences-gegevens

Als de waarde voor de sleutel niet bestaat, retourneer dan de tweede parameterwaarde (in dit geval null, is dit als de standaardwaarde)

pref.getBoolean("key_name1", null);         // getting boolean
pref.getInt("key_name2", null);             // getting Integer
pref.getFloat("key_name3", null);           // getting Float
pref.getLong("key_name4", null);            // getting Long
pref.getString("key_name5", null);          // getting String

Sleutelwaarde verwijderen uit SharedPreferences

editor.remove("key_name3"); // will delete key key_name3
editor.remove("key_name4"); // will delete key key_name4
 
// Save the changes in SharedPreferences
editor.commit(); // commit changes

Wis alle gegevens uit SharedPreferences

 editor.clear();
 editor.commit(); // commit changes

Ondersteuning pre-honingraat met StringSet

Hier is de gebruiksklasse:

public class SharedPreferencesCompat {

    public static void putStringSet(SharedPreferences.Editor editor, String key, Set<String> values) {
            if (Build.VERSION.SDK_INT >= 11) {
                while (true) {
                    try {
                        editor.putStringSet(key, values).apply();
                        break;
                    } catch (ClassCastException ex) {
                        // Clear stale JSON string from before system upgrade
                        editor.remove(key);
                    }
                }
            } else putStringSetToJson(editor, key, values);
    }

    public static Set<String> getStringSet(SharedPreferences prefs, String key, Set<String> defaultReturnValue) {
        if (Build.VERSION.SDK_INT >= 11) {
            try {
                return prefs.getStringSet(key, defaultReturnValue);
            } catch (ClassCastException ex) {
                // If user upgraded from Gingerbread to something higher read the stale JSON string
                return getStringSetFromJson(prefs, key, defaultReturnValue);
            }
        } else return getStringSetFromJson(prefs, key, defaultReturnValue);
    }

    private static Set<String> getStringSetFromJson(SharedPreferences prefs, String key, Set<String> defaultReturnValue) {
        final String input = prefs.getString(key, null);
        if (input == null) return defaultReturnValue;

        try {
            HashSet<String> set = new HashSet<>();
            JSONArray json = new JSONArray(input);
            for (int i = 0, size = json.length(); i < size; i++) {
                String value = json.getString(i);
                set.add(value);
            }
            return set;
        } catch (JSONException e) {
            e.printStackTrace();
            return defaultReturnValue;
        }
    }

    private static void putStringSetToJson(SharedPreferences.Editor editor, String key, Set<String> values) {
        JSONArray json = new JSONArray(values);
        if (Build.VERSION.SDK_INT >= 9)
            editor.putString(key, json.toString()).apply();
        else
            editor.putString(key, json.toString()).commit();
    }

    private SharedPreferencesCompat() {}
}

Een voorbeeld om voorkeuren op te slaan als StringSet-gegevenstype is:

Set<String> sets = new HashSet<>();
sets.add("John");
sets.add("Nicko");
SharedPreferences preferences = PreferenceManager.getDefaultSharedPreferences(this);
SharedPreferencesCompat.putStringSet(preferences.edit(), "pref_people", sets);

Om ze terug te halen:

Set<String> people = SharedPreferencesCompat.getStringSet(preferences, "pref_people", new HashSet<String>());

Referentie: Android-ondersteuningsvoorkeuren

Filter toevoegen voor EditTextPreference

Maak deze klasse:

public class InputFilterMinMax implements InputFilter {

    private int min, max;

    public InputFilterMinMax(int min, int max) {
        this.min = min;
        this.max = max;
    }

    public InputFilterMinMax(String min, String max) {
        this.min = Integer.parseInt(min);
        this.max = Integer.parseInt(max);
    }

    @Override
    public CharSequence filter(CharSequence source, int start, int end, Spanned dest, int dstart, int dend) {
        try {
            int input = Integer.parseInt(dest.toString() + source.toString());
            if (isInRange(min, max, input))
                return null;
        } catch (NumberFormatException nfe) { }
        return "";
    }

    private boolean isInRange(int a, int b, int c) {
        return b > a ? c >= a && c <= b : c >= b && c <= a;
    }
}

Gebruik :

EditText compressPic = ((EditTextPreference) findPreference(getString("pref_key_compress_pic"))).getEditText();
compressPic.setFilters(new InputFilter[]{ new InputFilterMinMax(1, 100) });