Programmier Tutorial - Apps für Android entwickeln - Settings und Preferences in Android

Programmier Tutorial: Apps für Android entwickeln – Teil 11: Settings und Preferences in Android


Im elften Teil unseres großen Android™ Tutorials werden wir unsere AktieHQ App um eine Settings-Activity (Einstellungsbildschirm) erweitern. Wir stellen dazu Settings und Preferences vor und beschreiben, wie sie in Android behandelt werden.

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

android settings class

Anlegen der neuen Java Klasse EinstellungenActivity in das Android Projekt

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:

android settings class name

Angabe des Klassennamens im Create New Class-Dialog

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:

Soviel zur Theorie, jetzt kommen wir zur Praxis.

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


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.

android manifest

Deklarieren der neuen Activity in dem AndroidManifest

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.


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 stings.xml-Datei und enthält bereits die einzufügende Codezeile (blauer Rahmen A):

android strings settings

Definieren des Titel-Strings für die EinstellungenActivity in strings.xml

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


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:


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:

Das Ergebnis sieht dann wie folgt aus:

android setting activity

Settings-Menüeintrag überwachen und EinstellungenActivity starten wenn Eintrag geklickt wurde

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:

android settings starten

Settings-Menüeintrag überwachen und EinstellungenActivity starten in AktiendetailActivity

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:

android app settings

Durch Klicken des Settings-Menüeintrags startet die EinstellungenActivity

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:

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.
android xml ordner

Erstellen des “xml” Verzeichnis im “res” Verzeichnis

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 xml ordner dialog

Anlegen des XML Ressourcen Verzeichnis

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.
android xml preferences

Anlegen der preferences.xml Datei in dem XML Verzeichnis

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.
android xml preferences dialog

Erstellen der preferences.xml Datei mit dem Root Element PreferenceScreen

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:


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:

android preferences edittext

Unsere preferences.xml Datei mit einer editTextPreference

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:


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

android strings konstanten

Ergänzen der String-Konstanten für die editTextPreference in der strings.xml Datei

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:


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:

android settings laden

Laden der Settings aus der preference.xml Datei mit addPreferenceFromLayout()

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:

android preferences test

Das EditTextPreference-Objekt wird in der EinstellungenActivity angezeigt

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:


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:


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.


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:


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:

android preference change

Die Klasse EinstellungenActivity mit der Implementierung des onPreferenceChangeListener

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:

android preference summary

Das EditTextPreference-Objekt wird mit der Preference-Summary in der EinstellungenActivity angezeigt

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:


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.


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:


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:

android preference change

Finanzdaten für die in SharedPreferences gespeicherte Aktienliste werden abgefragt

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:


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:

android checkboxpreference

Die preferences.xml Datei mit einer EditTextPreference und der CheckBoxPreference

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:


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:

android strings checkbox

Ergänzen der String-Konstanten für die CheckBoxPreference in der strings.xml Datei

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:


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:

android studio project avd run

Android App über das Run App-Symbol starten

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
android choose device

Auswählen des angeschlossenen Android Geräts zum Aufspielen unserer App

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:

android preference checkbox

Die neue Preference (CheckBoxPreference) wird in der EinstellungenActivity angezeigt

android checkboxpreference

Ist die Preference Indizemodus aktiviert, wird eine Indizeliste anstelle der Aktienliste angezeigt

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.


Comments 35

  1. Pingback: Android Tutorial: Activities und Intents in Android

  2. Ich muss wirklich sagen, dies ist das beste online, gratis Android Tutorial, das es gibt. Alles ist sehr übersichtlich erklärt mit Bildern, Text. 😀
    Ich hoffe, die Reihe wird bald fortgesetzt!

    1. Post
      Author

      Hallo Tobias,

      vielen Dank für dein Lob. Es freut mich sehr, wenn das Tutorial verständlich ist. Die Reihe wird weiter fortgesetzt.

      Viele Grüße, Chris

  3. Ich muss sagen, dies ist das beste online, gratis Android Tutorial, das ich bisher gefundne habe.
    Ich freue mich schon auf eine Fortsetzung. Danke!

    1. Post
      Author
  4. Pingback: Android Tutorial: Mit impliziten Intent eine andere App aufrufen

  5. Moin,
    erstmal, wirklich ansehnliches Tutorial!
    Ab 4.5 mit dem Einfügen der Anweisung “addPreferencesFromResource(R.xml.preferences)” in die onCreate Methode, kommt beim Testen der App immer die Nachricht: “Unfortunately AktieHQ has stopped” wenn ich auf Settings klicke… An was kann das liegen? Liegt es vllt an der veralteten Anweisung?
    Viele Grüße und Danke im Voraus für die Hilfe 🙂

    1. Post
      Author

      Hallo Robin,

      an der veralteten Anweisung sollte es nicht liegen, da der Code in genau dieser Form bei vielen funktioniert hat.

      Gibt dir Android Studio eine Fehlermeldung aus? Um die Fehlermeldung in Android Studio zu sehen, darfst du nicht auf den OK-Button im “Unfortunately AktieHQ has stopped”-Dialog klicken.

      Weiterhin kannst du mit dem Debugger einen Breakpoint an der Codezeile “addPreferencesFromResource(R.xml.preferences);” setzen und dann die App im Debug-Modus mit dem grünen Käfer-Symbol ausführen. Dann im Debug-Modus untersuchen was zu dem Crash führt.

      Linkvorschläge für das Debugging:
      https://developer.android.com/tools/debugging/debugging-studio.html
      https://www.youtube.com/watch?v=Vo5PXWnKtQ4

      Viele Grüße, Chris

      1. Salü!

        Ich hatte den gleichen Fehler und hab die Ursache gefunden. Sie liegt im preferences.xml:

        Der PreferenceScreen Tag ist geschlossen, trotzdem kommen zwei Attribute nach. Sind die beiden weg, funktioniert’s.

        AndroidStudio zeigt das auch an mit dem Highlighting.

        1. Post
          Author

          Hallo André,

          danke für die Hilfe!

          Ohh, dass der Fehler beim Erstellen des Tutorials nicht aufgefallen ist. Ich werde die betreffenden Stellen in der Anleitung demnächst korrigieren.

          Viele Grüße und nochmals Danke!, Chris

  6. Wenn ich die “Liste der Finanzinstrumente” ändere in dem ich z.B. den DAX entferne, zeigt er mir das noch an, aber wenn ich aus den Einstellungen raus gehe und wieder rein ist der DAX wieder da.
    Irgendwie speichert er nicht die Änderung und ich hab jetzt schon alles mehrfach kontrolliert.
    Habt ihr vllt eine Idee woran das liegen könnte?

    1. Post
      Author

      Hallo Mathias,

      schwer zu sagen ohne Quellcode. Wenn du möchtest, kannst du mir deine Projektdateien per E-Mail zusenden. Ich werde dann mal drüber schauen, vielleicht kann ich den Fehler finden. Die E-Mail Adresse kannst du im Impressum nachschauen.

      UPDATE: Der Fehler konnte gefunden werden. In der Methode onPreferenceChange der Klasse EinstellungenActivity wurde als Rückgabewert false zurück gegeben. Es muss aber true zurück gegeben werden, sonst werden die Änderungen nicht gespeichert.

      Viele Grüße, Chris

  7. Hallo Chris,

    auch von mir nochmal vielen Dank für das klasse Tutorial… 😀

    Allerdings bleibe ich momentan im Kapitel 11.5 hängen. Ich kann android.content.SharedPreferences nicht importieren… der Eintrag bleibt ausgegraut und die Bubble-Info lautet: “Unused import statement.”

    Kannst Du mir vielleicht weiterhelfen? Ohne den Import gehts natürlich auch im SourceCode nicht weiter… 🙁

    Danke und viele Grüße
    Sepp

    1. Post
      Author

      Hallo Sepp,

      das ist ja ein merkwürdiger Fehler. Vielleicht hilft es das build.gradle im app-Ordner zu synchronisieren. Das Gradle kannst du mit Tools -> Android -> Sync Project with Gradle Files synchronisieren.

      Wenn du möchtest, kannst du mir auch deine Projektdateien als ZIP per E-Mail senden. Ich schau dann mal drüber. Die E-Mail findest du über das Impressum.

      Viele Grüße, Chris

      1. Post
        Author
    2. Noch für’s Protokoll:

      Die ausgegrauten Import-Statements in Android-Studio bedeuten zunächst einmal nicht, dass die entsprechende Klasse nicht importiert wird, sondern – siehe auch “Bubble Info: Unused import statement” – dass die Klasse gar nicht verwendet wird, genau genommen also auch nicht importiert werden muss. Ein Tippfehler bei der Verwendung des Klassennamens (s.u.) ist eine Möglichkeit, dieses Verhalten hervorzurufen.

      Bei mir kommen z.B. regelmäßig durch irgendwelche Tests automatisch import-Anweisungen in den Quelltext. Wenn sich die Tests als unbrauchbar erweisen und ich die Anweisungen im Quelltext wieder lösche, vergesse ich regelmäßig, auch die import-Statements zu löschen (da hilft die graue Schrift dann sehr dabei, den Code sauber zu halten 😉 )

      Weiß jemand (Chris?), ob “unused import statements” beim Erzeugen des Java-Bytecodes ignoriert werden?

      1. Post
        Author
  8. Hallöle,
    ein ganz tolles Tutorial. Ich würde nur gerne wissen, welche Methoden addPreferenceFromResource und findPreference ersetzt haben? Denn diese werden bei mir als deprecated angezeigt.
    Viele Grüße Kathryn

    1. Post
      Author
  9. Wir haben doch Android API Level 10 als minSdkVersion festgelegt. Im Abschnitt 2.2 wird darauf auch hingewiesen.

    Hallo,

    In der AndroidManifest.xml wird an zwei Stellen das Attribut “parentActivityName” verwendet.

    Vom AndroidStudio bekomme ich dazu folgende Warnung:

    “Attribute parentActivityName is only used in API level 16 and higher”

    Liegt hier ein Versehen vor und kann/soll man diese Warnung mit welchen Folgen ignorieren?

    Gruß, Konrad

    1. Post
      Author

      Hallo Konrad,

      die Warnung ist als Hinweis zu sehen. Wie Du schon schreibst, ist das Attribut parentActivityName erst mit API Level 16 eingeführt worden. Damit unsere App auch auf älteren Android Geräten läuft, wurde zusätzlich mit <meta-data>-Tag gearbeitet.

      Es wird dadurch die Kompatibilität für neuere und ältere Android Geräte sichergestellt. Würden wir unsere Android App nur für API Level größer gleich 16 entwickeln, könnten wir auf den <meta-data>-Tag verzichten.

      Bei StackOverflow gibt es weitere sehr interessante Infos zu diesem Thema: Question about parentActivityName attribute

      Viele Grüße, Chris

  10. Hallo Chris, es läuft alles ganz prima. Die MainActivity zeigt beim Start die “fest verdrahtete” Aktienliste, deren Kurswerte ja nicht aktualisiert werden. Habe ich da etwa übersehen, diese Liste zu löschen ?
    Frohe Ostern weiterhin ! Norbert

    1. Post
      Author

      Hallo Norbert,

      die “fest verdrahtete” Aktienliste wird immer zum Start der App angezeigt. Erst durch manuelles Aktualisieren über das Overflow Menu werden echte Aktiendaten geladen. Man könnte auch die “fest verdrahtete” Liste direkt beim Startvorgang aktualisieren, indem man den asynchronen Task zum Laden der Aktiendaten in der onCreateView() Methode direkt startet. In dem Android Tutorial haben wir dies aber, aus Platzgründen, nicht umgesetzt.

      Viele Grüße, Chris

      Update: Da bereits einige Leser nach dem automatischen Aktualisieren der Aktiendaten gefragt haben, habe ich ein kleines Video erstellt, in welchem ich zeige wie aktuelle Aktiendaten direkt beim Starten der App angefragt werden können.

      Das Video findet ihr hier: Aktiendaten automatisch bei App-Start aktualisieren [Video]

  11. Hi,

    ich bin begeistert über die Qualität und den Umfang dieses Tutorials. Es ist sehr viel von dem abgedeckt, was mich interessiert. Herzlichen Dank!

    Was mir nicht ganz klar ist, ist die Sinnhaftigkeit des Codeblock B im Abschnitt 5 (// onPreferenceChangeListener sofort aufrufen….). Ich verstehe, dass eine Änderung simuliert und der Event Handler künstlich aufgerufen wird. Aber wieso? Bei mir macht es absolut keinen Unterschied, ob ich das tue oder nicht. Oder liegt es daran, dass ich von PreferenceActivity direkt auf PreferenceFragment umgestellt habe und PreferenceFragment evtl. mehr Automatismen hat? Aber wieso brauchst Du das bei der Checkbox dann nicht?

    Viele Grüße
    Martin

    1. Post
      Author

      Hallo Martin,

      danke für’s Lob!

      Wenn mit der PreferenceActivity gearbeitet wird, muss Codeblock B verwendet werden, damit die Werte der Aktienliste in der Preference-Summary direkt beim ersten Starten der App angezeigt werden. Wird die onPreferenceChange() Methode nicht künstlich beim Erzeugen der Activity aufgerufen, enthält die Preference-Summary einen leeren String. Wie das bei dem PreferenceFragment im Detail aussieht, müsste man nochmal genau nachsehen. Aber es kann durchaus sein, dass dieser umständliche Schritt bei eine PreferenceFragment wegfällt.

      Viele Grüße, Chris

  12. Hallo,

    ich habe eine Frage. Wie kann ich ein EditTextPreference abhängig von einem ListPreference machen?

    Ich hab eine ListPreference mit zwei Items und möchte die EditTextPreference erst aktivieren wenn Item2 aktiviert ist. Wenn das Item1 aktiv ist soll es einfach grau sein oder von mir aus sogar komplett ausgeblendet. Könntest du mir da bitte helfen?

    Viele Grüße
    Samet

    1. Post
      Author
  13. Hi Chris,

    dein Tutorial ist echt Gold wert. Es gibt nichts vergleichbares im Netz.
    Danke für die Mühe und den Einsatz.

    Eine Frage zu diesem Kapitel hätte ich dennoch:
    Gibt es eine Möglichkeit die Schriftfarbe von dem preference_aktienlisten_title zu ändern bzw. von dem was wir eintippen (BMW.DE,…)? Habe es schon mit eigenen Styles probiert, aber bekomme es einfach nicht gebacken.
    Danke nochmal und liebe Grüße
    Jojo

    1. Post
      Author
  14. Hallo,

    Ich bin dabei, mich mit Android-Programming auseinander zu setzen. Ich habe allerdings ein Problem und ich hätte gedacht, dass Ihr eventuell das Problem lösen könnt, da das Tutorial oberhalb sehr ausführlich und verständlich erklärt wurde. Eigentlich eine simple Sache, allerdings wird das nie irgendwo speziell erklärt, wahrscheinlich da es so einfach ist. Ich würde gerne ein “Save Game” erstellen, d.h. wenn ich in der “MainActivity” bin und dann auf Start drücke, dass ich auswählen kann “Neues Spiel” oder “Spiel laden”. Das Save Game soll speichern wo man aufgehört hat (Bei welcher Activity man stehen geblieben ist, also “keine Werte speichern” einfach nur der Activity-Stand). Da ich mich nicht mit “Save Games” auskenne, könntet Ihr mir eventuell weiter helfen?

    l.g.
    Phil

    1. Post
      Author

      Hallo Phil,

      in Lektion 15 dieses Tutorials schreiben wir über den Android Lifecycle und wie man den Zustand von Activities zwischenspeichern kann. Möchte man den zwischengespeicherten Zustand persistent halten, könnte man ihn anschließend in einer kleinen “Save Game”-Datei ablegen, in einer Art CSV-Datei.

      Ich hoffe, das hilft Dir ein bisschen weiter.

      Viele Grüße, Chris

Schreibe einen Kommentar

Deine E-Mail-Adresse wird nicht veröffentlicht.