Użyj zapisanych wartości preferencji Zawiera Android Jetpack.

W tym dokumencie opisujemy, jak przechowywać i wykorzystywać Preference wartości zapisane przez do biblioteki preferencji.

Przechowywanie danych preferencji

Ta sekcja zawiera informacje o tym, jak Preference może przechowywać dane.

Ustawienia wspólne

Domyślnie Preference używa SharedPreferences do zapisania . Interfejs API SharedPreferences obsługuje proste odczytywanie i zapisywanie par klucz-wartość z pliku zapisywanego dla wszystkich sesji aplikacji. Biblioteka preferencji używa prywatnej instancji SharedPreferences, więc tylko nie może uzyskać do niego dostępu.

Załóżmy na przykład, że: SwitchPreferenceCompat:

<SwitchPreferenceCompat
        app:key="notifications"
        app:title="Enable message notifications"/>

Gdy użytkownik włączy przełącznik. stan, plik SharedPreferences aktualizacji za pomocą pary klucz-wartość "notifications" : "true". Używany klucz to taki sam jak klucz ustawiony w kluczu Preference.

Więcej informacji o interfejsie API SharedPreferences znajdziesz w artykule Zapisywanie pary klucz-wartość .

Informacje na temat różnych sposobów przechowywania danych na urządzeniu z Androidem znajdziesz w sekcji Dane i przechowywania plików.

Magazyn danych preferencji

Chociaż biblioteka preferencji przechowuje dane z elementami SharedPreferences przez Domyślnie SharedPreferences nie zawsze jest idealnym rozwiązaniem. Na przykład, jeśli aplikacja wymaga zalogowania się przez użytkownika, warto jednak ustawień aplikacji w chmurze, aby te ustawienia były odzwierciedlane we wszystkich usługach na innych urządzeniach i platformach. Jeśli aplikacja ma konfigurację specyficznych dla danego urządzenia, każdy użytkownik ma osobne ustawienia, co sprawia, że SharedPreferences nie jest idealnym rozwiązaniem.

PreferenceDataStore umożliwia używanie niestandardowego backendu pamięci masowej do utrwalania wartości Preference. Więcej informacje zawiera artykuł na temat używania niestandardowego magazynu danych.

Odczytywanie wartości preferencji

Aby pobrać używany obiekt SharedPreferences, wywołaj PreferenceManager.getDefaultSharedPreferences() Chociaż ta metoda działa z dowolnego miejsca w aplikacji, zalecamy podzielisz aplikację na warstwy. Więcej informacji można znaleźć w sekcji Dane warstwy danych.

Na przykład dla EditTextPreference z kluczem "signature", jak następujące:

<EditTextPreference
        app:key="signature"
        app:title="Your signature"/>

Zapisaną wartość parametru Preference możesz pobrać globalnie w ten sposób:

val sharedPreferences = PreferenceManager.getDefaultSharedPreferences(this /* Activity context */)
val name = sharedPreferences.getString("signature", "")

SharedPreferences sharedPreferences =
        PreferenceManager.getDefaultSharedPreferences(this /* Activity context */);
String name = sharedPreferences.getString("signature", "");

Wykrywaj zmiany wartości preferencji

Aby wykryć zmiany wartości parametru Preference, możesz wybrać jedną z 2 opcji interfejsy:

• Preference.OnPreferenceChangeListener
• SharedPreferences.OnSharedPreferenceChangeListener

W poniższej tabeli przedstawiono różnice między tymi dwoma interfejsami:

Implementacja OnPreferenceChangeListener

Implementacja OnPreferenceChangeListener umożliwia nasłuchiwanie oczekujących zmiana na wartość Preference. Następnie możesz sprawdzić, czy zmiana ma miejsce. Na przykład ten kod pokazuje, jak nasłuchiwać zmian w wartości EditTextPreference z kluczem "name":

override fun onPreferenceChange(preference: Preference, newValue: Any): Boolean {
    Log.e("preference", "Pending Preference value is: $newValue")
    return true
}

@Override
public boolean onPreferenceChange(Preference preference, Object newValue) {
    Log.e("preference", "Pending Preference value is: " + newValue);
    return true;
}

Następnie musisz ustawić tego detektora bezpośrednio za pomocą setOnPreferenceChangeListener() w następujący sposób:

preference.onPreferenceChangeListener = ...

preference.setOnPreferenceChangeListener(...);

Implementowanie obiektu OnSharedPreferenceChangeListener

Jeśli zachowujesz wartości Preference za pomocą SharedPreferences, możesz też użyć funkcji SharedPreferences.OnSharedPreferenceChangeListener, aby nasłuchiwać zmian. Dzięki temu możesz nasłuchiwać, gdy wartości zapisane przez Preference ulegną zmianie, np. podczas synchronizowania ustawień z serwerem. Ten przykład pokazuje, jak nasłuchuj zmiany wartości EditTextPreference z kluczem "name":

override fun onSharedPreferenceChanged(sharedPreferences: SharedPreferences, key: String) {
    if (key == "signature") {
        Log.i(TAG, "Preference value was updated to: " + sharedPreferences.getString(key, ""))
    }
}

@Override
public void onSharedPreferenceChanged(SharedPreferences sharedPreferences, String key) {
    if (key.equals("signature")) {
        Log.i(TAG, "Preference value was updated to: " + sharedPreferences.getString(key, ""));
    }
}

Rejestrowanie detektora za pomocą registerOnSharedPreferenceChangedListener() w następujący sposób:

preferenceManager.sharedPreferences.registerOnSharedPreferenceChangeListener(...)

getPreferenceManager().getSharedPreferences().registerOnSharedPreferenceChangeListener(...);

    val listener: SharedPreferences.OnSharedPreferenceChangeListener =
            SharedPreferences.OnSharedPreferenceChangeListener {...}
    

    SharedPreferences.OnSharedPreferenceChangeListener listener =
            new SharedPreferences.OnSharedPreferenceChangeListener() {...}
    

Aby zapewnić prawidłowe zarządzanie cyklem życia produktów (Activity lub Fragment), zarejestruj się wyrejestruj ten detektor w wywołaniach zwrotnych onResume() i onPause(), jak pokazano w tym przykładzie:

override fun onResume() {
    super.onResume()
    preferenceManager.sharedPreferences.registerOnSharedPreferenceChangeListener(this)
}

override fun onPause() {
    super.onPause()
    preferenceManager.sharedPreferences.unregisterOnSharedPreferenceChangeListener(this)
}

@Override
public void onResume() {
    super.onResume();
    getPreferenceManager().getSharedPreferences().registerOnSharedPreferenceChangeListener(this);
}

@Override
public void onPause() {
    super.onPause();
    getPreferenceManager().getSharedPreferences().unregisterOnSharedPreferenceChangeListener(this);
}

Użyj niestandardowego magazynu danych

Zalecamy zachowywanie obiektów Preference przy użyciu SharedPreferences, możesz też użyć niestandardowego magazynu danych. Niestandardowy magazyn danych może być przydatny, jeśli aplikacja utrzymuje wartości w bazie danych lub jeśli wartości są związane z urządzeniem, jak co widać w poniższych przykładach.

Wdróż magazyn danych

Aby wdrożyć niestandardowy magazyn danych, utwórz klasę, która rozszerza PreferenceDataStore Poniższy przykład pokazuje magazyn danych, który obsługuje String wartości:

class DataStore : PreferenceDataStore() {
    override fun putString(key: String, value: String?) {
        // Save the value somewhere.
    }

    override fun getString(key: String, defValue: String?): String? {
        // Retrieve the value.
    }
}

public class DataStore extends PreferenceDataStore {
    @Override
    public void putString(String key, @Nullable String value) {
        // Save the value somewhere.
    }
    @Override
    @Nullable
    public String getString(String key, @Nullable String defValue) {
        // Retrieve the value.
    }
}

uruchamiać czasochłonne operacje poza wątkiem głównym, aby nie blokować użytkownika; za pomocą prostego interfejsu online. Możliwe, że w parametrze Fragment lub Activity zawierającym magazyn danych do zniszczenia przy zachowaniu wartości, zserializuj dane w taki sposób, nie utracą żadnych wartości zmienionych przez użytkownika.

Włącz magazyn danych

Po zaimplementowaniu magazynu danych ustaw nowy magazyn w onCreatePreferences(), aby Preference obiekty utrzymywały wartości z argumentem w bazie danych zamiast domyślnego magazynu danych SharedPreferences. Możesz włączyć dla każdego magazynu danych Preference lub całej hierarchii.

Aby włączyć niestandardowy magazyn danych dla określonego magazynu danych Preference, wywołaj setPreferenceDataStore(). Preference, jak w tym przykładzie:

val preference: Preference? = findPreference("key")
preference?.preferenceDataStore = dataStore

Preference preference = findPreference("key");
if (preference != null) {
    preference.setPreferenceDataStore(dataStore);
}

Aby włączyć niestandardowy magazyn danych dla całej hierarchii, wywołaj setPreferenceDataStore() (PreferenceManager):

val preferenceManager = preferenceManager
preferenceManager.preferenceDataStore = dataStore

PreferenceManager preferenceManager = getPreferenceManager();
preferenceManager.setPreferenceDataStore(dataStore);

Magazyn danych ustawiony dla konkretnego Preference zastępuje każdy magazyn danych, który dla odpowiedniej hierarchii. W większości przypadków magazyn danych ustawia się dla całą hierarchię.