Android
SharedPreferences

Wprowadzenie

Składnia

• Metoda kontekstowa

  • public SharedPreferences getSharedPreferences (nazwa ciągu, tryb int)

• Metoda działania

  • public SharedPreferences getPreferences ()

• Metody SharedPreferences

  • public SharedPreferences.Editor edit ()
  • public boolean zawiera ()
  • public Map <String,?> getAll ()
  • public boolean getBoolean (String string, boolean defValue)
  • public float getFloat (String string, float defValue)
  • public int getInt (String string, int defValue)
  • public long getLong (klucz string, długi defValue)
  • public String getString (Key string, String defValue)
  • public Set getStringSet (String string, Set defValues)
  • public void registerOnSharedPreferenceChangeListener (nasłuchiwanie SharedPreferences.OnSharedPreferenceChangeListener)
  • public void unregisterOnSharedPreferenceChangeListener (nasłuchiwanie SharedPreferences.OnSharedPreferenceChangeListener)

• Metody SharedPreferences.Editor

  • public void Apply ()
  • public boolean commit ()
  • public SharedPreferences.Editor clear ()
  • public SharedPreferences.Editor putBoolean (Klucz ciągu, wartość boolowska)
  • public SharedPreferences.Editor putFloat (Klucz ciągu, wartość zmiennoprzecinkowa)
  • public SharedPreferences.Editor putInt (klucz string, wartość int)
  • public SharedPreferences.Editor putLong (Klucz ciągu, długa wartość)
  • public SharedPreferences.Editor putString (Klucz ciągu, Wartość ciągu)
  • public SharedPreferences.Editor putStringSet (klucz string, ustaw wartości)
  • public SharedPreferences.Editor remove (String string)

Parametry

Uwagi

Odczytywanie i zapisywanie wartości w 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() to metoda z klasy Context - która rozszerza Activity . Jeśli potrzebujesz uzyskać dostęp do metody getSharedPreferences() z innych klas, możesz użyć context.getSharedPreferences() z odwołaniem do obiektu Context z Activity , View lub Application .

Usuwanie kluczy

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();

Po apply() prefs zawiera „key” -> „value”, oprócz wszystkiego, co już zawierał. Mimo że wygląda na to, że dodałem „klucz”, a następnie go usunąłem, usunięcie odbywa się w pierwszej kolejności. Wszystkie zmiany w Editor są stosowane za jednym razem, a nie w kolejności ich dodania. Wszystkie operacje usuwania są wykonywane przed wprowadzeniem wszystkich operacji.

Implementowanie ekranu ustawień za pomocą SharedPreferences

Jednym z zastosowań SharedPreferences jest zaimplementowanie w aplikacji ekranu „Ustawienia”, na którym użytkownik może ustawić swoje preferencje / opcje. Lubię to:

PreferenceScreen zapisuje preferencje użytkownika w SharedPreferences . Aby utworzyć ekran preferencji, potrzebujesz kilku rzeczy:

Plik XML do zdefiniowania dostępnych opcji:

To jest w /res/xml/preferences.xml , a dla powyższego ekranu ustawień wygląda to tak:

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

Określa dostępne opcje na ekranie ustawień. Istnieje wiele innych rodzajów Preference wymienionych w dokumentacji dla programistów Androida na temat klasy preferencji .

Następnie potrzebujemy działania do obsługi interfejsu użytkownika Preferencji . W tym przypadku jest dość krótki i wygląda następująco:

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

Rozszerza PreferenceActivity i zapewnia interfejs użytkownika dla ekranu preferencji. Można go uruchomić tak jak normalną czynność, w tym przypadku za pomocą czegoś takiego:

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

Nie zapomnij dodać PreferencesActivity do AndroidManifest.xml .

Pobieranie wartości preferencji w aplikacji jest dość proste, wystarczy wywołać najpierw setDefaultValues() , aby ustawić domyślne wartości zdefiniowane w pliku XML, a następnie uzyskać domyślne SharedPreferences . Przykład:

//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", "");

Pobierz wszystkie zapisane wpisy z określonego pliku SharedPreferences

Metoda getAll() pobiera wszystkie wartości z preferencji. Możemy go użyć na przykład do zarejestrowania bieżącej zawartości 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);
    } 
}

Dokumentacja ostrzega przed modyfikacją Collection zwróconej przez getAll :

Pamiętaj, że nie wolno modyfikować kolekcji zwróconej tą metodą ani zmieniać jej zawartości. W takim przypadku nie gwarantuje się spójności przechowywanych danych.

Odsłuchiwanie zmian w SharedPreferences

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


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

Proszę zanotować:

• Odbiornik będzie uruchamiany tylko wtedy, gdy wartość zostanie dodana lub zmieniona, ustawienie tej samej wartości nie wywoła go;
• Odbiornik musi zostać zapisany w zmiennej członkowskiej, a NIE w anonimowej klasie, ponieważ registerOnSharedPreferenceChangeListener przechowuje go ze słabym odwołaniem, aby był wyrzucany przez śmieci;
• Zamiast używać zmiennej składowej, może być również bezpośrednio zaimplementowana przez klasę, a następnie wywołać registerOnSharedPreferenceChangeListener(this);
• Pamiętaj, aby wyrejestrować nasłuchiwanie, gdy nie jest już wymagane, używając unregisterOnSharedPreferenceChangeListener .

Odczytywanie i zapisywanie danych w SharedPreferences za pomocą Singleton

Klasa SharedPreferences Manager (Singleton) do odczytu i zapisu wszystkich typów danych.

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

interface Model interface który jest implementowany przez klasy idące do Gson aby uniknąć progresywnego zaciemnienia.

public interface Model {
    
}

Zasady postępu dla interfejsu Model :

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

Różne sposoby tworzenia instancji obiektu SharedPreferences

Dostęp do SharedPreferences można uzyskać na kilka sposobów:

Pobierz domyślny plik SharedPreferences:

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

Uzyskaj konkretny plik SharedPreferences:

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

Uzyskaj SharedPreferences z innej aplikacji:

// 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)

zwraca preferencje zapisane przez Activity's class name zgodnie z opisem w dokumentacji :

Pobierz obiekt SharedPreferences, aby uzyskać dostęp do preferencji prywatnych dla tego działania. To po prostu wywołuje podstawową metodę getSharedPreferences (String, int), przekazując nazwę klasy tego działania jako nazwę preferencji.

Podczas korzystania z getSharedPreferences (nazwa ciągu, tryb int) metoda zwraca prefiksy zapisane pod podaną name . Tak jak w dokumentach:

Pobierz i przytrzymaj zawartość pliku preferencji „name”, zwracając wartość SharedPreferences, dzięki której możesz pobierać i modyfikować jej wartości.

Więc jeśli wartość zapisana w SharedPreferences musi być używana w aplikacji, należy użyć getSharedPreferences (String name, int mode) ze stałą nazwą. Ponieważ użycie getPreferences(int) zwraca / zapisuje preferencje należące do Activity go wywołuje.

Zatwierdź vs. Zastosuj

Metoda editor.apply() jest asynchroniczna , a editor.commit() synchroniczna .

Oczywiście powinieneś wywołać albo apply() albo commit() .

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() został dodany w 2.3 (API 9), zatwierdza bez zwracania wartości logicznej wskazującej powodzenie lub niepowodzenie.

commit() zwraca true, jeśli składowanie działa, false w przeciwnym razie.

dodano apply() ponieważ zespół programistów Androida zauważył, że prawie nikt nie zwrócił uwagi na wartość zwracaną, więc zastosowanie jest szybsze, ponieważ jest asynchroniczne.

W przeciwieństwie do commit() , który synchronicznie zapisuje swoje preferencje w trwałym magazynie, apply() natychmiast zatwierdza zmiany w SharedPreferences w pamięci, ale uruchamia asynchroniczne zatwierdzanie na dysku i nie zostaniesz powiadomiony o żadnych awariach. Jeśli inny edytor na tej SharedPreferences robi regularne commit() , podczas gdy apply() jest nadal znakomita, commit() będzie blokował aż wszystkie commity asynchroniczny (zastosowanie) są zakończone, a także wszelkich innych zatwierdzeń synchronizacji, które mogą być oczekujących.

Obsługiwane typy danych w SharedPreferences

SharedPreferences pozwala przechowywać tylko podstawowe typy danych ( boolean , float , long , int , String i string set ). Nie możesz przechowywać bardziej złożonych obiektów w SharedPreferences , a ponieważ tak naprawdę ma to być miejsce do przechowywania ustawień użytkownika lub podobnych, nie jest to baza danych do przechowywania danych użytkownika (na przykład zapisywanie listy rzeczy do zrobienia wykonanej przez użytkownika).

Aby przechowywać coś w SharedPreferences , używasz klucza i wartości. Kluczem jest sposób, w jaki możesz odwoływać się do tego, co później zapisałeś, oraz danych wartości, które chcesz przechowywać.

    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();

Przechowuj, pobieraj, usuwaj i usuwaj dane z SharedPreferences

Utwórz SharedPreferences BuyyaPref

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

Przechowywanie danych jako pary KEY / VALUE

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

Uzyskaj dane SharedPreferences

Jeśli wartość klucza nie istnieje, zwracana jest druga wartość parametru (w tym przypadku null, to jest jak wartość domyślna)

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

Usuwanie wartości klucza z 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

Wyczyść wszystkie dane z SharedPreferences

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

Obsługuje wstępną strukturę plastra miodu za pomocą StringSet

Oto klasa użyteczności:

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() {}
}

Przykładem zapisywania preferencji jako typu danych StringSet jest:

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

Aby je odzyskać:

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

Odniesienie: Preferencje obsługi Androida

Dodaj filtr do EditTextPreference

Utwórz tę klasę:

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

Posługiwać się :

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