Gespeicherte Einstellungswerte verwenden Teil von Android Jetpack

In diesem Dokument wird beschrieben, wie Sie Preference-Werte, die von die Einstellungsbibliothek aus.

Bevorzugte Datenspeicherung

In diesem Abschnitt wird beschrieben, wie ein Preference Daten dauerhaft speichern kann.

Gemeinsame Einstellungen

Standardmäßig verwendet ein Preference Zum Speichern SharedPreferences Werte. Die SharedPreferences API unterstützt das Lesen und Schreiben einfacher Schlüssel/Wert-Paare aus einer Datei, die über mehrere Anwendungssitzungen gespeichert wird. Die Die Einstellungsbibliothek verwendet eine private SharedPreferences-Instanz, sodass nur Ihre App darauf zugreifen kann.

Angenommen, SwitchPreferenceCompat:

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

Wenn ein Nutzer diesen Schalter auf „Ein“ setzt wird die Datei SharedPreferences mit dem Schlüssel/Wert-Paar "notifications" : "true" aktualisiert. Der verwendete Schlüssel ist der entspricht dem für Preference festgelegten Schlüssel.

Weitere Informationen zur SharedPreferences API finden Sie unter Schlüssel/Wert-Paar speichern Daten.

Informationen über die verschiedenen Möglichkeiten zum Speichern von Daten auf Android finden Sie unter Daten und Dateispeicher.

Präferenzdatenspeicher

Obwohl die Präferenzbibliothek Daten mit SharedPreferences speichert, SharedPreferences sind nicht immer eine ideale Lösung. Wenn beispielsweise Ihre Anwendung erfordert, dass sich ein Nutzer anmeldet, sollten Sie in der Cloud gespeichert, sodass diese für alle anderen Geräten und Plattformen. Wenn Ihre Anwendung über Konfigurationseinstellungen verfügt, Optionen, die gerätespezifisch sind, hat jeder Nutzer auf dem Gerät eigene Einstellungen, Dadurch ist SharedPreferences eine weniger gute Lösung.

PreferenceDataStore können Sie ein benutzerdefiniertes Speicher-Back-End verwenden, um Preference-Werte beizubehalten. Weitere Informationen finden Sie unter Benutzerdefinierten Datenspeicher verwenden.

Werte von Leseeinstellungen

Rufen Sie zum Abrufen des verwendeten SharedPreferences-Objekts den folgenden Befehl auf: PreferenceManager.getDefaultSharedPreferences() Obwohl diese Methode überall in Ihrer Anwendung funktioniert, empfehlen wir, teilen Sie Ihre App in Ebenen auf. Weitere Informationen finden Sie unter Daten Ebene

Beispiel: Bei einem EditTextPreference mit dem Schlüssel "signature", wie folgt:

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

So können Sie den gespeicherten Wert für Preference global abrufen:

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

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

Auf Änderungen der Einstellungswerte warten

Sie können zwischen zwei Optionen wählen, um auf Änderungen an Preference-Werten zu warten. Schnittstellen:

• Preference.OnPreferenceChangeListener
• SharedPreferences.OnSharedPreferenceChangeListener

Die folgende Tabelle zeigt, wie sich die beiden Oberflächen unterscheiden:

OnPreferenceChangeListener implementieren

Durch die Implementierung eines OnPreferenceChangeListener können Sie auf einen ausstehenden in den Wert einer Preference ändern. Dann können Sie überprüfen, ob die Änderung erfolgt. Der folgende Code zeigt beispielsweise, wie auf eine Änderung am Wert einer EditTextPreference mit dem Schlüssel "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;
}

Als Nächstes legen Sie diesen Listener direkt mit setOnPreferenceChangeListener(), wie folgt:

preference.onPreferenceChangeListener = ...

preference.setOnPreferenceChangeListener(...);

OnSharedPreferenceChangeListener implementieren

Wenn Sie Preference-Werte mit SharedPreferences dauerhaft speichern, können Sie auch Folgendes verwenden: SharedPreferences.OnSharedPreferenceChangeListener, um auf Änderungen zu warten. So können Sie darauf warten, dass sich die von Preference gespeicherten Werte ändern. z. B. wenn Einstellungen mit einem Server synchronisiert werden. Das folgende Beispiel zeigt, wie Sie Auf Änderung des Werts eines EditTextPreference mit dem Schlüssel warten "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, ""));
    }
}

Registrieren Sie den Listener mithilfe von registerOnSharedPreferenceChangedListener(), wie folgt:

preferenceManager.sharedPreferences.registerOnSharedPreferenceChangeListener(...)

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

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

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

Für eine ordnungsgemäße Lebenszyklusverwaltung in Activity oder Fragment registrieren und hebt die Registrierung dieses Listeners in den Callbacks onResume() und onPause() auf, wie hier gezeigt. im folgenden Beispiel:

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

Benutzerdefinierten Datenspeicher verwenden

Obwohl wir empfehlen, Preference-Objekte mit SharedPreferences dauerhaft zu speichern, können Sie auch einen benutzerdefinierten Datenspeicher verwenden. Ein benutzerdefinierter Datenspeicher kann nützlich sein, oder wenn Werte gerätespezifisch sind, wie z. B. die in den folgenden Beispielen gezeigt werden.

Datenspeicher implementieren

Erstellen Sie zum Implementieren eines benutzerdefinierten Datenspeichers eine Klasse, die das PreferenceDataStore Im folgenden Beispiel wird ein Datenspeicher erstellt, String-Werte:

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

Zeitaufwendige Vorgänge außerhalb des Hauptthreads ausführen, um den Nutzer nicht zu blockieren . Da es möglich ist, dass Fragment oder Activity beim Speichern eines Werts gelöscht werden soll, serialisieren Sie die Daten, gehen keine vom Nutzer geänderten Werte verloren.

Datenspeicher aktivieren

Nachdem Sie den Datenspeicher implementiert haben, legen Sie den neuen Datenspeicher in onCreatePreferences(), damit Preference-Objekte Werte mit der Eigenschaft Datenspeicher gespeichert, anstatt den Standard-SharedPreferences zu verwenden. Sie können eine Datenspeicher für jede Preference oder für die gesamte Hierarchie.

Rufen Sie zum Aktivieren eines benutzerdefinierten Datenspeichers für eine bestimmte Preference Folgendes auf: setPreferenceDataStore() zum Preference, wie im folgenden Beispiel gezeigt:

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

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

Um einen benutzerdefinierten Datenspeicher für eine gesamte Hierarchie zu aktivieren, rufen Sie setPreferenceDataStore() am PreferenceManager:

val preferenceManager = preferenceManager
preferenceManager.preferenceDataStore = dataStore

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

Ein Datenspeicher, der für eine bestimmte Preference festgelegt ist, überschreibt alle Datenspeicher, die für die entsprechende Hierarchie festgelegt ist. In den meisten Fällen legen Sie einen Datenspeicher für der gesamten Hierarchie.