Programmier Tutorial: – Teil 11: Settings und Preferences in Android

---

Über ein Settings-Menü (Einstellungsmenü) werden die Benutzereinstellungen verwaltet. Die vorgenommenen Einstellungen werden als Preferences (getätigte Auswahl) gespeichert.

In unserer App sollen zwei Einstellungen von den Benutzern vorgenommen werden können:

• Auswahl der Finanzinstrumente – Eingabe der Symbole (Aktien-Kennungen) für die Finanzdaten angezeigt werden sollen.
• Wechseln auf Indize-Liste – Umschalten von der individuellen Aktienliste zu einer Liste von wichtigen Indizes.

Später können der Android Anwendung noch weitere Einstellungsoptionen hinzugefügt werden. Es sollte dabei aber unbedingt darauf geachtet werden, dass nicht alles zu einer Einstellung wird, da dies schnell den Benutzer überfordert.

Daher muss der Softwareentwickler vorher genau überlegen und abwägen welche Einstellung es in die App schafft. Hier ist weniger oft mehr.

Nun wünschen wir euch viel Spaß bei dem elften Teil unseres großen Android Tutorials. Los geht’s!

1. Settings und Preferences in Android

Über Settings können in Android Anwendungen die Benutzereinstellungen vorgenommen werden und damit das Verhalten der Android App vom Benutzer nach seinen Vorlieben (Preferences) angepasst werden.

Einige Apps erlauben es dem Anwender bspw. zu entscheiden, ob Benachrichtigungen angezeigt werden oder wie oft Daten mit der Cloud synchronisiert werden sollen. Solche Einstellungen werden meist in einem Settings-Bildschirm (Activity) vorgenommen und anschließend als User-Preference abgespeichert.

Settings verbessern die Benutzererfahrung auf zwei Arten:

1. Benutzer müssen nicht wiederholt mit den gleichen Fragen beim Nutzen der Anwendung unterbrochen werden. Über Settings wird vorbestimmt, was in gewissen Situationen passieren soll. Diese Vorgaben müssen nur einmal getätigt werden bzw. in vielen Fällen als Standardvorgabe bereits vorweggenommen werden. Siehe: Decide for me but let me have the final say

2. Benutzer fühlen sich in der Android App zu Hause und besitzen die Kontrolle über das Verhalten der App. Siehe: Let me make it mine

---

Möchte man seinen Anwendern einen Settings-Bildschirm zur Verfügung stellen, in welchem sie wichtige Einstellungen für die Android Anwendung vornehmen können, sollte man sich unbedingt an die Empfehlungen des Android Settings Guide halten.

Darin wird sehr ausführlich beschrieben, wie die Android Preference APIs benutzt werden und eine einheitliche Benutzererfahrung erreicht wird, die konsistent mit anderen Android Apps ist.

2. Erstellen einer Settings-Activity

Nun möchten wir unsere Android App um eine weitere Activity, eine Settings-Activity, erweitern. Dafür sind mehrere Arbeitsschritte notwendig und es müssen verschiedene Projektdateien verändert werden.

Außerdem werden wir dafür nicht wie bisher den Android Studio Wizzard nutzen, sondern alle Änderungen selbst per Hand vornehmen bzw. ausführen.

Folgende Schritte werden benötigt, um die Settings-Activity zu erstellen:

1. Anlegen der neuen Java-Klasse EinstellungenActivity.java
2. Einfügen des Quellcodes (minimales Grundgerüst, wird später erweitert)
3. Deklarieren der neuen Activity EinstellungenActivity in der AndroidManifest.xml Datei
4. Anlegen des Titel-Strings in der strings.xml Ressourcen-Datei

Beginnen wir nun mit dem ersten Schritt.

2.1 Anlegen der neuen Java-Klasse „EinstellungenActivity.java“

Dazu gehen wir wie folgt vor:

1. Mit der rechten Maustaste in der Projekt-Ansicht von Android Studio auf den Paketnamen unseres Android Projekts klicken.
2. Anschließend klicken wir im Kontext-Menü auf den Eintrag New.
3. Dann auf den Java Class-Eintrag klicken.

Die untere Abbildung verdeutlicht das eben beschriebene Vorgehen:

Danach öffnet sich der Create New Class-Dialog, in welchem wir den Namen unserer neuen Settings-Activity angeben.

Wir nehmen in dem Dialog folgende Einstellungen vor:

• Als Name geben wir „EinstellungenActivity“ ein.
• Als Kind wählen wir Class aus und klicken den OK-Button.

Siehe folgende Abbildung:

Jetzt erstellt Android Studio automatisch die neue Java-Klasse nach unseren Vorgaben und legt diese in dem Projektordner ab. Die neue Klasse ist noch leer, daher werden wir als Nächsten den minimal benötigten Quellcode einfügen.

2.2 Einfügen des Quellcodes (minimales Grundgerüst)

Die eben erstellte Klasse EinstellungenActivity soll eine Tochterklasse der PreferenceActivity-Klasse werden und das Interface Preference.OnPreferenceChangeListener implementieren.

Die Klasse PreferenceActivity ist die Basisklasse für alle Activities, die Einstellungsmöglichkeiten den User anzeigen bzw. bieten. Vor Android 3.0 (HONEYCOMB) erlaubte nur diese Klasse das Anzeigen einer Liste von Preferences. Diese Funktionalität ist mittlerweile in der neuen Klasse PreferenceFragment zu finden. Daher sollte die neue Klasse vorwiegend genutzt werden.

Wir verwenden für unsere App jedoch die PreferenceActivity-Klasse, da wir Android API Level 10 als minSdkVersion anstreben.

Die PreferenceActivity-Klasse befindet sich, wie auf das Interface Preference.OnPreferenceChangeListener, in dem Package android.preference. Das Package stellt sicher, dass alle Einstellungen auf die gleiche Art und Weise verwaltet werden. Mehr Infos könnt ihr unter folgenden Verlinkungen finden:

• Package android.preference
• Klasse PreferenceActivity
• Interface Preference.OnPreferenceChangeListener

Soviel zur Theorie, jetzt kommen wir zur Praxis.

Den folgenden Quellcode fügen wir in die neu erstellte Klasse EinstellungenActivity ein:

EinstellungenActivity.java

package de.programmierenlernenhq.aktiehq.app;

import android.os.Bundle;
import android.preference.Preference;
import android.preference.PreferenceActivity;
import android.widget.Toast;

public class EinstellungenActivity extends PreferenceActivity
        implements Preference.OnPreferenceChangeListener {

    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);

        Toast.makeText(this, "Einstellungen-Activity gestartet.", Toast.LENGTH_SHORT).show();
        Toast.makeText(this, "Zurück mit Back-Button.", Toast.LENGTH_SHORT).show();
    }

    @Override
    public boolean onPreferenceChange(Preference preference, Object value) {
        return false;
    }
}

Die neue EinstellungenActivity macht zu Beginn noch nicht sehr viel. Beim Erzeugen der Activity geben wir zwei Mitteilungen (Toasts) aus, die eingeblendet werden und nach kurzer Zeit wieder verschwinden.

Weiterhin überschreiben wir in den Zeilen 20 bis 22 die abstrakte Methode onPreferenceChange des Interfaces Preference.OnPreferenceChangeListener. In der Methode führen wir momentan noch nichts aus. Später werden wir an dieser Stelle auf durchgeführte Einstellungsänderungen der Benutzer reagieren.

Als nächsten Schritt müssen wir die neue Activity in dem AndroidManifest bekannt machen.

2.3 Deklarieren der neuen Activity EinstellungenActivity in der AndroidManifest.xml Datei

Der nächste Arbeitsschritt besteht darin, das Android System über die neu erstellte Activity EinstellungenActivity zu informieren, indem wir die Activity in der AndroidManifest.xml deklarieren.

Die AndroidManifest-Datei enthält die essentiellen Informationen über unsere Anwendung, die das Android System benötigt, bevor unser Code ausgeführt werden kann. Weitere Infos über das AndroidManifest findet ihr hier: App Manifest.

Als Erstes öffnen wir die AndroidManifest.xml-Datei in Android Studio. Dazu klicken wir doppelt auf den Eintrag AndroidManifest.xml in der Projekt-Ansicht. Anschließend wird das AndroidManifest im Editorfenster geöffnet, siehe folgende Abbildung.

Nun fügen wir den folgenden Codeblock in die Activity-Hierarchie ein. In der oberen Abbildung ist der Codeblock bereits eingefügt worden und mit einem blauen Rahmen markiert.

AndroidManifest.xml

<activity
    android:name=".EinstellungenActivity"
    android:label="@string/title_activity_einstellungen"
    android:parentActivityName=".MainActivity">
    <meta-data
        android:name="android.support.PARENT_ACTIVITY"
        android:value="de.programmierenlernenhq.aktiehq.app.MainActivity" />
</activity>

Wir geben dem Android System den Klassennamen unserer EinstellungenActivity bekannt und legen ihre Parent-Activity fest.

Außerdem weisen wir in Zeile 3 unserer neuen Activity ein label zu. Dies erfolgt dynamisch, indem wir auf die String-Konstante @string/title_activity_einstellungen verweisen. Diesen müssen wir aber noch im nächsten Arbeitsschritt anlegen.

2.4 Anlegen des Titel-Strings in der strings.xml Ressourcen-Datei

Als letzten Schritt müssen wir den String-Verweis @string/title_activity_einstellungen aus dem AndroidManifest in der Ressourcen-Datei strings.xml definieren.

Dazu öffnen wir die Datei mit einem Doppelklick auf den Eintrag strings.xml in der Projekt-Ansicht von Android Studio. Die Datei befindet sich im Unterverzeichnis res/values. Die folgende Abbildung zeigt den Ort der strings.xml-Datei und enthält bereits die einzufügende Codezeile (blauer Rahmen A):

Die folgende Anweisung muss in die Datei eingefügt werden:

strings.xml

<string name="title_activity_einstellungen">Einstellungen</string>

Jetzt kann das AndroidManifest den Wert für den Titel unserer neuen Activity aus der Ressourcen-Datei strings.xml auslesen. Dieses dynamische Zuweisen von Strings ist bei späteren Lokalisierungen der Anwendung von großem Vorteil, da in der Datei strings.xml alle Bezeichnungen an einer Stelle gespeichert werden und daher nur diese geändert werden muss.

Mit diesem letzten Arbeitsschritt ist die neue Activity EinstellungenActivity in unsere Anwendung hinzugefügt worden. Damit wir testen können, ob alles wie gewünscht funktioniert, müssen wir sie mittels Android Intent starten.

3. Starten der neuen Settings-Activity

Die neue Settings-Activity soll über den Menüeintrag Settings aus den beiden bereits vorhandenen Activities MainActivity und AktiendetailActivity gestartet werden. Der Menüeintrag ist bereits in den beiden Activities vorhanden, es wird jedoch noch nicht auf das Anklicken des Eintrags reagiert.

Dies ändern wir nun, indem wir in der Methode onOptionsItemSelected überprüfen, ob der Settings-Menüeintrag gedrückt wurde. Die Methode ist bereits in den beiden Activities MainActivity und AktiendetailActivity vorhanden und muss nur von uns ergänzt werden.

Das Vorgehen ist bei beiden Activities identisch. Wir beginnen mit der Activity MainActivity. Dazu öffnen wir sie in Android Studio und scrollen zu der onOptionsItemSelected-Methode im Quelltext.

In der Methode verändern wir den Quelltext an der Stelle der if-Anweisung folgendermaßen:

MainActivity.java

if (id == R.id.action_settings) {
    startActivity(new Intent(this, EinstellungenActivity.class));
    return true;
}

Mit der Anweisung in Zeile 2 starten wir unsere neue Activity EinstellungenActivity, indem wir einen Intent erzeugen und mit dessen Hilfe die neue Android Activity starten.

Danach fügen wir die notwendige Import-Anweisung ganz oben im Quellcode ein, falls dies nicht schon automatisch von Android Studio vorgenommen wurde:

MainActivity.java

import android.content.Intent;

Das Ergebnis sieht dann wie folgt aus:

Die gleiche Änderung nehmen wir nun auch an der onOptionsItemSelected-Methode der AktiendetailActivity vor.

Auch hier muss mit dem oben angegebenen Quellcode die if-Anweisung verändert werden. Da wir die gleiche Activity mit dem Intent starten möchten, bleibt der Code unverändert. Auch diesmal muss die Klasse Intent zu Beginn des Quelltextes mit der Import-Anweisung importiert werden.

Die folgende Abbildung zeigt die vorgenommenen Änderungen an der AktiendetailActivity-Klasse:

Jetzt haben wir den Settings-Menüeintrag für beide Activities mit einer Funktion hinterlegt, wodurch die neue Settings-Activity bei Klick auf den Button gestartet wird.

3.1 Testen des Menüeintrags und Starten der Settings-Activity

Nun möchten wir unsere Settings-Activity auch einmal in Aktion sehen. Dazu installieren und starten wir unsere AktieHQ App wie in Abschnitt 8 beschrieben.

Die untere Abbildung zeigt das Verhalten unserer Android App:

Die EinstellungenActivity sollte sich auf diese Weise auch von der AktiendetailActivity starten lassen.

4. Definieren der Preferences in XML

Kommen wir nun zu dem wichtigsten Teil dieser Lektion. Wir haben bis jetzt nur eine leere EinstellungenActivity, die als Rahmen für unsere Einstellungselemente (Preferences) fungiert.

In diesem Abschnitt werden wir zunächst die Theorie, die hinter Settings und Preferences in Android steckt, weiter vertiefen und anschließend die Preferences in einer XML-Datei definieren und sie unserer EinstellungenActivity hinzufügen.

Was sind Preferences in Android?

In Android bestehen Settings aus Preference-Elementen die von der Hauptklasse Preference abgeleitet sind und in einer XML-Datei deklariert wurden.

Ein Preference-Objekt ist ein Block für eine einzelne Einstellung (Setting). Die Preference-Objekte können wie Blöcke in einer Liste aufgereiht werden.

Dabei besitzt jeder Block seine eigenen Merkmale und ein entsprechendes User Interface, durch das der Benutzer die gewünschte Einstellung vornehmen kann.

Eine ListPreference bspw. erzeugt ein Element, das bei Anklicken einen Dialog mit Listenelementen öffnet. Eine CheckBoxPreference erzeugt ein Element, das eine Checkbox anzeigt.

Jede Preference, die der Liste (den Settings) zugefügt wird, besitzt ein Schlüssel-Wert Paar (key-value pair), welches das Android System nutzt, um die vorgenommene Einstellung zu speichern.

Die Einstellung wird zusammen mit den anderen App-Einstellungen in einer Default SharedPreferences-Datei gespeichert. Wenn der Nutzer eine Einstellung ändert, aktualisiert das System den zum angegebenen Schlüssel passenden Wert in der SharedPreferences-Datei.

Auf die SharedPreferences-Datei sollte nur lesend zugegriffen werden. Das Speichern übernimmt das Android System.

Die in der SharedPreferences-Datei abgespeicherten Werte können von folgenden Datentypen sein:

• Boolean
• Float
• Int
• Long
• String
• String Set

Da die Benutzeroberfläche der App-Einstellungen (settings user interface) in Android aus Preference-Objekten zusammengesetzt wird und nicht aus View-Objekten besteht, muss eine spezialisierte Activity- oder Fragment-Klasse für das Darstellen der Settings verwendet werden.

Hierbei muss die Android Zielplattform beachtet werden:

• Android älter als 3.0 – Soll die eigene App auf Android Geräten mit API Level 10 und niedriger laufen, muss die Settings-Activity eine Erweiterung der Klasse PreferenceActivity sein.
• Ab Android 3.0 – Sollte eine normale Activity verwendet werden, die ein PreferenceFragment besitzt. Das PreferenceFragment zeigt dabei die App-Settings an.

Jede Einstellung (setting) für unsere App wird also von einer speziellen Unterklasse der Preference-Klasse repräsentiert. Jede Unterklasse besitzt Hauptmerkmale, wie den Titel der Einstellung oder den Default-Wert. Jede Unterklasse stellt aber auch zusätzliche, spezielle Eigenschaften zur Verfügung, wie ein EditText-Widget bei der EditTextPreference.

Dadurch ist in Android jeder Listeneintrag des Einstellungsbildschirms mit einem spezialisierten Preference-Objekt hinterlegt.

In der folgenden Liste sind die aktuell verfügbaren Preferences aufgeführt:

• CheckBoxPreference – Eine Preference, die ein Checkbox-Widget zur Verfügung stellt.
• EditTextPreference – Diese Preference erlaubt die Eingabe einer Zeichenkette in einen EditText-Dialog.
• ListPreference – Diese Preference zeigt eine Liste von Einträgen als Dialog an.
• MultiSelectListPreference – In dieser Preference können mehrere Listenelemente ausgewählt werden.
• SwitchPreference – Eine Preference, die einen Schalter mit zwei Zuständen zur Verfügung stellt.

Weiterführende Informationen über Settings und SharedPreferences findet ihr auf den folgenden Seiten der Android Developer Webseite:

• Settings in Android
• SharedPreferences in Android

Definieren der Preferences in XML

In Android können Preferences per XML im Vorfeld definiert und auch während der Laufzeit instanziiert werden. Beides ist möglich. Um eine leichter lesbare Struktur zu erhalten, ist die erste Variante besser, also die Preferences (die Liste der Einstellungen) in einer XML-Datei als eine Hierarchie von Preference-Objekten zu definieren. Dadurch wird auch das Updaten später deutlich einfacher.

Außerdem sind die App-Einstellungen auf diese Weise vordefiniert. Sie können dennoch zur Laufzeit verändert werden, sollte dies einmal unbedingt notwendig sein.

Wir werden nun eine Liste von Einstellungen, also die Preferences unserer Android App, in XML definieren. Dazu werden wir die folgenden Schritte durchführen:

1. Anlegen des Verzeichnis xml in dem res-Verzeichnis unseres Projekts.
2. Erstellen der preferences.xml Datei in diesem Verzeichnis.
3. Definieren unserer Preferences in der preferences.xml Datei.
4. Ergänzen der benötigten String-Konstanten in der strings.xml Ressourcen-Datei.
5. Anzeigen der Preferences in unserer bisher noch leeren EinstellungenActivity.

4.1 Anlegen des Verzeichnis „xml“ im Ressourcen-Ordner

Wir legen nun das Verzeichnis an, in welchem die preferences.xml Datei abgelegt wird. In das Verzeichnis können wir auch weitere Preferences-Dateien legen, bspw. wenn mehrere Fragmente die Einstellungen anzeigen sollen. In unserem Fall, und auch in den meisten anderen Fällen, benötigen wir aber nur eine XML-Datei.

Das Verzeichnis legen wir wie folgt an:

1. Mit der rechten Maustaste auf das res-Verzeichnis in der Projekt-Ansicht klicken.
2. Danach auf den Menüeintrag New klicken.
3. Anschließend auf den Android resource directory-Eintrag klicken.

Als Nächstes öffnet sich der New Resource Directory-Dialog. Hier gibt es eine Menge an Einstellungsmöglichkeiten, von denen die meisten für uns keine Bedeutung haben. Für uns sind nur die oberen beiden Textfelder interessant.

Wir nehmen in dem Dialog die folgenden Einstellungen vor:

1. Als Directory name geben wir xml in das Textfeld ein.
2. Für den Resource type wählen wir xml aus der DropDown-Liste aus.
3. Anschließend klicken wir auf den OK-Button.

Android Studio erstellt nun automatisch das XML Ressourcen-Verzeichnis. Zu Beginn ist der Ordner noch leer, aber das werden wir nun ändern.

4.2 Erstellen der preferences.xml Datei im XML-Verzeichnis

Jede Preference-Unterklasse kann als XML-Element in der preferences.xml Datei deklariert werden. Dazu muss als Name des Elements der Klassenname verwendet werden, wie bspw. EditTextPreference.

Die XML-Datei kann einen beliebigen Namen besitzen, es ist aber sinnvoll sie preferences.xml zu nennen.

Wir legen die preferences.xml Datei folgendermaßen an:

1. Mit der rechten Maustaste auf das xml-Verzeichnis im res-Verzeichnis klicken.
2. Dann auf den Menüeintrag New klicken.
3. Danach auf den XML resource file-Eintrag klicken.

Es öffnet sich der New XML Resource File-Dialog, in welchem wir die folgenden beiden Eingaben vornehmen:

1. Als File name geben wir preferences an.
2. Das Root element soll ein PrefrenceScreen sein.

Anschließend klicken wir auf den OK-Button. Android Studio erstellt nun automatisch die preferences.xml Datei und legt diese in dem frisch angelegten xml-Verzeichnis ab.

4.3 Definieren der Preferences in der preferences.xml Datei

Die eben erstellte preferences.xml Datei besitzt momentan nur den Wurzelknoten PreferenceScreen als einziges Element. Innerhalb des PreferenceScreen-Elements fügen wir unsere Preferences ein.

Jedes Kindelement, das wir innerhalb des PreferenceScreen einfügen, erscheint als einzelner Eintrag in der Preferences-Liste (list of settings), die alle Einstellungen unserer Android App enthält.

Wir fügen nun unsere erste Preference in die preferences.xml Datei ein.

Dazu verwenden wir den folgenden Quellcode:

preferences.xml

<?xml version="1.0" encoding="utf-8"?>

<PreferenceScreen xmlns:android="http://schemas.android.com/apk/res/android">

    <EditTextPreference
        android:title="@string/preference_aktienliste_title"
        android:key="@string/preference_aktienliste_key"
        android:defaultValue="@string/preference_aktienliste_default"
        android:inputType="textMultiLine" />

</PreferenceScreen>

Den oberen Quellcode fügen wir in die preferences.xml Datei ein und überschreiben damit den alten bereits vorhandenen Quellcode.

In den Zeilen 5 bis 9 definieren wir das EditTextPreference-Objekt. Dabei haben die vier Attribute folgende Bedeutung:

• android:title – Enthält den Titel der Einstellung.
• android:key – Diesen einzigartigen Schlüssel (unique key) verwendet das Android System, um den Wert der Einstellung in den SharedPreferences abzuspeichern.
• android:defaultValue – Spezifiziert den Initialwert, den das Android System in die SharedPreferences-Datei speichert. Für jede Einstellung sollte ein default value angegeben werden.
• android:inputType – Legt fest wie die Eingaben vom Benutzer eingegeben werden können, z.B. als Text, Zahlen, Datum mit entsprechendem Eingabe-Dialog.

Die folgende Abbildung zeigt die preferences.xml Datei in unserem Android Studio Projekt:

Für Preference-Objekte sind noch viele weitere Attribute definiert. Mehr Informationen über alle unterstützten Attribute könnt ihr in der Preference Dokumentation und den zugehörigen Unterklassen finden.

Für die ersten drei Attribute verwenden wir Verweise aus String-Konstanten. Die Konstanten sind noch nicht vorhanden und müssen als Nächstes angelegt werden.

4.4 Ergänzen der String-Konstanten in der strings.xml Datei

Damit unsere Android App später leichter zu übersetzen (lokalisieren) und warten ist, haben wir alle Bezeichnungen der App in der Ressourcen-Datei strings.xml ausgelagert. Für unsere EditTextPreference verwenden wir drei weitere Bezeichnungen, die wir jetzt in der strings.xml Datei ergänzen müssen.

Die folgenden Codezeilen müssen in die strings.xml Datei eingefügt werden:

strings.xml

<string name="preference_aktienliste_title">Liste der Finanzinstrumente</string>
<string name="preference_aktienliste_key">aktienliste</string>
<string name="preference_aktienliste_default">BMW.DE,DAI.DE,VOW3.DE,SAP.DE,^GDAXI</string>

Somit sieht die Ressourcen-Datei strings.xml jetzt folgendermaßen aus:

4.5 Anzeigen der Preferences in der EinstellungenActivity

Wir haben nun alle notwendigen Arbeitsschritte ausgeführt und Preferences für unsere Android App in einer XML-Datei definiert. Jetzt können wir die Preferences in unsere vorher erstellte EinstellungenActivity laden und von dieser anzeigen lassen.

Dieser Schritt ist sehr einfach und besteht nur aus einer einzigen Anweisung.

Die EinstellungenActivity, unsere Settings-Activity, ist von der PreferenceActivity-Klasse abgeleitet. Dadurch ist sie in der Lage eine Liste von Einstellungen (list of settings) aus einer Hierarchie von Preference-Objekten zu laden und anzuzeigen. Die Einstellungen werden automatisch gespeichert, wenn der Benutzer eine Änderung daran vornimmt. Diese Funktionalität ist bereits in der Vaterklasse (PreferenceActivity) implementiert.

Die Liste der Einstellungen (list of settings) werden mit der Anweisung addPreferencesFromResource() aus der vorher angelegten XML-Datei, in der alle Preferences deklariert sind, geladen. Somit müssen wir nur diese eine Anweisung einfügen und unsere Preferences-Objekte werden erzeugt.

Wir fügen folgende Anweisung in die onCreate()-Methode der EinstellungenActivity ein:

EinstellungenActivity.java

addPreferencesFromResource(R.xml.preferences);

Die beiden Toast-Anweisungen benötigen wir nicht mehr, daher löschen wir die beiden entsprechenden Zeilen im Quelltext und die zugehörige Import-Anweisung.

Android Studio informiert uns darüber, dass diese Anweisung veraltet ist. Da wir unsere Android Anwendung aber für Android ab API 10 (minSdkVersion) entwickeln, werden wir sie verwenden.

Diese eine Anweisung ist für einfache Android Anwendungen oft ausreichend, da das Android System Änderungen an den Einstellungen automatisch in der Default SharedPreferences Datei speichert. Aus dieser kann man dann bei Bedarf den Wert der Einstellung wieder auslesen. Wir werden aber im nächsten Abschnitt noch etwas Code hinzufügen, um selbst auf Einstellungsänderungen reagieren zu können.

In unserem Android Projekt sieht die Klasse EinstellungenActivity nun folgendermaßen aus:

4.6 Testen der Settings-Activity jetzt mit einem Einstellungselement

Nun möchten wir unsere Settings-Activity mit dem EditTextPreference-Objekt in Aktion sehen. Dazu installieren und starten wir unsere AktieHQ App wie in Abschnitt 8 beschrieben.

Die untere Abbildung zeigt das Verhalten unserer Android App:

Unsere Aktien-App besitzt jetzt ihre erste Einstellungsoption, ein EditTextPreference-Objekt. Später werden wir noch eine weitere Einstellungsoption hinzufügen, aber für den Moment sind wir mit dem einen Element sehr zufrieden.

Es ist sogar jetzt schon möglich eine neue Aktienliste einzugeben. Aber die Aktiendaten werden nicht für die in der Preference hinterlegten Symbole geholt, da im Moment immer für BMW.DE, DAI.DE und ^GDAXI die Finanzdaten angefragt werden.

Daher muss unsere Android Anwendung noch etwas angepasst werden, damit wir für die, in den SharedPreferences hinterlegte, Aktienliste die Finanzdaten anfragen.

Diese Codeänderungen werden wir in dem nächsten Abschnitt vornehmen. Außerdem möchten wir die in der Liste ausgewählten Finanzinstrumente in der Einstellung anzeigen und werden daher einen onPreferenceChangeListener in unserer EinstellungenActivity implementieren.

5. Implementieren eines OnPreferenceChangeListener

Mit einem OnPreferenceChangeListener können wir auf vom Benutzer vorgenommene Änderungen an bestimmten Einstellungen reagieren. Dazu wird für die relevante Einstellung (preference) ein OnPreferenceChangeListener registriert. Sobald der Nutzer die Einstellung ändert, wird vom Listener die Methode onPreferenceChange mittels Callback aufgerufen.

Dadurch ist es möglich, den in der Methode onPreferenceChange hinterlegten Code auszuführen, immer dann wenn sich die entsprechende Einstellung ändert.

Unsere Klasse EinstellungenActivity implementiert bereits das OnPreferenceChangeListener-Interface. Es ist aber noch keine Funktionalität hinterlegt. Das wollen wir nun ändern.

Mit diesen Schritten implementieren wir den OnPreferenceChangeListener:

1. Auswahl einer bestimmten Preference. Bei uns ist es die Preference, die die Aktienliste speichert.
2. Registrieren des OnPreferenceChangeListener für diese Preference.
3. Füllen der onPreferenceChange-Methode mit Funktionalität.

Die ersten beiden Schritte werden mit dem folgenden Codeblock ausgeführt, der in die onCreate-Methode der EinstellungenActivity eingefügt werden muss:

EinstellungenActivity.java

Preference aktienlistePref = findPreference(getString(R.string.preference_aktienliste_key));
aktienlistePref.setOnPreferenceChangeListener(this);

Mit Zeile 1 suchen wir nach der Preference, die unsere aktuell ausgewählten Finanzinstrumente für die Aktienabfrage speichert. Den Verweis auf die Preference speichern wir in der Variable aktienlistePref ab.

Durch die Anweisung in Zeile 2 registrieren wir für die Preference aktienlistePref einen OnPreferenceChangeListener und zwar den in unserer Klasse implementierten. Daher das this. Somit wird bei Änderung der Aktienliste-Einstellung die Methode onPreferenceChange unserer Klasse EinstellungenActivity ausgeführt.

In der Methode onPreferenceChange können wir also auf die Einstellungsänderung reagieren. Als Reaktion möchten wir die ausgewählten Finanzinstrumente anzeigen und zwar als android:summary im Bildschirm unserer EinstellungenActivity.

Eine summary ist die Zusammenfassung der entsprechenden Einstellung im PreferenceActivity-Bildschirm (screen).

Wir erweitern daher die onPreferenceChange-Methode folgendermaßen:

EinstellungenActivity.java

public boolean onPreferenceChange(Preference preference, Object value) {

    preference.setSummary(value.toString());

    return true;
}

Damit die summary auch sofort beim Erzeugen der Activity EinstellungenActivity angezeigt wird, müssen wir noch die folgenden Zeilen in die onCreate-Methode einfügen.

EinstellungenActivity.java

// onPreferenceChange sofort aufrufen mit der in SharedPreferences gespeicherten Aktienliste
SharedPreferences sharedPrefs = PreferenceManager.getDefaultSharedPreferences(this);
String gespeicherteAktienliste = sharedPrefs.getString(aktienlistePref.getKey(), "");
onPreferenceChange(aktienlistePref, gespeicherteAktienliste);

Mit den oberen Anweisungen lesen wir die aktuelle Aktienliste aus den SharedPreferences aus und übergeben sie der onPreferenceChange-Methode zusammen mit der Aktienliste-Preference. In der onPreferenceChange-Methode wird dann die summary der Aktienliste-Preference auf den übergebenen Wert, also die aktuelle Aktienliste, gesetzt.

Zusätzlich müssen noch die beiden folgenden Import-Anweisungen zu Beginn der Klassendatei eingefügt werden:

EinstellungenActivity.java

import android.content.SharedPreferences;
import android.preference.PreferenceManager;

Der Quellcode ist leichter zu verstehen, wenn man die gesamte Klasse betrachtet. In der unteren Abbildung ist daher die Klasse EinstellungenActivity zum besseren Verständnis abgebildet:

Mit dem orange markierten Codeblock A registrieren wir den OnPreferenceChangeListener für die Aktienliste-Preference.

Mit dem orange markierten Codeblock B rufen wir die onPreferenceChange-Methode selbst auf und übergeben ihr die aktuelle Aktienliste, welche wir vorher aus den SharedPreferences ausgelesen haben.

Mit dem blau markierten Codeblock C implementieren wir die onPreferenceChange-Methode des OnPreferenceChangeListener-Interfaces. Wir setzen den Wert der summary auf den übergebenen Wert. In unserem Fall ist dies die aktuell ausgewählte Aktienliste.

5.1 Testen der Settings-Activity jetzt mit OnPreferenceChangeListener

Nun möchten wir unsere Settings-Activity mit dem OnPreferenceChangeListener testen. Dazu installieren und starten wir unsere AktieHQ App wie in Abschnitt 8 beschrieben.

Die untere Abbildung zeigt das Verhalten unserer Android App:

Die ausgewählte Aktienliste wird jetzt in der Einstellung angezeigt. Unsere Android App reagiert also auf Einstellungsänderungen.

Die Finanzdaten werden jedoch weiterhin nur für die drei fest codierten Symbole BMW.DE, DAI.DE und ^GDAXI abgefragt. Im nächsten Abschnitt werden wir dies ändern und die Finanzdaten für die, in SharedPreferences hinterlegte, Aktienliste abfragen.

6. Preference-Wert aus den SharedPreferences auslesen

Die notwendigen Änderungen werden wir in dem AktienlisteFragment vornehmen. Dazu werden wir aus den Default SharedPreferences die aktuell ausgewählte Aktienliste auslesen und für diese dann die Aktiendaten-Anfrage ausführen.

Die Abfrage der simulierten Online-Aktiendaten von unserem Web-Server wird mit einem Klick auf den Aktualisieren-Button im Overflow-Menü gestartet. Daher müssen wir den für den Button hinterlegten Code anpassen.

Dazu nehmen wir folgende Änderungen an der onOptionsItemSelected-Methode in der Klasse AktienlisteFragment vor:

AktienlisteFragment.java

public boolean onOptionsItemSelected(MenuItem item) {
  // Wir prüfen, ob Menü-Element mit der ID "action_daten_aktualisieren" 
  // ausgewählt wurde, holen die Finanzdaten und geben eine Meldung aus
  int id = item.getItemId();
  if (id == R.id.action_daten_aktualisieren) {

    // Erzeugen einer Instanz von HoleDatenTask
    HoleDatenTask holeDatenTask = new HoleDatenTask();

    // Auslesen der ausgewählten Aktienliste aus den SharedPreferences
    SharedPreferences sPrefs = PreferenceManager.getDefaultSharedPreferences(getActivity());
    String prefAktienlisteKey = getString(R.string.preference_aktienliste_key);
    String prefAktienlisteDefault = getString(R.string.preference_aktienliste_default);
    String aktienliste = sPrefs.getString(prefAktienlisteKey,prefAktienlisteDefault);

    // Starten des asynchronen Tasks und Übergabe der Aktienliste
    holeDatenTask.execute(aktienliste);

    // Den Benutzer informieren, dass neue Aktiendaten im Hintergrund abgefragt werden
    Toast.makeText(getActivity(), "Aktiendaten werden abgefragt!", Toast.LENGTH_SHORT).show();

    return true;
  }
  return super.onOptionsItemSelected(item);
}

In den Zeilen 11 bis 14 lesen wir die ausgewählte Aktienliste aus den SharedPreferences aus. Dazu lassen wir uns zuerst die DefaultSharedPreferences für unsere Android App geben. Anschließend lesen wir aus der strings.xml Ressourcen-Datei den Schlüssel (key) und den Default-Wert für die Aktienliste-Preference aus.

In Zeile 14 lesen wir mit der getString-Methode die ausgewählte Aktienliste aus dem SharedPreferences-Objekt aus. Dabei ist der erste Parameter der Schlüssel, zu dem die Methode getString in den SharedPreferences den abgelegten Wert (value) sucht und zurück liefert. Sollte kein Wert für den Schlüssel hinterlegt sein, wird der zweite Parameter von der getString-Methode zurück geliefert. In unserem Fall ist das der Default-Wert (BMW.DE,DAI.DE,VOW3.DE,SAP.DE,^GDAXI) der Aktienliste-Preference.

In Zeile 17 starten wir den asynchronen Task und übergeben ihm die eben ausgelesene Aktienliste als Parameter.

Damit die Finanzdaten auch wirklich für die ausgewählte Aktienliste abgefragt werden, müssen wir die Methode doInBackground des asynchronen Tasks in der AktienlisteFragment-Klasse anpassen.

AktienlisteFragment.java

protected String[] doInBackground(String... strings) {

  if (strings.length == 0) { // Keine Eingangsparameter erhalten, daher Abbruch
    return null;
  }

  // Exakt so muss die Anfrage-URL an unseren Web-Server gesendet werden:
  // https://www.programmierenlernenhq.de/tools/query.php?s=DAI.DE,BMW.DE

  // Wir konstruieren die Anfrage-URL für unseren Web-Server
  final String URL_PARAMETER = "https://www.programmierenlernenhq.de/tools/query.php";

  String symbols = strings[0];

  String anfrageString = URL_PARAMETER;
  anfrageString += "?s=" + symbols;

  .
  .
  .

Es muss nur eine Änderung vorgenommen werden. Und zwar muss in die String-Variable symbols die übergebene Aktienliste gespeichert werden.

Dazu wird in Zeile 13 das erste Element des String-Arrays strings in der Variable symbols gespeichert.

Das war auch schon alles. Jetzt wird von unserer Android Anwendung die in den Einstellungen gespeicherte Aktienliste für die Abfrage der Online-Finanzdaten verwendet.

Als letzte Änderung in der AktienlisteFragment-Klasse fügen wir ganz oben im Quellcode die folgenden beiden Import-Anweisungen ein:

AktienlisteFragment.java

import android.content.SharedPreferences;
import android.preference.PreferenceManager;

Zur Übersicht könnt ihr euch auch den gesamten Quelltext der Klasse AktienlisteFragment.java noch einmal in Ruhe anschauen:

AktienlisteFragment.java (als ZIP-Datei gepackt)

6.1 Testen der gewählten Aktienliste und Abfragen der Finanzdaten

Nun möchten wir unsere App testen, um zu sehen ob die Online-Finanzdaten für die, in den Preferences festgelegte, Aktienliste angefragt werden. Dazu installieren und starten wir unsere AktieHQ App wie in Abschnitt 8 beschrieben.

Die untere Abbildung zeigt das Verhalten unserer Android App:

Wie in der oberen Abbildung zu sehen ist, lädt unsere Android App jetzt die gewünschten Finanzdatendaten für die, vom Benutzer vorher festgelegte, Aktienliste.

Im nächsten Abschnitt werden wir unserer Android Anwendung eine weitere Preference hinzufügen. Dadurch soll das Verwenden von Settings und Preferences in Android noch einmal verdeutlicht werden. Das Vorgehen dabei entspricht fast vollständig dem von Abschnitt 4.

7. Hinzufügen einer weiteren Preference

Unsere Android App zeigt momentan eine individuelle Aktienliste an. Für einen schnellen Marktüberblick bietet sich eine Indizeliste an, die unsere User bei Bedarf aktivieren können. Es müsste dabei mit einer weiteren Preference einfach zwischen den beiden Listen gewechselt werden.

Dazu fügen wir unserer Anwendung eine weitere Preference hinzu, die es den Benutzern mit Hilfe einer Checkbox ermöglicht, den gewünschten Modus festzulegen.

Das Hinzufügen der weiteren Preference läuft nach folgendem Schema ab:

1. Definieren der neuen Preference in der preferences.xml Datei.
2. Ergänzen der benötigten String-Konstanten in der strings.xml Datei.
3. Auslesen des hinterlegten Einstellungswerts und Erstellen der gewünschten Indize-Übersicht.

Es werden nur diese drei Schritte benötigt. Einen OnPreferenceChangeListener müssen wir nicht registrieren, da das Android System den ausgewählten Wert selbständig speichert und uns dies hier ausreicht.

7.1 Definieren der neuen Preference in der preferences.xml Datei

Die neue Preference soll eine CheckBoxPreference sein. Der Benutzer soll über sie festlegen können, welche Aktienliste ausgegeben werden soll.

Um die neue Preference anzulegen, öffnen wir die preferences.xml Datei in Android Studio und fügen den folgenden Quellcode nach EditTextPreference ein:

preferences.xml

<CheckBoxPreference
    android:title="@string/preference_indizemodus_title"
    android:key="@string/preference_indizemodus_key"
    android:defaultValue="false"
    android:summary="@string/preference_indizemodus_summary" />

Die ersten drei Attribute sind uns bereits aus der EditTextPreference bekannt. Neu hingegen ist das Attribut android:summary. Die summary ist eine Zusammenfassung der Einstellung und steht direkt unter dem Einstellungstitel. Sie kann den aktuell eingestellten Wert anzeigen oder eine kurze Beschreibung der Einstellung sein.

In unserem Android Projekt sieht die preferences.xml Datei jetzt wie folgt aus:

Als Nächstes müssen dir die String-Konstanten in der strings.xml Ressourcen-Datei ergänzen.

7.2 Ergänzen der String-Konstanten in der strings.xml Datei

Die neue Preference verwendet drei String-Konstanten, die bisher noch nicht angelegt worden sind. In diesem Schritt werden wir dies nachholen.

Dazu öffnen wir die strings.xml Datei in Android Studio und ergänzen die folgenden drei String-Konstanten am Ende des Quellcodes:

strings.xml

<string name="preference_indizemodus_title">Marktübersicht (Indize-Modus)</string>
<string name="preference_indizemodus_key">indizemodus</string>
<string name="preference_indizemodus_summary">Eine Indizeliste wird anstelle der Aktienliste angezeigt.</string>

Jetzt kann von der preferences.xml Datei auf die drei oben definierten String-Konstanten zugegriffen werden.

Die folgende Abbildung zeigt die strings.xml Datei mit den eben vorgenommenen Ergänzungen:

Damit der, von dem Benutzer ausgewählte, Wert sich auch auf das Verhalten unserer Android App auswirkt, müssen wir einige kleine Änderungen an der AktienlisteFragment-Klasse vornehmen. Dies erfolgt im nächsten Arbeitsschritt.

7.3 Auslesen des hinterlegten Einstellungswerts und Erstellen der gewünschten Finanzübersicht

In der Klasse AktienlisteFragment müssen wir zwei Änderungen vornehmen:

1. Auslesen des hinterlegten Einstellungswerts aus den SharedPreferences.
2. Aufrufen des asynchronen Tasks mit der entsprechenden Liste, Aktien- oder Indize-Liste, und damit Anfrage der Finanzdaten starten.

Diese Änderungen nehmen wir in der onOptionsItemSelected-Methode in der Klasse AktienlisteFragment vor:

AktienlisteFragment.java

public boolean onOptionsItemSelected(MenuItem item) {
  // Wir prüfen, ob Menü-Element mit der ID "action_daten_aktualisieren"
  // ausgewählt wurde, holen die Finanzdaten und geben eine Meldung aus
  int id = item.getItemId();
  if (id == R.id.action_daten_aktualisieren) {

    // Erzeugen einer Instanz von HoleDatenTask
    HoleDatenTask holeDatenTask = new HoleDatenTask();

    // Auslesen der ausgewählten Aktienliste aus den SharedPreferences
    SharedPreferences sPrefs = PreferenceManager.getDefaultSharedPreferences(getActivity());
    String prefAktienlisteKey = getString(R.string.preference_aktienliste_key);
    String prefAktienlisteDefault = getString(R.string.preference_aktienliste_default);
    String aktienliste = sPrefs.getString(prefAktienlisteKey, prefAktienlisteDefault);

    // Auslesen des Anzeige-Modus aus den SharedPreferences
    String prefIndizemodusKey = getString(R.string.preference_indizemodus_key);
    Boolean indizemodus = sPrefs.getBoolean(prefIndizemodusKey, false);

    // Starten des asynchronen Tasks und Übergabe der Aktienliste
    if (indizemodus) {
    String indizeliste = "^GDAXI,^TECDAX,^MDAXI,^SDAXI,^GSPC,^N225,^HSI,XAGUSD=X,XAUUSD=X";
    holeDatenTask.execute(indizeliste);
            }
    else {
      holeDatenTask.execute(aktienliste);
    }

    // Den Benutzer informieren, dass neue Aktiendaten im Hintergrund abgefragt werden
    Toast.makeText(getActivity(), "Aktiendaten werden abgefragt!", Toast.LENGTH_SHORT).show();

    return true;
  }

  return super.onOptionsItemSelected(item);
}

Die gelb markierten Codezeilen sind unsere Änderungen am bestehenden Quelltext.

In Zeile 17 lesen wir den Schlüssel für die Indizemodus-Einstellung aus, um damit in Zeile 18 den in DefaultSharedPreferences aktuell hinterlegten Wert zu erfragen. Sollte keiner hinterlegt sein, setzen wir den Wert auf false.

In den Zeilen 21 bis 27 starten wir den asynchronen Task. Wenn der User den Indizemodus ausgewählt hat, übergeben wir dem asynchronen Task die indizeliste. Die Variable ist vom Typ String und enthält die wichtigsten Indizes.

Ist der Indizemodus nicht aktiviert, übergeben wir dem asynchronen Task die aktienliste.

Diesmal müssen wir keine zusätzlichen Import-Anweisungen der Klasse hinzufügen.

Somit sind die notwendigen Änderungen an der AktienlisteFragment-Klasse vorgenommen und wir können die neue Einstellung unserer Android App testen.

Zur Übersicht könnt ihr euch auch den gesamten Quelltext der Klasse AktienlisteFragment.java noch einmal in Ruhe anschauen:

AktienlisteFragment.java (als ZIP-Datei gepackt)

8. Starten unserer Android App und Testen der neuen Einstellung

Alle notwendigen Änderungen an den Quelltexten unseres Android Projekts sind vorgenommen. Nun wollen wir unsere App testen. Dazu installieren wir die Anwendung auf unser angeschlossenes Android Gerät (Smartphone oder Tablet) und lassen sie dort ausführen.

Um die App auf dem Android Gerät starten zu können, müssen alle Schritte von Teil 3 des Android Tutorials befolgt worden sein.

Hier noch einmal in Kürze die wichtigsten Arbeitsschritte.

Zuerst schließen wir unser Android Gerät an den PC an und stellen eine Verbindung über die ADB (Android Debug Bridge) her. Danach klicken wir auf das Run 'app'-Symbol. Unser Android Projekt wird dadurch neu erstellt und auf dem angeschlossenen Gerät ausgeführt.

Das Run 'app'-Symbol befindet sich in der oberen Menüleiste, siehe folgende Abbildung:

Nach einigen Momenten öffnet sich der Choose Device-Dialog. In ihm nehmen wir die folgenden Einstellungen vor:

1. Radio Button Choose a running device aktivieren
2. Das angeschlossene Android Gerät auswählen
3. Mit einem Klick auf den OK-Button die Installation unserer App auf das Gerät starten

Der Dialog schließt sich und unsere Android App wird auf das angeschlossene Gerät übertragen und installiert. Die Installation dauert nur einen kurzen Augenblick und verläuft fast unbemerkt im Hintergrund. Danach wird unsere App automatisch gestartet.

8.1 Testen der CheckBox-Preference unserer Android App

Nun wollen wir die neue Einstellung testen und auf Funktion prüfen. Die CheckBoxPreference wird in der EinstellungenActivity unterhalb der EditTextPreference angezeigt.

Die unteren beiden Abbildungen zeigen das Verhalten unserer Android App:

Wie zu erkennen ist, funktioniert unsere Anwendung wie gewünscht. Es ist jetzt möglich über die EinstellungenActivity den Modus zu wechseln und zwischen einer individuellen Aktienliste und einer vorgegebenen Indizeliste zu wechseln.

8.2 Video – Testen der Settings und Preferences unserer App

Nun möchten wir unsere Android App auch einmal in der aktuellen Entwicklungsstufe im Video sehen. Dazu haben wir das folgende kurze Video erstellt, in dem die neue Funktion unserer App vorgestellt wird:

In dem oberen Video ist der gesamte Funktionsumfang unserer Android App zu sehen.

Zu Beginn fragen wir die Online-Finanzdaten für die individuelle Aktienliste an und erhalten die Finanzinformationen für die eingetragenen Symbole. Danach gelangen wir mit einem Klick auf den Settings-Menüeintrag in die EinstellungenActivity. Dort fügen wir ein weiteres Symbol (ALV.DE) der Aktienliste hinzu und drücken die Back-Taste auf unserem Android Gerät.

Anschließend lassen wir uns die Finanzdaten für die eben erweiterte Aktienliste ausgeben. Mit einem Klick auf das neu hinzugefügte Listenelement öffnen wir in die AktiendetailActivity und bekommen die Finanzdaten des Elements angezeigt.

Wir drücken die Back-Taste auf unserem Android Gerät und navigieren damit zur MainActivity unserer App zurück.

Mit einem weiteren Klick auf Settings gelangen wir wieder in unseren Settings-Bildschirm. Diesmal aktivieren wir durch zweite Einstellungsoption den Indize-Modus unserer Android Anwendung und drücken die Back-Taste.

Jetzt klicken wir auf den Aktualisieren-Menüeintrag und laden die aktuellen Finanzdaten für die hinterlegten Indizes. Diesmal wird die Indizeliste anstelle der Aktienliste für die Online-Abfrage verwendet.

Zusammenfassung

In dieser sehr großen Lektion haben wir Settings und Preferences in Android kennengelernt und erfahren wie leicht sich Einstellungen in die eigene Android Anwendung integrieren lassen.

Zuerst haben wir eine Settings-Activity, die EinstellungenActivity, erstellt und diese über das Overflow-Menü gestartet.

Danach haben wir in der preferences.xml Datei die erste Einstellung für unsere Android App definiert. Für die neue Preference haben wir die notwendigen String-Konstanten in der Ressourcen-Datei strings.xml angelegt und anschließend die Preference in unsere Settings-Activity geladen.

Um auf Benutzereingaben reagieren zu können, haben wir für die neue Preference einen OnPreferenceChangeListener registriert und durch ihn die aktuelle Aktienliste in der Preference-Summary ausgegeben.

Damit unsere App auch auf Änderungen der Aktienlisten-Einstellung reagiert, haben wir den Quellcode in der Klasse AktienlisteFragment überarbeitet und den hinterlegten Wert aus den SharedPreferences ausgelesen.

Anschließend haben wir noch eine zweite Einstellung hinzugefügt, so dass unsere Android Anwendung jetzt über eine EditTextPreference und eine CheckBoxPreference verfügt.

Danach haben wir unsere AktieHQ App auf ein Android Smartphone installiert und ihren gesamten Funktionsumfang in einem Video vorgestellt.

---

---