Android Settings Dialog Android Kurs Stufe 2 (Orangegurt)

Transkript

1 Android Kurs Stufe 2 (Orangegurt) Inhaltsverzeichnis 1 Settings Dialog Der Grundgedanke Das erste Beispiel Das Layout der MainActivity Die Settings Activity Das Settings Fragment Das Preferences Layout Der Code der MainActivity Das SharedPreferences Objekt Auslesen der Werte Ändern der Werte Einfügen neuer Werte Listener für geänderte Werte Die einzelnen Preference Elemente Grundeinstellungen Enable / Disable von Settings CheckBoxPreference SwitchPreference ListPreference EditTextPreference Submenü Lizenz Haftung AnPr_Android_Course_2_3_Settings_v01.docx Seite 1

2 1 Settings Dialog Wir haben uns nun die wesentlichen Kenntnisse angeeignet, Android Apps zu designen. Wir können Elemente dem User präsentieren und Informationen wie Klicks und Text vom User abfragen. Wie ihr als Android Nutzer aber wisst, gibt es bei fast allen Apps die Möglichkeit, Einstellungen vorzunehmen dies geschieht üblicherweise über die Settings. In diesem Dokument wollen wir uns die grundlegenden Eigenschaften des Settings Dialogs ansehen und wie wir auf die Einstellungswerte in den Activities zugreifen können. Bevor wir aber beginnen, noch ein kurzer Hinweis zum Thema API Version. Bei den Settings haben wir zwei Optionen entweder wir gehen auf ein API Level < 11, dann müssen wir auf Methoden zurückgreifen, welche als deprecated geflagged wurden, oder man geht auf API Level >= 11, dann hat man die Möglichkeit auf neue Methoden zu gehen, welche nicht als deprecated eingestuft wurden. Im Wesentlichen hat man sich entschieden, die gesamte Struktur der Settings in Zukunft auf Fragments aufzubauen, und das bis dato übliche Verfahren, das Settings Designt direkt in einer Activity laufen zu lassen langsam aus den Apps herauszudrängen. Nach langem Überlegen habe ich mich nun dafür entschieden, mich auf die neue Technologie zu konzentrieren und die Version ab API Level 11 zu erklären, da die Anzahl der alten Geräte langsam nicht mehr relevant ist. Leider muss man hier diese Entscheidung treffen, da die Support Library das Thema PreferenceFragment nicht berücksichtigt. Wer trotzdem sich die old school Variante ansehen möchte, sei auf folgenden Link verwiesen: In diesem Dokument werden wir uns mit den grundlegendsten Techniken der Settings (oder auch Preferences ) beschäftigen. Die weiterführenden Themen in diesem Zusammenhang werden wir auf einen späteren Zeitpunkt schieben, da wir sonst den Orangegurt überladen würden. Noch ein Hinweis zum Thema Design Guidelines. Android hat ein paar sinnvolle Anmerkungen zusammengefasst, wie man Setting Dialoge ansprechend designen soll. Diese findet ihr hier: 2 Der Grundgedanke Der Dialog, in dem die Settings vorgenommen werden, ist erst mal nichts anderes, als eine Activity. Wir werden uns aufgrund der Oben genannten Gründe auf die Activity mit den Fragments konzentrieren wir verwenden PreferenceFragment. Der Grund, warum wir nicht einfach normale Fragments verwenden können liegt in der Tatsache, dass die Preferences in einem gesonderten File abgelegt werden, welches von überall unserer App gelesen werden kann. Hinzu kommt, dass dieses File beim Neustart unserer App neu gelesen wird und somit die alten Einstellungen wieder hergestellt werden. Wir müssen also unsere Einstellungen nicht jedes Mal auf s Neue eingeben. Wie das File heißt und wo es liegt ist für uns als Entwickler erst mal nicht wichtig Android wird sich um alles kümmern. Da das Design für die Preferences immer einheitlich ist, wurde das File in dem die gewünschten Settingswerte enthalten sind und das File, welches für das Layout zuständig ist, zusammengefasst in ein einziges XML File. Wir werden uns in diesem Dokument im Wesentlichen die Möglichkeiten ansehen, welche verschiedenen Einstellungen wir in diesem File machen können. Auch der Zugriff auf die Settings sollte bei allen Apps einigermaßen einheitlich sein. Üblicherweise wird über das OptionsMenu der Dialog zum Einstellen der Settings aufgerufen. Auch dieses Thema werden wir hier behandeln wenngleich wir das OptionsMenu erst mal nur für die Settings betrachten und nicht für die weiteren Möglichkeiten. Auch das werden wir auf später verschieben. Seite 2

3 3 Das erste Beispiel Wir werden nun eine kleine App schreiben, bei der wir einen Settings Dialog realisieren. Vorerst werden wir die Funktionalität recht schmal halten. Wir werden in der MainActivity lediglich ein TextView Element haben, welches anzeigt, ob in den Settings unsere einzige vorhandene Checkbox selektiert ist, oder nicht. 3.1 Das Layout der MainActivity Wir sind inzwischen ja geübt, neue Projekte zu erzeugen. Wir schaffen ein Projekt namens SettingsTest und fügen dort eine MainActivity ein. Diese beinhaltet lediglich eine TextView. Hier das Layout unserer MainActivity (activity_main.xml): <RelativeLayout xmlns:android=" xmlns:tools=" android:layout_width="match_parent" android:layout_height="match_parent" tools:context=".mainactivity" > <TextView android:layout_width="wrap_content" android:layout_height="wrap_content" android:layout_centerhorizontal="true" android:layout_centervertical="true" /> </RelativeLayout> Wie ihr seht ist das nichts Weltbewegendes. Wir haben dem TextView auch nur einen Leerstring zugewiesen (der natürlich in strings.xml auch eingetragen werden muss),da wir den Inhalt unseres TextViews aus den Settings übernehmen müssen. 3.2 Die Settings Activity Wie wir Oben beschrieben haben, werden wir unsere Settings in einer eigenen Activity einbetten, welche das PreferenceFragment beherbergt. Um diese Activity zu erzeugen, müssen wir eine neue Klasse erstellen und sie von der Acitivty Klasse ableiten. Hierbei rufen wir in der oncreate Methode oncreate der Superklasse auf und instanziieren unser Fragment MySettingsFragment als zentraler Inhalt (android.r.id.content das ist eine StandardID für den Inhalt). Das Ganze passiert wie bei Fragments üblich über den FragmentManager (wir erinnern uns wenn wir ab API Level 11 Fragments umsetzen, brauchen wir den getfragmentmanager und nicht den getsupportfragmentmanager): public class MySettingsActivity extends Activity { Seite 3

4 protected void oncreate(bundle savedinstancestate) { super.oncreate(savedinstancestate); getfragmentmanager().begintransaction().replace( android.r.id.content, new MySettingsFragment()).commit(); Wichtig ist nun noch, dass wir die neue Activity Klasse im Manifest File AnroidManifest.xml registrieren, indem wir im Tag <application> am Ende folgende Konfiguration einfügen: <activity android:name="com.example.settingstest.mysettingsactivity" android:label="@string/title_mysettingsactivity_main" > </activity> Eclipse wird nun monieren, dass die Klasse MySettingsFragment noch nicht existiert diese werden wir nun nachreichen. 3.3 Das Settings Fragment Der eigentliche Inhalt der Activity wird über ein Fragment dargestellt. Die Besonderheit hier ist, dass wir hier kein normales Fragment verwenden, sondern ein PreferenceFragment. Dieses benötigt kein übliches Layout als Parameter, sondern ein preferneces Layout, welches wir uns im nächsten Kapitel näher ansehen werden. Dort werden wir für unsere Checkbox in dem Preferences Dialog noch einen Namen (eigentlich Key ) festlegen er soll pref_test heißen. Um im Programm später darauf zugreifen zu können definieren wir hier eine Konstante, welche diesen Namen beinhaltet. public class MySettingsFragment extends PreferenceFragment { public static final String KEY_PREF_TEST = "pref_test"; public void oncreate(bundle savedinstancestate) { super.oncreate(savedinstancestate); addpreferencesfromresource(r.xml.preferences); 3.4 Das Preferences Layout Üblicherweise wird das Layout unseres PreferencesFragment in einem XML File abgelegt, welches sich im Ordner res/xml befindet und preferences.xml heißt. Wir legen also einen neuen Unterordner unter res an und nennen diesen xml. Hier tragen wir ein leeres XML File ein, welches wir wie folgt editieren: <?xml version="1.0" encoding="utf-8"?> <PreferenceScreen xmlns:android=" android"> <CheckBoxPreference android:key="pref_test" android:title="@string/pref_test_title" android:summary="@string/pref_test_summ" android:defaultvalue="true" /> </PreferenceScreen> Seite 4

5 Wir tragen also eine Checkbox ein, welche auf den Key pref_test hört. Weiterhin geben wir der Checkbox noch einen Titel das wird der groß geschriebene Text im Settings Dialog sein und eine Summary, was der kleinere Text sein wird. Der Titel bei uns soll My Settings sein und die Summary Do your Settings. Diese Strings müsst ihr natürlich noch in strings.xml eintragen. 3.5 Der Code der MainActivity In der MainActivity lassen wir nun alle Fäden zusammenlaufen. Die oncreate Methode habe ich nicht weiter angepasst das was Eclipse mir eingetragen hat ist OK. Die folgende Methode lassen wir zwar auch unangetastet, ich möchte sie aber an dieser Stelle mal kurz vorstellen. Die oncreateoptionsmenu ist die Methode, welche das Standardmenü erscheinen lässt. Diese Funktion wird bei vielen Android Geräten über die Taste links unten, bzw. wenn keine eigene Taste existiert im Bildschirm unterhalb des ActionMenü rechts oben gestartet. In diesem Standardmenü befindet sich im Regelfall der Settings Eintrag. Wenn diese Methode also existiert, dann können wir mit dem MenuInflater das Standardmenü auf unseren Bildschirm zaubern. public boolean oncreateoptionsmenu(menu menu) { getmenuinflater().inflate(r.menu.activity_main, menu); return true; Das Layout unseres Menüs finden wir unter res/menu im File activity_main.xml: <menu xmlns:android=" > <item android:id="@+id/menu_settings" android:orderincategory="100" android:showasaction="never" android:title="@string/menu_settings"/> </menu> Die einzelnen Bedeutungen der Einträge werden wir uns zu einem späteren Zeitpunkt ansehen, wichtig an dieser Stelle ist nur, dass wir hier ein Menü erzeugen, welches über den Menübutton zustande kommt. Man kann hier noch einen icon (also eine Grafik) reinhängen. Das ganze Thema Menü werde ich in die nächste Gürtelfarbe reinpacken, da wir hier wieder ein paar Dinge bezüglich API Level 11 beachten müssen und das den Orangegurt sprengen würde. Wer vorher sich schon schlau machen will, sei auf diese Links verwiesen: Jetzt haben wir zwar das (zugegebenermaßen sehr einfache) Layout festgelegt. Nun müssen wir nur noch dafür sorgen, dass das Menü auch angezeigt wird. Das erledigen wir über die Methode onoptionsitem- Selected : public boolean onoptionsitemselected(menuitem item) { switch (item.getitemid()) { case R.id.menu_settings: startsettings(); return true; default: return super.onoptionsitemselected(item); Da wir dem Settings Menüeintrag eine ID gegeben haben, können wir identifzieren, über welchen Eintrag die Methode aufgerufen wurde. Üblicherweise packen wir die ganze Funktionalität in eine Switch/Case An- Seite 5

6 weisung hinein, damit wir diesen Teil einfach erweitern können. Um das Settings Menü zu starten, habe ich eine eigene Methode spendiert. Hier starte ich wie sollte es anders sein den Settings Dialog mit Hilfe eines Intents: private void startsettings() { Intent intent = new Intent(); intent.setclass(mainactivity.this, MySettingsActivity.class); startactivity(intent); Nun kommen wir zu der Methode, welche die Settingsinformationen auslesen und in die TextView einbauen soll. Da das Settings Menü unsere MainActivity in den Pausenstatus versetzen wird, können wir davon ausgehen, dass wenn wir aus den Settings wieder rauskommen, die Methode onresume aufgerufen wird. Dies ist also die ideale Stelle, die Settings auszulesen: protected void onresume() { super.onresume(); SharedPreferences sharedpref = PreferenceManager.getDefaultSharedPreferences(this); boolean preftestchecked = sharedpref.getboolean(mysettingsfragment.key_pref_test, false); TextView mytextview = (TextView) findviewbyid(r.id.settingstesttext); mytextview.settext(string.valueof(preftestchecked)); Wir rufen (natürlich) wieder die Methode der Superklasse auf, um die internen Vorgänge zu erlauben. Anschließen holen wir uns die SharedPreferences. Dies ist ein wichtiges Objekt, da es uns ermöglicht die Preferences zu speichern und wieder zu laden. Ich gehe im nächsten Kapitel nochmal kurz auf dieses Objekt ein. Danach hole ich mir die Information, ob die Checkbox in unserem Settings Dialog ausgewählt (checked) ist, oder nicht: SharedPreferences sharedpref = PreferenceManager.getDefaultSharedPreferences(this); boolean preftestchecked = sharedpref.getboolean(mysettingsfragment.key_pref_test, false); Der erste Parameter ist der Key-Wert unseres Settings. Sollten die Settings nicht gefunden worden sein, legen wir noch einen Defaultwert im zweiten Parameter fest ich habe mich hier für false entschieden. Die Information packe ich in eine Boolean Variable, welche ich im Anschluss lediglich in einen String konvertiere und in die TextView hineinschreibe. So, das war es auch schon. Nun können wir die App starten und das Menü aufrufen den Settings Dialog starten und die Checkbox auswählen. Wenn wir die Back Taste drücken sehen wir, dass das false sich nun zu einem true geändert hat. Wenn wir den Vorgang wiederholen und die Checkbox deselektieren, sehen wir wieder ein false. Interessant ist auch, dass wenn wir die App schließen und danach wieder neu starten, der Wert aus dem letzten Lauf der App wiedergefunden wird. Android hat es sich also gemerkt, was wir beim letzten Mal eingestellt haben wir müssen uns also nicht mühsam um irgendwelches Persistieren kümmern! 4 Das SharedPreferences Objekt Wie schon erwähnt, dient das SharedPreferences Objekt dazu, die Statuswerte zu speichern bzw. wieder zu laden. Dabei ist dieses Objekt sehr eng mit unserem PreferenceFragment verknüpft, so dass wir uns nicht um die Details der Persistierung kümmern müssen. Einstellungen im PreferenceFragment werden automatisch in unserem SharedPreferences Objekt und danach im Filesystem abgelegt. Dies kann man zwar mit dem Eintrag PreferenceScreen android:persistent="false" unterbinden, wobei sich dies nicht empfiehlt. Seite 6

7 4.1 Auslesen der Werte Weiterhin ist das SharedPreferences Objekt von jeder Stelle unserer App aufrufbar, da wir es von allen Activities mit Hilfe des PreferenceManager aufrufen können. Ein Aufruf (aus dem vorausgegangenen Kapitel) sieht wie folgt aus: SharedPreferences sharedpref = PreferenceManager.getDefaultSharedPreferences(this); boolean preftestchecked = sharedpref.getboolean(mysettingsfragment.key_pref_test, false); Wichtig ist, dass ihr die einzelnen Keys sauber pflegt und euch eine sinnvolle Namenskonvention überlegt, damit ihr später nicht durcheinander kommt. 4.2 Ändern der Werte Die Werte werden natürlich mit dem Settings Dialog geändert. Es gibt aber auch Möglichkeiten, die Settings programmatisch zu ändern. Da wie bei den Views auch alle XML basierten Elemente in Java Klassen münden, gibt es auch für die einzelnen Preferences Elemente Java Entsprechungen. Wenn wir also unsere Checkbox programmatisch auf true setzen wollen, dann müssen wir lediglich das zugehörige Java Objekt finden und dies auf den gewünschten Wert setzen: CheckBoxPreference checkboxpreftest = (CheckBoxPreference) this.findpreference(mysettingsfragment.key_pref_test); if (checkboxpreftest!= null) { checkboxpreftest.setchecked(true); Wir holen also einfach die Preferences und suchen dort den Preferencewert mit dem gegebenen Key. Wichtig ist, dass die Preferences nur im PreferenceFragment gefunden werden können. Wenn wir von der Activity aus die Settings ändern wollen, können wir mit einem Interface arbeiten, wie wir es bei den normalen Fragments ja bereits gesehen haben. 4.3 Einfügen neuer Werte In dem SharedPreferences Objekt können auch andere Werte abgelegt werden, welche nicht im Settings Dialog eingestellt werden. Dies kann sinnvoll sein, wenn interne Programmstatuswerte nicht verloren gehen dürfen. Hierfür benötigen wir einen Editor für die Preferences. Wir ergänzen unsere Activity wie folgt: public void ondestroy() { super.ondestroy(); SharedPreferences sharedpref = PreferenceManager.getDefaultSharedPreferences(this); SharedPreferences.Editor myeditor = sharedpref.edit(); myeditor.putstring(key_pref_dyn, "my dynamic value"); myeditor.commit(); Wir erzeugen uns einen Editor, indem wir mit der edit() Methode diesen Editor einer Variablen zuweisen. Dies startet auch automatisch eine Transaktion, welche wir am Ende mit commit() abschließen müssen. Mit Hilfe dieses Editors können wir nun einen neuen Wert eintragen. Ich habe mich für einen Stringwert entschieden, der einen eindeutigen Key-Wert benötigt, den wir in der Activity Klasse festlegen müssen: public static final String KEY_PREF_DYN = "pref_dynamic"; In der onresume Methode ergänzen wir unseren Code nun wie folgt wir lesen nach dem Checkbox Wert auch unseren neuen dynamischen Wert ein und schreiben anschließend nicht nur den boolschen Wert in unser Textfeld, sondern auch noch unseren dynamischen Settingswert: Seite 7

8 String prefdynvalue = sharedpref.getstring(key_pref_dyn, "empty"); mytextview.settext(string.valueof(preftestchecked) + " " + prefdynvalue); Wie ihr sehen werdet, wird unser TextView Element beim nächsten Starten unserer App den Text false empty anzeigen (sofern die Checkbox zuletzt deselektiert war), da wir den dynamischen Settingswert noch nicht eingetragen haben und somit der Defaultwert greift. Wenn wir allerdings die App beenden, wird on- Destroy aufgerufen und der dynamische Wert in die Settings eingetragen. Beim nächsten App Start wird nun der Wert gefunden und das TextView Element wird anzeigen false my dynamic value. Wir können folgende einfache Datentypen in unser SharedPreferences Objekt eintragen: Datentyp: boolean float int long String Set<String> Methode: putboolean(key, value); putfloat(key, value); putint(key, value); putlong(key, value); putstring(key, value); putstringset(key, value); Set ist eine Sammlung von Strings, welche wie folgt instanziiert wird: Set<String> set = new HashSet<String>(); Im set können nun mit add Werte eingetragen werden, welche wir als entsprechende Liste im SharedPreferences Objekt speichern und wieder herauslesen können. Beim Lesen können wir aus dem HashSet ein Array erzeugen. 4.4 Listener für geänderte Werte Der letzte Punkt für unser SharedPreference Objekt ist der OnSharedPreferenceChangeListener. Dieser wird aktiv, wenn ein Setting geändert wurde. Folgende Funktionalität soll dies verdeutlichen wenn unsere Checkbox selektiert ist, soll ein anderer Summarytext angezeigt werden, als wenn sie nicht selektiert ist. Wir definieren zuerst unsere Strings im strings.xml: <string name="pref_test_summ">check for displaying true</string> <string name="pref_test_summ_checked"> Uncheck for displaying false</string> Danach implementieren wir den Listener in unser MySettingsFragment: public class MySettingsFragment extends PreferenceFragment implements OnSharedPreferenceChangeListener { public void onsharedpreferencechanged(sharedpreferences sharedpreferences, String key) { if (key.equals(key_pref_test)) { setsummarytext( (CheckBoxPreference)findPreference(KEY_PREF_TEST)); Die Methode onsharedpreferencechanged wird wie immer von Eclipse per Mausklick implementiert. Wir ergänzen lediglich den Code, der für den Tausch des SummaryTexts zuständig ist. Diesen habe ich in eine eigene Methode eingefügt, welche sich um die Anzeige des richtigen Texts kümmert. Damit wir auch beim Seite 8

9 erstmaligen Aufruf des Settings Dialogs den richtigen Text zu sehen bekommen, rufen wir diese Methode auch beim oncreate auf: public void oncreate(bundle savedinstancestate) { super.oncreate(savedinstancestate); addpreferencesfromresource(r.xml.preferences); setsummarytext((checkboxpreference)findpreference(key_pref_test)); Die Methode ist relativ einfach gestrickt und sollte uns keine Probleme bereiten: private void setsummarytext(checkboxpreference mycheckbox) { if (mycheckbox!= null) { if (mycheckbox.ischecked()){ mycheckbox.setsummary(r.string.pref_test_summ_checked); else { mycheckbox.setsummary(r.string.pref_test_summ); Es wird zuerst geprüft, ob der Aufrufer das Preference Element auch wirklich gefunden hat. Anschließend wird geprüft, ob die Checkbox selektiert ist und demensprechend wird der richtige String als Summary eingesetzt. Was nun noch fehlt ist, den Listener zu registrieren. Da wir diesen Listener wirklich nur dann brauchen, wenn wir aktiv mit dem Settings Dialog arbeiten, registrieren wir ihn in der onresume Methode und entfernen ihn wieder in der onpause Methode: public void onresume() { super.onresume(); getpreferencescreen().getsharedpreferences(). registeronsharedpreferencechangelistener(this); public void onpause() { super.onpause(); getpreferencescreen().getsharedpreferences(). unregisteronsharedpreferencechangelistener(this); 5 Die einzelnen Preference Elemente Nun haben wir die wichtigsten Elemente kennengelernt, um die Settings in unser Programm einzubauen, wobei wir als Beispiel eine Checkbox verwendet haben. Wir wollen uns in den nächsten Kapiteln eine Auswahl an möglichen anderen Settings Elementen ansehen und die wichtigsten Einstellungen. 5.1 Grundeinstellungen Zuerst kommt natürlich der key Eintrag, ohne den wir keinen eindeutigen Zugriff auf unsere Preferences haben. Es empfiehlt sich auch für jeden Settings Eintrag einen Default Value zu setzen, was im Prinzip der Anfangszustand ist. Weiterhin kennt jedes Element zumindest die beiden Werte Title und Summary. Title ist die im großen Text geschriebene Überschrift und die Summary die etwas kleiner geschriebene Zusammenfassung unterhalb der Überschrift. Seite 9

10 Den Code dazu haben wir weiter Oben schon kennengelernt der Vollständigkeit halber hier nochmal die XML Definition im preferences.xml File: <CheckBoxPreference android:key="pref_test" android:defaultvalue="true" /> Zusätzlich ist es manchmal noch sinnvoll eine Grafik mit einzubinden. Dies erfolgt über das icon Attribut: Der Einfachheit halber habe ich hier das Drawable ic_launcher genommen, da es standardmäßig von Eclipse bereits eingefügt wurde. 5.2 Enable / Disable von Settings Settingelemente können aktiviert und deaktiviert sein. Dies kann man mit zweierlei Methoden ermöglichen. Zuerst die einfachere die Abhängigkeiten. Es gibt gewisse Settings, welche nur dann sinnvoll gesetzt werden können, wen ein anderes Setting auf true steht. Zur Verdeutlichung ergänzen wir unser preferences.xml File wie folgt: <CheckBoxPreference android:key="pref_test" android:title="@string/pref_test_title" android:summary="@string/pref_test_summ" android:defaultvalue="true" android:icon="@drawable/ic_launcher"/> <CheckBoxPreference android:key="pref_test2" android:title="@string/pref_test_title" android:summary="@string/pref_test_summ" android:defaultvalue="true" android:dependency="pref_test"/> Wichtig ist hier der Eintrag android:dependency="pref_test". Wir geben hier an, dass es eine Abhängigkeit zwischen dem pref_test2 und dem pref_test gibt und zwar wird dies dergestalt interpretiert, dass pref_test2 nur dann aktiv ist, wenn pref_test ausgewählt ist. Sobalt pref_test keinen Haken mehr hat, ist pref_test2 inaktiv. Eine zweite Möglichkeit ist es, die Elemente programmatisch zu aktivieren, bzw. deaktivieren. Wie wir eine Referenz auf die Checkbox bekommen haben wir in den Oberen Kapiteln gesehen. Deaktivieren können wir das Element wie folgt: mycheckbox.setenabled(false); Wenn wir den Status auf Aktiv setzen wollen, dann müssen wir als Parameter lediglich true setzen. Wir können auch programmatisch feststellen, ob das Element aktiv ist: mycheckbox.isenabled() 5.3 CheckBoxPreference Wie wir in den oberen Beispielen schon gesehen haben, ist die CheckBoxPreference recht einfach umsetzbar. Den XML Code werde ich an dieser Stelle nicht nochmal wiederholen, einfach im vorausgehenden Kapitel nochmal reinschauen. Die wichtigsten Java Methoden haben wir auch schon gesehen. Hier möchte ich jedoch die zwei wichtigsten kurz ansprechen: Seite 10

11 Methode:.isChecked().setChecked(value) Beschreibung: Liefert true zurück, wenn die Checkbox selektiert ist, sonst false Wenn value auf true steht, wird die Checkbox selektiert, wenn value auf false steht, wird sie deselektiert. Alle weiteren Methoden können unter folgenden Links ersehen werden: SwitchPreference Die SwitchPreference ist prinzipiell nichts anderes als eine Checkbox, nur dass sie optisch anders dargestellt ist. In den Java Klassen kann man dies daran erkennen, dass beide eine Ableitung der Klasse TwoStatePreference sind. Der Code sieht entsprechend einfach aus: <SwitchPreference android:key="pref_test3" android:defaultvalue="true" /> Die beiden Elemente switchtexton und switchtextoff sind optional. Wenn sie nicht vorhanden sind, wird der Text des Schiebers On und Off sein. Mit diesen beiden Elementen können wir den Text sprachlich individualisieren. Die Methoden der Java Klasse sind identisch mit denen der Checkbox: Methode:.isChecked().setChecked(value) Beschreibung: Liefert true zurück, wenn die Checkbox selektiert ist, sonst false Wenn value auf true steht, wird die Checkbox selektiert, wenn value auf false steht, wird sie deselektiert. Auch hier findet ihr die notwendigen zusätzlichen Infos im Netz: Alle weiteren Methoden können unter folgenden Links ersehen werden: Wer es ganz indiviuell haben möchte, kann sich die View, welche mit dem Switch verbunden ist auch individuell zusammenbauen und über das Attribut android:layout auch laden. Da dies hier aber zu weit führen würde, muss ich an dieser Stelle lediglich auf die API verweisen. 5.5 ListPreference Ein auch recht häufig anzutreffendes Element bei den Settings ist die ListPreference. Dies ist im Wesentlichen ein Feld von Radio Buttons. Dieses öffnet sich als Subdialog und listet alle vorher definierten Werte auf. Diese müssen aber zuvor definiert werden. Dies geschieht in einem String Array, welche auch in einem Array festgelegt werden können. Hierzu erzeugen wir im Ordner res/values das File array.xml und schreiben folgendes rein: <?xml version="1.0" encoding="utf-8"?> <resources> <string-array name="pref_list_example_disp"> <item>wert A</item> <item>wert B</item> Seite 11

12 <item>wert C</item> </string-array> <string-array name="pref_list_example_values"> <item>0</item> <item>1</item> <item>2</item> </string-array> </resources> Wir haben somit zwei verschiedene String Arrays geschaffen. Das erste ist für die Anzeige der Werte im Dialog (wenn wir mehrsprachig arbeiten, so muss dieser Bereich entsprechend in die sprachspezifischen Unterordner wir erinnern uns an den Gelbgurt). Das zweite Array steht für die Werte, welche beim Auswählen hinterlegt werden. Dies muss für eine saubere Sprachunabhängigkeit gewährleistet sein! Weiterhin müssen wir nun unser strings.xml File mit folgenden Werten ergänzen: <string name="pref_list_default">2</string> <string name="pref_list_title">select values</string> <string name="pref_list_summ">click for opening the dialog</string> Hier finden wir die Werte für unseren Titel und der Summary. Was wir hier auch hinterlegen ist der Defaultwert, welcher nicht der Anzeigewert, sondern der hinterlegte, sprachunabhängige Wert sein muss. In unserem preferences.xml File fügen wir das Element nun ein;: <ListPreference android:key="pref_list_example" Wie wir sehen, fügen wir neben den üblichen Attributen nun die Einträge als Referenzen auf unsere neu erzeugten Arrays ein dies gilt für unser Anzeigewerte (android:entries), als auch für unsere hinterlegten Werte (android:entryvalues). Der sich öffnende Dialog kann noch weiter konfiguriert werden, wobei ich an dieser Stelle hierauf nicht weiter eingehen möchte. Hier noch die wichtigsten Methoden: Methode: Beschreibung:.getEntryValues() Liefert ein Array von CharSequence Werten, welche die Werte des entryvalues Array beinhaltet..findindexofvalue(value) Gibt die Indexposition des gegebenen Wertes (entsprechend des Arrays aus getentryvalues)..getvalue().setvalue(value) Gibt den Wert aus, der gerade ausgewählt ist. Setzt den Wert, der gerade ausgewählt ist auf value, wobei dieser Teil des Arrays aus getentryvalues sein muss. Alle weiteren Infos, wie immer im Netz: Seite 12

13 5.6 EditTextPreference Das letzte Element in dieser Reihe welches ich besprechen möchte ist das EditTextPreference Element. Es ist zwar relativ selten, dass man wirklich Texteingaben machen möchte, aber hin und wieder kommt man hier nicht drum rum. Prinzipiell ist das EditTextPreference Feld genauso zu nutzen wie eine Kombination eines EditText Views und einer normalen Preference View. Um dies zu verdeutlichen setzen wir mal ein Edit- TextPreference um, welches nur Ziffern akzeptiert. Zuerst erweitern wir die strings.xml: <string name="pref_text_default">15</string> <string name="pref_text_title">enter number</string> <string name="pref_text_summ">click for opening the dialog</string> Danach fügen wir in preferences.xml folgenden Eintrag ein: <EditTextPreference android:key="pref_edittext_test" android:inputtype="number"/> Wie wir sehen, können wir auch hier einen inputtype vorgeben. Die Javamethoden sind ebenfalls keine Überraschung. Methode:.getText().setText(value) Beschreibung: Liefert den eingegebenen Text zurück. Belegt den eingegebenen Text neu mit dem Wert value. Weitere Details findet ihr unter Submenü Wenn zu viele Settings in einem Dialog vorgesehen sind empfiehlt es sich, diesen aufzuteilen. Die einfachste Möglichkeit bietet das Einsetzen eines weiteren PreferenceScreens. Dieser wird lediglich in den bereits existierenden PreferenceScreen eingebettet: <?xml version="1.0" encoding="utf-8"?> <PreferenceScreen xmlns:android=" <CheckBoxPreference android:key="pref_test" android:defaultvalue="true"/> <PreferenceScreen android:key="pref_subscreen" <SwitchPreference android:key="pref_test3" </PreferenceScreen> </PreferenceScreen> Seite 13

14 Wie ihr seht, bekommt der innere PreferenceScreen auch einen Titel und eine Summary. Ansonsten wird der innere PreferencesScreen genauso gehandhabt, wie der äußere es können beliebige Elemente eingefügt werden. Wenn ihr die App startet, dann werdet ihr die altbekannte Checkbox sehen und einen weiteren Eintrag. Wenn ihr auf diesen Klickt, dann öffnet sich der Subscreen und ihr seht dort die inneren Elemente (in unserem Fall nur das SwitchPreferences Element. Seite 14

15 6 Lizenz Diese(s) Werk bzw. Inhalt von Maik Aicher ( steht unter einer Creative Commons Namensnennung - Nicht-kommerziell - Weitergabe unter gleichen Bedingungen 3.0 Unported Lizenz. The Android robot is reproduced or modified from work created and shared by Google and used according to terms described in the Creative Commons 3.0 Attribution License. Eclipse and the Eclipse Logo are trademarks of Eclipse Foundation, Inc. "Oracle and Java are registered trademarks of Oracle and/or its affiliates. Other names may be trademarks of their respective owners." 7 Haftung Ich übernehme keinerlei Haftung für die Richtigkeit der hier gemachten Angaben. Sollten Fehler in dem Dokument enthalten sein, würde ich mich über eine kurze Info unter [email protected] freuen. Seite 15