Programmier Tutorial: Apps für Android entwickeln – Teil 34: Eine Standard-Einstellung für unsere App bereitstellen

---

Anschließend werden wir im praktischen Teil dieser Lektion eine XML-Ressourcen Datei erstellen und in ihr ein SwitchPreference-Element definieren, über das das zu verwendenden Datenformat vorgegeben werden kann. Dieses Preference-Element werden wir danach von der SettingsFragment-Klasse zu einer App-Einstellung umwandeln lassen.

Den aktuellen Wert der SwitchPreference-Einstellung werden wir dann in der MainActivity-Klasse aus den SharedPreferences auslesen und anhand des Wertes den Anfrage-String des HTTP-Requests bilden, so dass entweder XML- oder JSON-Daten vom Webserver angefordert werden.

Um den Benutzer besser über die von ihm getätigte Einstellung zu informieren, werden wir danach das OnPreferenceChangeListener-Interface der SettingsActivity-Klasse implementieren, welches auf Einstellungsänderungen reagiert und den Zusammenfassungstext der SwitchPreference-Einstellung entsprechend anpasst.

Abschließend werden wir unsere Android App im Emulator auf einem Android Virtual Device ausführen und prüfen, ob die SettingsActivity die App-Einstellung korrekt erzeugt und unsere Anwendung den vom Benutzer eingestellten Wert für die Datenabfrage verwendet.

1. App-Einstellungen aus Preference-Elementen erzeugen

In der vorherigen Lektion haben wir eine SettingsActivity implementiert und in diese ein SettingsFragment eingebunden. Das SettingsFragment wurde von der Klasse PreferenceFragmentCompat abgeleitet und besitzt daher alle Eigenschaften eines Fragments und zusätzliche Eigenschaften der Preference-API von Android.

Wir können daher mit Hilfe des SettingsFragment unsere App-Einstellungen erzeugen und verwalten lassen. Alles was wir dafür noch benötigen, ist eine XML-Ressourcen Datei, in welcher die Einstellungen in Form von Preference-Elementen definiert worden sind. Das SettingsFragment ist Dank der Preference-API in der Lage die definierten Preference-Elemente selbständig in App-Einstellungen umzuwandeln und dabei für diese eine Benutzeroberfläche zu erzeugen.

Von dem Android Framework werden bereits einige Standard-Einstellungen bereitgestellt, die für die meisten Aufgaben auch ausreichend sind. Möchte man jedoch komplexere Einstellungen in die eigene Anwendung einbinden, müssen diese selbst implementiert werden.

Die folgenden Preference-Elemente sind bereits in Android implementiert und können direkt in der XML-Ressourcen Datei als App-Einstellung genutzt werden:

• CheckBoxPreference – Ist eine Einstellung, die über ein Kästchen aktiviert oder deaktiviert werden kann. Der gespeicherte Wert ist vom boolean-Datentyp und true, falls das Kästchen angehakt wurde.

• SwitchPreference – Ist eine Einstellung, die über einen Schalter eingestellt werden kann. Der gespeicherte Wert ist vom boolean-Datentyp und true, falls der Schalter nach rechts geschoben wurde.

• EditTextPreference – Durch Klick auf diese Einstellung öffnet sich ein Dialog mit einem EditText-Widget, in welches ein String-Wert eingegeben werden kann.

• ListPreference – Durch Klick auf diese Einstellung öffnet sich ein Dialog mit einer Liste von Einträgen. Das ausgewählte Listenelement wird als Einstellungswert gespeichert. Der Datentypen der Listenelemente kann boolean, float, int, long oder String sein.

Die aus einer XML-Datei erzeugten App-Einstellungen werden vom SettingsFragment selbständig verwaltet. Ändert der Benutzer eine App-Einstellung, wird vom Fragment automatisch der neue Wert in die SharedPreferences gespeichert. Da dies im Hintergrund erfolgt, nimmt der Nutzer von der Einstellungsänderung jedoch keine Kenntnis.

Bei einigen App-Einstellungen ist dies auch in Ordnung. Bei Einstellungen die nicht selbsterklärend sind, ist es jedoch besser, den Benutzern Rückmeldung über die vorgenommene Änderung zu geben. Dazu muss ein OnPreferenceChangeListener für die entsprechende Einstellung implementiert und registriert werden. Mit dem Listener können dann Änderungen an der Einstellung direkt erfasst und die Benutzer über die vorgenommene Änderung ausführlich informiert werden.

Zum Erzeugen der App-Einstellungen sind somit die folgenden drei Arbeitsschritte erforderlich:

1. Definieren der Preference-Elemente – Zuerst müssen die gewünschten Preference-Elemente in einer XML-Ressourcen Datei definiert werden. Die XML-Datei muss sich in dem Ordner res/xml/ befinden und sollte den Dateinamen preferences.xml tragen.

2. Umwandeln der Preference-Elemente – Die per XML definierten Preference-Elemente müssen anschließend von dem SettingsFragment in App-Einstellungen umgewandelt werden. Dies geschieht mit Hilfe der addPreferencesFromResource() Methode, der die ID der XML-Ressourcen Datei preferences.xml übergeben wird.

3. Reagieren auf Einstellungsänderungen – Zwar verwaltet die Preference-API die App-Einstellungen selbständig, jedoch ohne den Benutzer darüber Rückmeldungen zu geben. Mit einem OnPreferenceChangeListener kann auf Einstellungsänderungen reagiert und der Benutzer über seine getätigte Auswahl informiert werden.

1.1 Definieren der Preference-Elemente in einer XML-Datei

Im ersten Schritt müssen die gewünschten Preference-Elemente in einer XML-Ressourcen Datei definiert werden. Die XML-Datei muss sich in dem Ordner res/xml/ befinden. Der Dateiname kann beliebig vorgegeben werden. Es ist jedoch sehr zu empfehlen der Datei den Name preferences.xml zu geben.

Hinweis: Die Preference-Elemente können zwar auch zur Laufzeit instanziiert werden, das Verwenden einer XML-Datei zum Definieren der Einstellung mittels einer Hierarchie an Preference-Elementen ist jedoch zu bevorzugen. Durch Verwenden einer XML-Datei kann die Struktur der Einstellungen besser überblickt und leichter verändert werden.

In dieser XML-Datei können nun mehrere Preference-Elemente per XML-Vokabular definiert werden. Mit Hilfe der Preference-API können die einzelnen Elemente dann später direkt in App-Einstellungen mit einer eigenen Benutzeroberfläche umgewandelt werden.

Die Preference-Elemente werden wie folgt definiert:

preferences.xml

<?xml version="1.0" encoding="utf-8"?>
<androidx.preference.PreferenceScreen 
    xmlns:android="http://schemas.android.com/apk/res/android">

    <PreferenceCategory android:title="Unsere Kategorie">

        <CheckBoxPreference
            android:key="key_checkbox_preference"
            android:title="Titel der Checkbox-Einstellung"
            android:summary="Eine kurze Erklärung für die Benutzer."
            android:defaultValue="true" />

        <SwitchPreferenceCompat
            android:key="key_switch_preference"
            android:title="Titel der Switch-Einstellung"
            android:summary="Eine weitere kurze Erklärung für die Benutzer."
            android:defaultValue="false" />

    </PreferenceCategory>
</androidx.preference.PreferenceScreen>

Mit dem oberen Code-Beispiel wird ein Einstellungsbildschirm (Preference Screen) per XML definiert. Das Wurzelelement der XML-Datei muss dabei immer ein <PreferenceScreen> Element sein, innerhalb dessen die Einstellungselemente eingefügt werden. Dazu müssen einfach die benötigten <Preference> Elemente dem <PreferenceScreen> als Kindelemente hinzugefügt werden.

Um die Übersichtlichkeit zu steigern, können die Einstellungselemente beliebigen Einstellungskategorien zugewiesen werden. Im oberen Quellcode sind die beiden <Preference> Elemente, <CheckBoxPreference> und <SwitchPreferenceCompat>, bspw. einer Einstellungskategorie zugeordnet worden. Dazu mussten sie nur innerhalb eines <PreferenceCategory> Elements definiert werden.

Die beiden <Preference> Elemente wurden mit den folgenden vier Attributen versehen:

• android:key – Mit diesem Attribut wird der entsprechenden Einstellung ein einzigartiger Schlüssel (unique key) zugewiesen. Dieser Schlüssel wird vom Android System verwendet, um den Wert der Einstellung in die SharedPreferences zu speichern. Nur durch Angabe eines Schlüssels kann der vom Benutzer eingestellten Wert persistent gespeichert werden.

• android:title – Mit diesem Attribut wird ein Titel für die entsprechende Einstellung vorgegeben. Der gewählte Titel sollte möglichst selbsterklärend und für den Benutzer leicht zu verstehen sein.

• android:summary – Mit diesem Attribut wird eine kurze Zusammenfassung für die entsprechende Einstellung vorgegeben. Die Zusammenfassung kann zum einen über den aktuell eingestellten Wert informieren und zum anderen dem Benutzer etwas ausführlicher erklären, wozu die Einstellung genau verantwortlich ist.

• android:defaultValue – Jede Einstellung sollte über einen Standardwert verfügen, der vom Android System als Anfangswert in die SharedPreferences geschrieben wird. Dies ist der Wert den die entsprechende Einstellung erhält, wenn die App auf das Android Gerät installiert wird.

1.2 Umwandeln der Preference-Elemente in App-Einstellungen

Sind die gewünschten Preference-Elemente in einer XML-Ressourcen Datei definiert worden, können sie im zweiten Schritt zu App-Einstellungen umgewandelt werden. Diese Aufgabe wird von dem SettingsFragment übernommen, welches von der PreferenceFragmentCompat-Klasse abgeleitet ist und somit über zusätzliche Funktionen der Preference-API verfügt.

Das Umwandeln der Hierarchie von Preference-Elementen wird in der onCreatePreferences() Methode durchgeführt, die automatisch vom Android System während des Erzeugens des Fragments, innerhalb der onCreate() Methode, aufgerufen wird.

Mit folgendem Quellcode werden aus der erstellten XML-Ressource die App-Einstellungen erzeugt:

SettingsFragment.java

public class SettingsFragment extends PreferenceFragmentCompat implements
        Preference.OnPreferenceChangeListener {

    @Override
    public void onCreatePreferences(Bundle bundle, String s) {

        // Laden der Preference-Elemente aus einer XML-Datei
        addPreferencesFromResource(R.xml.preferences);
    }

    ...
}

In Zeile 8 wird mit Hilfe der addPreferencesFromResource() Methode die Hierarchie von Preference-Elementen in App-Einstellungen umgewandelt. Dazu muss der Methode nur die ID der im ersten Schritt erzeugten XML-Ressourcen Datei übergeben werden, in welcher die Preference-Elemente definiert sind.

Das SettingsFragment verwaltet die so erzeugten App-Einstellungen selbständig. Sobald der Nutzer eine Einstellung ändert, wird dies von dem Fragment erkannt und der neu eingestellte Wert in die SharedPreferences unter dem Einstellungsschlüssel (Preference-Key) persistent abgespeichert. Der Einstellungswert kann dann anschließend innerhalb der App mit Hilfe des entsprechenden Schlüssel wieder aus den SharedPreferences ausgelesen werden.

Für einige App-Einstellungen ist diese Art der Einstellungsverwaltung bereits völlig ausreichend. Möchte man dem Benutzer jedoch über die getätigte Auswahl gezielt Rückmeldung geben, ist noch ein dritter Schritt erforderlich, mit dem auf Einstellungsänderungen direkt reagiert werden kann.

1.3 Reagieren auf Einstellungsänderungen mit einem Listener

Zwar werden mit Hilfe der Preference-API die App-Einstellungen selbständig von dem SettingsFragment verwaltet, jedoch ohne den Benutzer darüber Rückmeldungen zu geben. Mit einem OnPreferenceChangeListener kann gezielt auf Einstellungsänderungen reagiert und der Benutzer direkt über seine getätigte Auswahl informiert werden.

Mit dem folgenden Quellcode wird das OnPreferenceChangeListener-Interface implementiert:

SettingsFragment.java

public class SettingsFragment extends PreferenceFragmentCompat implements
        Preference.OnPreferenceChangeListener {

    @Override
    public void onCreatePreferences(Bundle bundle, String s) {

        // Laden der Preference-Elemente aus einer XML-Datei
        addPreferencesFromResource(R.xml.preferences);

        // Mit einem Listener werden Einstellungsänderungen überwacht
        Preference preference = findPreference("key_switch_preference");
        preference.setOnPreferenceChangeListener(this);
    }

    @Override
    public boolean onPreferenceChange(Preference preference, Object newValue) {
        String preferenceKey = preference.getKey();
        boolean preferenceValue = (boolean) newValue;

        if (preferenceKey.equals("key_switch_preference")) {
            preference.setSummary("Der neue Wert ist: " + preferenceValue);
        }

        return true;
    }
}

Um das OnPreferenceChangeListener-Interface zu implementieren, muss dessen einzige Methode, die onPreferenceChange() Methode, ausprogrammiert werden. Sie wird vom Android System aufgerufen, sobald der Benutzer die Einstellung geändert hat. Und zwar unmittelbar bevor der neue Wert gespeichert wird.

Die Methode besitzt einen Rückgabewert vom Typ boolean, mit dem vorgegeben werden kann, ob der neue Einstellungswert auch übernommen und persistent gespeichert werden soll. Nur wenn true zurückgegeben wird, lässt das Fragment den neuen Wert in die SharedPreferences abspeichern.

Damit die onPreferenceChange() Methode auch aufgerufen wird, muss der OnPreferenceChangeListener mit Hilfe der setOnPreferenceChangeListener() Methode für die entsprechende Einstellung registriert werden. Da in unserem Fall die SettingsFragment-Klasse das Listener-Interface implementiert, muss der setOnPreferenceChangeListener() Methode eine Referenz auf die Fragment-Instanz übergeben werden.

Dies hat den großen Vorteil, dass von der Fragment-Instanz mehrere Einstellungen nach unseren Vorgaben überwacht werden können. Den Einstellungen muss als Listener-Objekt nur die Fragment-Instanz übergeben werden. Welche der überwachten Einstellungen gerade geändert wurde, kann man dann mit Hilfe des Einstellungsschlüssels, wie im oberen Quellcode gezeigt, überprüfen und für die Einstellung die passende Summary als Rückmeldung für den Benutzer ausgeben.

Mit den eben beschriebenen drei Arbeitsschritten werden aus Preference-Elementen, die in einer XML-Datei definiert wurden, die App-Einstellungen erzeugt und gezielt auf vorgenommene Änderungen überwacht. Die Werte der so erzeugten Einstellungen können anschließend App-weit aus dem SharedPreferences ausgelesen werden.

1.4 Auslesen der Einstellungswerte innerhalb der App

Die Einstellungswerte werden standardmäßig in den DefaultSharedPreferences der Android App abgespeichert. Auf die Werte kann so von überall innerhalb der Anwendung zugegriffen werden. Es wird nur die Instanz der DefaultSharedPreferences benötigt, auf die mit Hilfe der statischen Methode PreferenceManager.getDefaultSharedPreferences() zugegriffen werden kann.

Mit folgendem Quellcode wird auf den Wert einer Einstellung von einer anderen Activity aus zugegriffen:

MainActivity.java

// Mit this muss ein Context-Objekt übergeben werden, wie bspw. eine Activity-Instanz
SharedPreferences sharedPrefs = PreferenceManager.getDefaultSharedPreferences(this);
String preferenceKey = "key_switch_preference";
boolean preferenceValue = sharedPrefs.getBoolean(preferenceKey, false);

Zuerst wird die DefaultSharedPreferences-Instanz mit Hilfe der getDefaultSharedPreferences() Methode innerhalb der MainActivity-Klasse angefordert. Die SharedPreferences-Instanz enthält alle Schlüssel-Wert Paare (key-value pairs) der erzeugten App-Einstellungen.

Somit kann der Wert einer bestimmten App-Einstellung über den Einstellungsschlüssel ausgelesen werden. Dies geschieht mit Hilfe mehrerer getter-Methoden, die auf den Datentyp der jeweiligen Einstellung abgestimmt sind.

Im oberen Beispiel wird der Einstellungswert als boolean-Wert abgespeichert. Daher ist die getBoolean() Methode zu verwenden, der als Argumente der Einstellungsschlüssel und ein Standardwert übergeben werden müssen. Der Standardwert wird benötigt, falls der aktuelle Einstellungswert nicht ausgelesen werden kann. Als Rückgabewert erhält man den aktuellen Wert der zum Schlüssel passenden Einstellung oder eben den übergebenen Standardwert, falls ein Fehler eintrat.

2. Definieren einer SwitchPreference und Einbinden dieser in die App-Einstellungen

Wir haben im theoretischen Teil dieser Lektion erfahren, wie Preference-Elemente mit Hilfe der Preference-API in App-Einstellungen umgewandelt werden. Das erlangte Wissen möchten wir nun in die Praxis umsetzen und eine SwitchPreference als erste Einstellung für unserer Android App implementieren.

Um das SwitchPreference-Element als Einstellung in unsere App einzubinden, werden wir nun die folgenden drei Arbeitsschritte durchführen:

1. Bereitstellen weiterer String-Ressourcen – Um das Preference-Element zu definieren, werden einige String-Ressourcen benötigt, wie Titel, Schlüssel und Zusammenfassung der Einstellung. Die benötigten Bezeichnungen werden wir dazu in der strings.xml Ressourcen-Datei bereitstellen.

2. Definieren des SwitchPreference-Elements – Anschließend werden wir das SwitchPreference-Element in der preferences.xml Datei definieren. Da die Datei noch nicht existiert, werden wir sie vorher von Android Studio erstellen lassen.

3. Umwandeln des Preference-Elements in eine App-Einstellung – Das definierte Preference-Element lassen wir dann mit Hilfe der Preference-API in eine App-Einstellung umwandeln. Dies wird in der Klasse SettingsFragment erfolgen, welche die dafür benötigte Funktionalität von ihrer Super-Klasse, der PreferenceFragmentCompat-Klasse, erbt.

Beginnen wir nun mit dem ersten Arbeitsschritt.

2.1 Bereitstellen von String-Ressourcen für die App-Einstellungen

Wir definieren nun mehrere String-Ressourcen, die wir später für das Definieren des SwitchPreference-Element wiederverwenden werden. Dazu öffnen wir die strings.xml Ressourcen-Datei im Editor von Android Studio, indem wir doppelt auf ihren Dateinamen im Project Tool Window klicken. Die Datei befindet sich im res/values/ Ordner unseres Projekts.

Dem bereits vorhandenen Code der strings.xml Datei fügen wir die markierten Zeilen hinzu:

strings.xml

<resources>
    <string name="app_name">Zitate</string>

    <string name="welcome_message">Hello CodeYourApp World! als String-Ressource</string>
    <string name="text_button_activity_main">Hole Daten</string>

    <string name="sample_author">Johann Wolfgang v. Goethe</string>
    <string name="sample_quote">Das sicherste Mittel, ein freundschaftliches Verhältnis
        zu hegen und zu erhalten, finde ich darin, daß man sich wechselweise mitteile,
        was man tut. Denn die Menschen treffen viel mehr zusammen in dem, was sie tun,
        als in dem, was sie denken.</string>

    <string name="action_get_data">Hole Daten</string>
    <string name="action_settings">Einstellungen</string>
    <string name="action_lookup_author">Autor nachschlagen</string>
    <string name="action_share_quote">Zitat teilen</string>

    <string name="preference_category_title">Datenabfrage</string>
    <string name="preference_xmlmode_title">XML-Daten verwenden</string>
    <string name="preference_xmlmode_key">key_xml_mode</string>
    <string name="preference_xmlmode_summary_on">Es werden XML-Daten vom Webserver angefordert.</string>
    <string name="preference_xmlmode_summary_off">Der XML-Datenmodus ist deaktiviert.</string>

    <string name="preference_quotecount_title">Anzahl angeforderte Zitate</string>
    <string name="preference_quotecount_key">key_quote_count</string>
    <string name="preference_quotecount_summary">Zitate werden pro Anfrage vom Webserver angefordert.</string>
    <string name="preference_quotecount_dialog_unit">Zitate</string>
    <string name="preference_quotecount_dialog_positive_button_text">OK</string>
    <string name="preference_quotecount_dialog_negative_button_text">Abbrechen</string>
    <string name="preference_quotecount_dialog_title">Wie viele Zitate sollen angefordert werden?</string>

</resources>

Insgesamt haben wir in der strings.xml Datei mit den Zeilen 18 bis 30 zwölf neue String-Ressourcen definiert. Die Ressourcen werden wir in dieser und der nächsten Lektion für das Definieren der Preference-Elemente verwenden.

Auf die String-Ressourcen können wir bspw. mit R.string.preference_xmlmode_key vom Quellcode aus oder mit @string/preference_xmlmode_key von einer anderen XML-Datei aus zugreifen.

In Android Studio sollte die strings.xml Datei nun wie folgt aussehen:

• strings.xml
• Projektstruktur

In der oberen Abbildung sind die neu eingefügten Zeilen mit einem Rahmen umschlossen (Markierung A). Die oberen fünf String-Ressourcen werden wir als Nächstes für das Definieren des Preference-Elements wiederverwenden. Die übrigen sieben werden wir erst in der nächsten Lektion benötigen.

2.2 Definieren des SwitchPreference-Elements in der preferences.xml Datei

Wir werden nun die preferences.xml Ressourcen-Datei erstellen und in ihr das SwitchPreference-Element definieren. Die zu erstellende XML-Datei muss in dem res/xml/ Ressourcen-Ordner abgelegt werden. Dieses Verzeichnis existiert momentan noch nicht in unserem Android Projekt und muss daher von uns erstellt werden.

Somit besteht das Definieren des SwitchPreference-Elements aus den folgenden beiden Schritten:

1. Anlegen des xml-Ordners – Wir legen in dem Ressourcen-Ordner unseres Android Studio Projekts den xml-Ordner an, in welchem die preferences.xml Datei abgelegt werden muss.

2. Erstellen der preferences.xml Datei – In dem erstellten xml-Ordner lassen wir von Android Studio eine neue XML-Ressourcen Datei mit dem Dateinamen preferences.xml erstellen. Anschließend definieren wir in der erstellten XML-Datei das SwitchPreference-Element per Android XML-Vokabular.

2.2.1 Anlegen des xml-Ordners in Android Studio

Alle XML-Dateien, in welchen Preference-Elemente definiert werden, müssen in dem xml-Ordner des Android Projekts abgelegt werden. Nur Dateien die sich im res/xml/ Ordner befinden, können für das Erzeugen von App-Einstellungen verwendet werden.

Wir werden nun den xml-Ordner anlegen. Dazu gehen wir folgendermaßen vor:

1. Mit der rechten Maustaste auf den Ordner res/ in dem Project Tool Window klicken.
2. Anschließend den Eintrag New des Kontext-Menüs anklicken.
3. Danach auf Directory klicken.

Anschließend öffnet sich der New Directory-Dialog, in welchem wir den Namen des zu erstellenden Ordner vorgeben müssen:

Wir tragen in das Feld Enter new directory name den Wert xml ein und bestätigen anschließend den Dialog mit einem Klick auf den OK Button.

Nun legt Android Studio den Ressourcen-Ordner res/xml/ für unsere Preferences-Dateien automatisch an.

2.2.2 Erstellen der preferences.xml Datei

Als nächsten Schritt erstellen wir die XML-Datei preferences.xml, in welcher wir die Preference-Elemente für unsere App-Einstellungen definieren. Dazu führen wir die folgenden Schritte aus:

1. Mit der rechten Maustaste auf den eben erstellten Ordner xml/ in dem Project Tool Window klicken.
2. Anschließend den Eintrag New des Kontext-Menüs anklicken.
3. Danach auf XML resource file klicken.

Anschließend öffnet sich der New XML Resource File-Dialog, der uns bei der Erstellung der XML-Ressourcen Datei unterstützt. Wir müssen nur die beiden Felder des Dialogs ausfüllen.

In dem New XML Resource File-Dialog nehmen wir nun die folgenden Einstellungen vor:

1. Als Dateinamen tragen wir preferences.xml in das Feld File name ein.
2. Den Wert für das Root element lassen wir auf PreferenceScreen stehen.

Anschließend bestätigen wir den New XML Resource File-Dialog mit einem Klick auf den OK Button, woraufhin die neue XML-Ressourcen Datei automatisch von Android Studio erstellt und im Editorfenster der IDE geöffnet wird.

Falls die Datei nicht automatisch geöffnet wurde, führen wir das Öffnen manuell durch. Dazu klicken wir doppelt auf ihren Dateinamen preferences.xml im Project Tool Window von Android Studio. Die Datei befindet sich im res/xml/ Ordner unseres Projekts.

Standardmäßig öffnet sich das Editorfenster in der Design-Ansicht. Damit der XML-Code der Datei angezeigt wird, müssen wir unten im Editorfenster den Tab Text anklicken.

Den generierten XML-Code löschen wir vollständig und fügen an dessen Stelle den folgenden XML-Code ein:

preferences.xml

<?xml version="1.0" encoding="utf-8"?>
<androidx.preference.PreferenceScreen
    xmlns:android="http://schemas.android.com/apk/res/android">

    <PreferenceCategory android:title="@string/preference_category_title">

        <SwitchPreferenceCompat
            android:key="@string/preference_xmlmode_key"
            android:title="@string/preference_xmlmode_title"
            android:summary="@string/preference_xmlmode_summary_off"
            android:defaultValue="false" />

    </PreferenceCategory>
</androidx.preference.PreferenceScreen>

Mit dem oberen XML-Code haben wir den Einstellungsbildschirm (Preference Screen) unserer Android App per XML definiert. Das Wurzelelement der XML-Datei muss dabei immer ein <PreferenceScreen> Element sein, innerhalb dessen die Einstellungselemente eingefügt werden. Als PreferenceScreen verwenden wir die Implementierung der AndroidX Preference-Bibliothek (androidx.preference.PreferenceScreen).

Mit dem <PreferenceCategory> Element legen wir eine Einstellungskategorie fest, in welche wir unsere Preference-Elemente einfügen werden. Sie trägt den Titel „Datenabfrage“, den wir mit Hilfe der String-Ressource @string/preference_category_title vorgeben.

Innerhalb des <PreferenceCategory> Elements haben wir das SwitchPreference-Element definiert. Um genau zu sein, handelt es sich um ein SwitchPreferenceCompat-Element aus der AndroidX Preference Library, welches wir aus Kompatibilitätsgründen verwenden müssen.

Für das <SwitchPreferenceCompat> Element haben wir die folgenden vier Attribute definiert:

• android:key – Mit diesem Attribut wird der Einstellungsschlüssel zugewiesen. Dieser Schlüssel wird vom Android System verwendet, um den Wert der Einstellung in die SharedPreferences zu speichern. Nur durch Angabe eines Schlüssels kann der vom Benutzer eingestellten Wert persistent gespeichert werden.

• android:title – Mit diesem Attribut wird der Titel vorgegeben. Der Titel der SwitchPreference lautet „XML-Daten verwenden“ und wird mit Hilfe der vorher angelegten String-Ressource vorgegeben.

• android:summary – Mit diesem Attribut wird eine kurze Zusammenfassung vorgegeben. Die Zusammenfassung informiert den Benutzer über den aktuell eingestellten Wert. Für jeden der beiden Zuständen (An/Aus) wird ein eigener Text mit Hilfe der angelegten String-Ressourcen ausgegeben.

• android:defaultValue – Jede Einstellung sollte über einen Standardwert verfügen, der vom Android System als Anfangswert in die SharedPreferences geschrieben wird. Wir haben den Standardwert des SwitchPreference-Elements auf false gesetzt.

In Android Studio sollte die preferences.xml Datei nun wie folgt aussehen:

• preferences.xml
• Projektstruktur

Wir haben nun die XML-Datei preferences.xml erstellt und in ihr unser erstes Preference-Element definiert. Als Nächstes muss das Preference-Element vom SettingsFragment in eine App-Einstellung umgewandelt werden.

2.3 Umwandeln des Preference-Elements in eine App-Einstellung

Das definierte Preference-Element lassen wir jetzt mit Hilfe der Preference-API in eine App-Einstellung umwandeln. Dies wird in der Klasse SettingsFragment erfolgen, welche die dafür benötigte Funktionalität von ihrer Super-Klasse, der PreferenceFragmentCompat-Klasse, erbt.

Hinweis: Unsere Klasse SettingsFragment ist von der Klasse PreferenceFragmentCompat abgeleitet. Aus diesem Grund können wir nicht das SwitchPreference-Element des Android Frameworks verwenden, sondern müssen auf das SwitchPreferenceCompat-Element der AndroidX Preference Library zurückgreifen.

Wir öffnen nun die Klassendatei SettingsFragment.java im Editor von Android Studio mit einem Doppelklick auf ihren Dateinamen im Project Tool Window. Die Klassendatei befindet sich im Package-Ordner de.codeyourapp.zitate unseres Projekts.

In der SettingsFragment.java nehmen wir folgende Änderung an der onCreatePreferences() Methode vor:

Hinweis: Der untere Quellcode ist Teil des geschützten Bereichs von ProgrammierenLernen^HQ. Durch Freischalten unserer Android Online-Kurse erhältst du Zugriff auf alle geschützten Inhalte.
Erfahre mehr über unsere Android Online-Kurse.

Im oberen Quellcode der SettingsFragment-Klasse wurde nur die Methode onCreatePreferences() überarbeitet. Es wurde die nicht mehr benötigte Toast-Anweisung auskommentiert und in Zeile 17 die addPreferencesFromResource() Methode aufgerufen.

Die Methode addPreferencesFromResource() ist für das Umwandeln der Preference-Elemente in App-Einstellungen verantwortlich. Dazu muss ihr die Ressourcen-ID der preferences.xml Datei übergeben werden. Sie wandelt dann die darin definierten Preference-Elemente in App-Einstellungen mit eigener Benutzeroberfläche um.

Weitere Änderungen müssen an der SettingsFragment-Klasse nicht vorgenommen werden. Um Tippfehler zu vermeiden, empfiehlt es sich die gesamte onCreatePreferences() Methode durch den oben markierten Quellcode zu ersetzen.

In Android Studio sollte die SettingsFragment.java Klassendatei nun wie folgt aussehen:

• SettingsFragment.java
• Projektstruktur

In der oberen Abbildung ist die überarbeitete SettingsFragment.java Klassendatei dargestellt. Es wurde nur der Quellcode der onCreatePreferences() Methode verändert (Markierung B). Das SwitchPreference-Element wird nun von der SettingsFragment-Klasse in eine App-Einstellung umgewandelt.

Die so erzeugten App-Einstellung ist bereits jetzt voll funktionsfähig. Ändert der Benutzer die SwitchPreference-Einstellung, wird der neue Wert automatisch vom Android System in die SharedPreferences gespeichert.

Dies hat jedoch noch keine Auswirkung auf das Verhalten unserer Anwendung, da der eingestellte Wert bisher nicht von uns ausgelesen wird. Um unsere App auf den eingestellten Wert reagieren zu lassen, ist eine Änderung an der MainActivity-Klasse erforderlich, die wir im nächsten Abschnitt vornehmen werden.

3. Auslesen der gewählten Einstellung in der MainActivity

Mit der SwitchPreference soll vorgegeben werden, in welchem Format der Webserver die Zitatdaten an unsere App übertragen soll. Ob die Zitatdaten im XML- oder JSON-Format geliefert werden, wird durch den Anfrage-String des HTTP-Requests festgelegt.

Dieser Anfrage-String muss also in Abhängigkeit vom aktuellen Einstellungswert der SwitchPreference gebildet werden. Der Zusammenbau dieses Strings wird von der refreshListView() Methode der MainActivity-Klasse aus gesteuert. Daher müssen wir an genau dieser Stelle den aktuellen Wert der SwitchPreference-Einstellung auslesen und ihn für den Bau des Anfrage-Strings nutzen.

3.1 Überarbeiten der refreshListView() Methode der MainActivity-Klasse

Wir werden nun die notwendige Änderung vornehmen und die refreshListView() Methode der MainActivity-Klasse überarbeiten. Dazu öffnen wir die Klassendatei MainActivity.java im Editor von Android Studio mit einem Doppelklick auf ihren Dateinamen im Project Tool Window. Die Klassendatei befindet sich im Package-Ordner de.codeyourapp.zitate unseres Projekts.

In der MainActivity.java nehmen wir folgende Änderungen an der refreshListView() Methode vor:

MainActivity.java

private void refreshListView() {
    int quoteCount = 8;
    int parsingMethod = Utility.JSON_PARSING_METHOD;

    // Auslesen der ausgewählten Einstellung aus den SharedPreferences
    SharedPreferences sharedPrefs = PreferenceManager.getDefaultSharedPreferences(this);
    String prefXmlModeKey = getString(R.string.preference_xmlmode_key);
    boolean isXmlModeOn = sharedPrefs.getBoolean(prefXmlModeKey, false);
    if (isXmlModeOn) parsingMethod = Utility.XML_PARSING_METHOD;

    // Instanziieren des AsyncTask-Objekts und Starten des asynchronen Tasks
    RequestQuotesTask requestQuotesTask = new RequestQuotesTask();
    requestQuotesTask.execute(quoteCount, parsingMethod);
}

In der refreshListView() Methode werden nun zuerst zwei Variablen definiert, über welche die Zusammensetzung des Anfrage-Strings gesteuert wird. Die Variable quoteCount gibt vor wie viele Zitate angefragt werde sollen. Mit der Variable parsingMethod wird vorgegeben, auf welche Art die Zitatdaten interpretiert und somit auch in welchem Format sie bei dem Webserver angefordert werden sollen.

In den Zeilen 6 bis 9 wird der aktuelle Wert der SwitchPreference aus den SharedPreferences ausgelesen. Falls der Wert true ist, wird die Variable parsingMethod auf die Konstante XML_PARSING_METHOD gesetzt.

In Zeile 13 wird der asynchrone Task, mit dessen Hilfe die Zitatdaten beim Webserver angefordert werden, gestartet. Dies erfolgt durch Aufruf der execute() Methode, der die beiden Variablen quoteCount und parsingMethod als Argumente übergeben werden.

Zur besseren Kontrolle ist der gesamte Quellcode der MainActivity.java Datei hier noch einmal aufgeführt worden. Es wurden zwei Import-Anweisungen mit den Zeilen 3 und 4 eingefügt und die refreshListView() Methode mit den Zeilen 265 bis 278 überarbeitetet.

Zum Betrachten des gesamten Quellcodes muss der untere Block aufgeklappt werden:

Durch das Überarbeiten der refreshListView() Methode wird ab jetzt der aktuelle Wert der SwitchPreference-Einstellung für den Zusammenbau des Anfrage-Strings genutzt. Von unserer Android App wird somit auf die vom Benutzer getätigte Einstellung reagiert und in Abhängigkeit davon das XML- oder JSON-Format verwendet.

In Android Studio sollte der Inhalt der MainActivity.java Klassendatei nun wie folgt aussehen:

• MainActivity.java
• Projektstruktur

In der oberen Abbildung ist die MainActivity.java Klassendatei dargestellt. Es wurden zwei Import-Anweisungen eingefügt und die refreshListView() Methode überarbeitet . Sie ist daher als einzige Methode aufgeklappt. Die eingefügten bzw. überarbeiteten Codezeilen sind jeweils von einem blauen Rahmen umschlossen (Markierungen C und D).

Wir haben nun die MainActivity so überarbeitet, dass unsere App auf den aktuellen Wert der SwitchPreference-Einstellung reagiert. Wir können somit unsere App-Einstellung das erste Mal testen.

3.2 Testen der SwitchPreference-Einstellung auf einem AVD im Emulator

Wir werden nun unserer Android App auf einem Android Virtual Device im Emulator ausführen lassen. Auf diese Weise können wir direkt überprüfen, wie unsere App reagiert, wenn die SwitchPreference-Einstellungen benutzt wird.

Unsere App starten wir dazu wie gewohnt über den Run > Run 'app' Menüeintrag, den wir über die obere Menüleiste erreichen.

In den unteren Abbildungen ist unsere Android App auf dem virtuellen Gerät zu sehen. Die beiden Activities, MainActivity und DetailActivity, besitzen in dem Overflow Menu ihrer App Bar einen Einstellungen-Eintrag. Auf diesen Eintrag klicken wir nun jeweils einmal:

---

In der großen Abbildung ist die SettingsActivity dargestellt. Von ihr wird nun unsere erste App-Einstellung, eine SwitchPreference, ausgegeben, welche von dem SettingsFragment verwaltet wird.

Der Wert der SwitchPreference-Einstellung wird zwar schon persistent gespeichert, jedoch wird die Zusammenfassung der Einstellung noch statisch ausgegeben und nicht an den aktuellen Einstellungswert angepasst. Im nächsten Abschnitt werden wir dieses Verhalten korrigieren und auf Einstellungsänderungen mit dem SettingsFragment reagieren.

Bis auf den statischen summary-Text ist die SwitchPreference-Einstellung bereits jetzt voll funktionsfähig, so dass wir über sie das Datenformat vorgeben können. Steht der Schalter auf AN, werden XML-Daten vom Webserver angefordert. Wird der Schalter auf AUS gestellt, werden die Daten im JSON-Format angefordert.

Dies kann leicht im Logcat Tool Window von Android Studio mit folgenden Schritten überprüft werden:

1. Wir öffnen das Logcat Tool Window mit einem Klick auf den Logcat-Tab am unteren Bildschirmrand.
2. In der Drop-Down Liste stellen wir die Prioritätsstufe auf Verbose ein.
3. In das Suchfeld geben wir Utility|RequestQuotesTask (ohne Leerzeichen) als Suchbegriff ein.
4. Für die hintere Drop-Down Liste wählen wir den Eintrag Show only selected application aus.
5. In unserer Android App führen wir die Swipe-Refresh Geste durch und fordern damit neue Zitate vom Webserver an.

In der oberen Abbildung ist die Logcat-Ausgabe unserer Android App zu sehen. In der Anwendung wurde der Schalter der SwitchPreference-Einstellung auf AUS gestellt und anschließend neue Zitatdaten vom Webserver per Swipe-Refresh angefordert.

Wie zu erkennen ist, werden die Zitatdaten im JSON-Format angefordert. Dies erkennt man nicht nur an den Daten selbst, sondern auch am Anfrage-String, bei dem der mode-Parameter den Wert 0 erhalten hat.

Stellen wir nun den Schalter der SwitchPreference-Einstellung auf AN, werden die Zitatdaten im XML-Format angefordert.

Der Schalter der SwitchPreference-Einstellung steht nun auf AN und neue Zitatdaten wurden bereits vom Webserver angefordert. Wie zu erkennen ist, besitzen die Daten diesmal das XML-Format und der mode-Parameter des Anfrage-Strings hat den Wert 1 erhalten.

Durch diesen kurzen Test haben wir nun sichergestellt, dass unsere SwitchPreference-Einstellung wie erwartet funktioniert und unsere Android App die Zitatdaten nach Vorgaben der Einstellung anfordert.

Jedoch wird der Benutzer momentan noch nicht richtig über die ausgewählte Einstellung informiert. Der Zusammenfassungstext (summary text) der Einstellung wird noch statisch ausgegeben und nicht an den aktuellen Einstellungswert angepasst. Dies werden wir im nächsten Abschnitt korrigieren und auf Einstellungsänderungen mit dem SettingsFragment reagieren.

4. Auf Einstellungsänderungen mit dem SettingsFragment reagieren

Damit unsere App auf Einstellungsänderungen reagieren kann, müssen wir das OnPreferenceChangeListener-Interface ihrer SettingsFragment-Klasse implementieren. Mit Hilfe des OnPreferenceChangeListener können wir direkt auf Einstellungsänderungen reagieren und den Benutzer über den eingestellten Wert ausführlich informieren.

Wir öffnen nun die Klassendatei SettingsFragment.java im Editor von Android Studio mit einem Doppelklick auf ihren Dateinamen im Project Tool Window. Die Klassendatei befindet sich im Package-Ordner de.codeyourapp.zitate unseres Projekts.

In der SettingsFragment.java nehmen wir folgende Änderungen vor:

Im oberen Quellcode der SettingsFragment-Klasse wurden in den Zeilen 3 und 4 die Klasse PreferenceManager und das Interface SharedPreferences per Import-Anweisung innerhalb der Klasse sichtbar gemacht. Sie werden benötigt, um den aktuellen Einstellungswert aus den SharedPreferences auszulesen.

Anschließend wurde in den Zeilen 23 und 24 das SwitchPreference-Objekt mit Hilfe der findPreference() Methode angefordert und für dieses der OnPreferenceChangeListener registriert. Dadurch wird vom Android System automatisch die onPreferenceChange() Methode aufgerufen, sobald die SwitchPreference-Einstellung vom Benutzer geändert wird.

Mit den Zeilen 27 bis 29 wird der aktuelle Einstellungswert ausgelesen und die onPreferenceChange() Methode erstmalig aufgerufen. Dies ist erforderlich, um den Zusammenfassungstext der SwitchPreference-Einstellung initial vorzugeben.

Schließlich wird in den Zeilen 35 bis 43 das OnPreferenceChangeListener-Interface ausprogrammiert. Dazu wird in der onPreferenceChange() Methode überprüft, ob es sich bei der gerade geänderten Einstellung um die SwitchPreference-Einstellung handelt und falls dem so ist, wird in Abhängigkeit vom eingestellten Wert ihr Zusammenfassungstext vorgegeben.

In Android Studio sollte die SettingsFragment.java Klassendatei nun wie folgt aussehen:

• SettingsFragment.java
• Projektstruktur

In der oberen Abbildung ist die überarbeitete SettingsFragment.java Klassendatei dargestellt. Die hinzugefügten Codezeilen sind mit Markierungen versehen worden. Welche Bedeutung die jeweilige Zeile bzw. der jeweilige Code-Block besitzt, ist in der unteren Liste angegeben:

1. E – Die benötigten Import-Anweisungen zum Sichtbarmachen der PreferenceManager-Klasse und des SharedPreferences-Interfaces.
2. F – In der onCreatePreferences() Methode wird der OnPreferenceChangeListener für die SwitchPreference-Einstellung registriert.
3. G – Die onPreferenceChange() Methode des OnPreferenceChangeListener wurde ausprogrammiert, so dass unsere Android App nun selbständig auf Einstellungsänderungen reagiert.

Wir haben nun alle erforderlichen Änderungen an der SettingsFragment-Klasse durchgeführt. Mit Hilfe der eingebundenen SwitchPreference-Einstellung kann das Format der angeforderten Serverdaten vom Benutzer vorgegeben werden. Durch Implementieren des OnPreferenceChangeListener wird der Benutzer nun auch über den eingestellten Wert ausführlich informiert.

5. Ausführen und Testen unserer Android App

Wir werden nun unserer Android App auf einem Android Virtual Device im Emulator ausführen lassen und überprüfen, ob unsere Anwendung den Benutzer über eine erfolgte Einstellungsänderung Rückmeldung gibt.

Unsere App starten wir dazu wie gewohnt über den Run > Run 'app' Menüeintrag, den wir über die obere Menüleiste erreichen.

In den unteren Abbildungen ist unsere Android App auf dem virtuellen Gerät zu sehen. Die beiden Activities, MainActivity und DetailActivity, besitzen in dem Overflow Menu ihrer App Bar einen Einstellungen-Eintrag. Auf diesen Eintrag klicken wir nun jeweils einmal:

---

In der großen Abbildung ist die SettingsActivity dargestellt. In ihrem Inneren enthält sie das SettingsFragment, welches unsere App-Einstellungen verwaltet. Mit Hilfe des OnPreferenceChangeListener ist das Fragment nun in der Lage auf Änderungen der SwitchPreference-Einstellung selbständig zu reagieren.

Der Zusammenfassungstext der Einstellung wird nun dynamisch ausgegeben. Je nach Position des Schalters erscheint ein anderer Text. Wie in der oberen Abbildung zu erkennen ist, steht der Schalter auf AN. Dem Benutzer wird dies nun auch in dem Zusammenfassungstext der Einstellung ausführlich mitgeteilt. Wird der Schalter auf AUS gestellt, ändert sich der Text entsprechend.

Zusammenfassung

In dieser Lektion haben wir unserer Android App eine eigene Einstellung hinzugefügt, mit deren Hilfe der Benutzer das Format der Serverdaten vorgegeben kann. Als Einstellungselement haben wir dafür ein SwitchPreference-Element verwendet, einen einfachen Schalter mit den beiden Zuständen AN und AUS.

Wie ein solches Preference-Element in Android definiert und auf welche Weise es in unsere App-Einstellungen eingefügt wird, haben wir im theoretischen Teil dieser Lektion behandelt und dabei erfahren, welche Standard-Einstellungen in Android bereits durch Preference-Elemente implementiert sind.

Anschließend haben wir im praktischen Teil dieser Lektion eine XML-Ressourcen Datei erstellt und in ihr ein SwitchPreference-Element definiert, über das das zu verwendenden Datenformat vorgegeben werden kann. Dieses Preference-Element haben wir danach von der SettingsFragment-Klasse zu einer App-Einstellung umwandeln lassen.

Den aktuellen Wert der SwitchPreference-Einstellung haben wir dann in der MainActivity-Klasse aus den SharedPreferences ausgelesen und anhand des Wertes den Anfrage-String des HTTP-Requests gebildet, so dass entweder XML- oder JSON-Daten vom Webserver angefordert werden.

Um den Benutzer besser über die von ihm getätigte Einstellung zu informieren, haben wir danach das OnPreferenceChangeListener-Interface der SettingsActivity-Klasse implementiert, welches auf Einstellungsänderungen reagiert und den Zusammenfassungstext der SwitchPreference-Einstellung entsprechend anpasst.

Abschließend haben wir unsere Android App im Emulator auf einem Android Virtual Device ausgeführt und überprüft, ob die SettingsActivity die App-Einstellung korrekt erzeugt und unsere Anwendung den vom Benutzer eingestellten Wert für die Datenabfrage verwendet.

In der nächsten Lektion werden wir eine Custom Preference für unsere Android App bereitstellen. Dazu werden wir ein eigenes Preference-Element, mit dessen Hilfe die Zitatanzahl vorgegeben werden kann, definieren und von dem SettingsFragment daraus eine App-Einstellungen erstellen lassen.

Weiterführende Literatur

• Developer.android.com: Settings Guide
• Developer.android.com: Fragments Guide
• Developer.android.com: PreferenceFragmentCompat Reference
• Developer.android.com: Preference.OnPreferenceChangeListener Reference
• Developer.android.com: SwitchPreferenceCompat Reference

---

---

---