So codieren Sie einen Einstellungsbildschirm in einer Android-App

German (Deutsch) translation by Tatsiana Bochkareva (you can also view the original English article)

Final product image — What You'll Be Creating

Das Materialdesign-Team von Google gibt eine klare Definition der Einstellungen in Ihrer Android-App:

App-Einstellungen ermöglichen es Benutzern, Präferenzen für das Verhalten einer App anzugeben.

Sie bei Google geben auch an, dass Ihre Benutzer entweder über die seitliche Navigation oder das Symbolleistenmenü zu den App-Einstellungen navigieren sollten – mit einem Element mit der Bezeichnung Einstellungen.

Durch das Einfügen von Einstellungen in Ihre App können Ihre Benutzer einige der Funktionen Ihrer App steuern. Das macht Ihre Benutzer glücklich statt wütend – denn sie haben jetzt die Kontrolle darüber, wie sich die App verhält.

Es wird dringend empfohlen, den Zugriff auf die App-Einstellungen zu gewähren. Dies bietet Ihren Nutzern eine bessere Benutzererfahrung, was zu einer besseren Bewertung im Google Play Store führt, was schließlich zu einer höheren Anzahl von App-Downloads führt (was den Umsatz steigert).

Ich gehe davon aus, dass Sie mit den Einstellungen einer App auf Ihrem Gerät interagiert haben, beispielsweise indem Sie einen Standardklingelton ausgewählt oder Ihre Privatsphäre in der App kontrolliert haben. Fast alle der beliebtesten Apps, die Sie im Google Play Store heruntergeladen haben oder herunterladen werden, enthalten einen Einstellungsbildschirm, mit dem Sie das Verhalten der Anwendung steuern können.

Ein Beispiel für eine beliebte App mit einem Einstellungsbildschirm ist die Chrome Android App von Google. Im Einstellungsbildschirm dieser App können Benutzer die Standardsuchmaschine auswählen, das Benachrichtigungsverhalten ändern, die Privatsphäre der Benutzer steuern usw. Sie können dies selbst sehen, indem Sie die Chrome-App aus dem Google Play Store herunterladen (falls Sie sie noch nicht auf Ihrem Gerät haben). Der folgende Screenshot stammt aus der Chrome-App und zeigt den Einstellungsbildschirm der App an.

Screenshot of Chrome app settings screen

In diesem Beitrag erfahren Sie, wie Sie einen App-Einstellungsbildschirm von Grund auf neu erstellen und die Werte lesen, die der Benutzer aus den App-Einstellungen ausgewählt hat. Als zusätzlichen Bonus erfahren Sie auch, wie Sie die Android Studio-Vorlagenfunktion verwenden, um Ihr Projekt mit einem Einstellungsbildschirm schnell zu booten.

Ein Beispielprojekt (in Kotlin) für dieses Tutorial finden Sie in unserem GitHub-Repository, damit Sie es leicht verfolgen können.

Voraussetzungen

Um diesem Tutorial folgen zu können, benötigen Sie:

Ein grundlegendes Verständnis einiger Android-APIs (wie SharedPreferences)
Android Studio 3.0 oder höher
Kotlin-Plugin 1.1.51 oder höher

1. Erstellen Sie ein Android Studio-Projekt

Starten Sie Android Studio und erstellen Sie ein neues Projekt (Sie können es SettingsScreenDemo nennen) mit einer leeren Aktivität namens SettingsActivity. Stellen Sie sicher, dass Sie auch das Kontrollkästchen Kotlin-Unterstützung einschließen aktivieren.

2. Erstellen eines `PreferenceFragment`

Um API Level 11 (Honeycomb) und höher zu unterstützen, können wir das PreferenceFragment verwenden. Diese Klasse ist einfach ein Fragment, das eine Hierarchie von Preference-Objekten als Listen anzeigt.

import android.os.Bundle
import android.preference.PreferenceFragment
import android.support.v7.app.AppCompatActivity

class SettingsActivity : AppCompatActivity() {

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)

        if (fragmentManager.findFragmentById(android.R.id.content) == null) {
            fragmentManager.beginTransaction()
                    .add(android.R.id.content, SettingsFragment()).commit()
        }
    }


    class SettingsFragment : PreferenceFragment() {
        override fun onCreate(savedInstanceState: Bundle?) {
            super.onCreate(savedInstanceState)
            addPreferencesFromResource(R.xml.preferences)
        }
    }
}

Im obigen Code haben wir eine verschachtelte Klasse SettingsFragment in SettingsActivity erstellt (da die SetttingsFragment-Klasse so klein ist). Beachten Sie, dass unsere Klasse SettingsFragment die Superklasse PreferenceFragment erweitert und eine Methode addPrerenceFromResource innerhalb von onCreate() hat. In dieser Methode haben wir ihr die Ressourcen-ID R.xml.preference der XML-Präferenz zum Starten gegeben – wenn das Fragment geladen wird. Schließlich hosten wir das Fragment für die Aktivität, indem wir einfach die FragmentTransaction verwenden, um es der Benutzeroberfläche hinzuzufügen – innerhalb von onCreate() von SettingsActivity.

3. Unsere Präferenzen erstellen

Erstellen Sie eine XML-Datei und nennen Sie sie preferences.xml. Speichern Sie diese Datei im Verzeichnis res/xml in Ihrem App-Projekt. Beachten Sie, dass Sie dieser Datei einen beliebigen Namen geben können, es wird jedoch dringend empfohlen, bei den herkömmlichen Namen "Einstellungen" zu bleiben. Außerdem sollten Sie in einem App-Projekt normalerweise nur eine solche Datei haben.

<?xml version="1.0" encoding="utf-8"?>
<PreferenceScreen xmlns:android="https://schemas.android.com/apk/res/android">
    <CheckBoxPreference
            android:key="checkbox"
            android:summary="Tap to check if on or off"
            android:title="Checkbox Preference" />
    <RingtonePreference
            android:key="ringtone"
            android:showDefault="true"
            android:showSilent="true"
            android:summary="Pick a ringtone you like"
            android:title="Ringtone Preference" />
    <EditTextPreference
            android:dialogTitle="Enter a text"
            android:key="text"
            android:summary="Click to show a text entry dialog"
            android:title="EditText Preference" />
    <ListPreference
            android:dialogTitle="Select duration"
            android:entries="@array/settings_list_preference_titles"
            android:entryValues="@array/settings_list_preference_values"
            android:key="list"
            android:summary="Click to show a list to choose from"
            android:title="List Preference" />
    <SwitchPreference
            android:key="switch"
            android:title="Switch Preference"
            android:summary="Click to switch on or off"
            android:defaultValue="true"/>
</PreferenceScreen>

Der Root-Knoten für unsere Datei preferences.xml sollte ein <PreferenceScreen>-Element sein. Innerhalb dieses Wurzelelements haben wir jetzt unsere individuelle Preference. Hier sind die allgemeinen Attribute, die einer Preference zugeordnet sind:

android:key: Dieses Attribut wird verwendet, um den Wert im SharedPreferences-Objekt zu erhalten.
android:title: Legt den Titel für die Preference fest. Dies ist der fett gedruckte Text.
android:summary: legt die Zusammenfassung für die Preference fest (dies ist nicht erforderlich). Dies ist der verblasste Text unter dem Titel.
android:defaultValue: legt den Standardwert für die Preference fest.

Wir werden jede der oben definierten Preference in Kürze durchgehen. Beachten Sie, dass Sie eine Einstellung auch über den Preference von Android Studio hinzufügen oder anpassen können – ähnlich dem Layout-Ressourcen-Editor, mit dem Sie bereits vertraut sind. Sie können Ihre bevorzugte XML-Datei entweder direkt im "Text"-Modus hinzufügen/bearbeiten oder die Drag-and-Drop-Benutzeroberfläche im "Design"-Modus verwenden.

Wie Sie sehen, können Sie in diesem Editor jede Preference in den Palettenbereich (auf der linken Seite) ziehen und ablegen. Nach dem Ablegen sollten Sie es auswählen und seine Attribute im Attributbereich (auf der rechten Seite) des Editors ändern. Beachten Sie, dass wir standardmäßig einige Attribute zum Ändern erhalten. Um alle Attribute anzuzeigen oder zu ändern, die einer ausgewählten Preference zugeordnet sind, stellen Sie sicher, dass Sie unten im Attributbereich auf den Link Alle Attribute anzeigen klicken. Dies ist dem Layout-Editor, den Sie bereits kennen, sehr ähnlich.

Lassen Sie uns nun jede der Preference-Entitäten durchgehen, die wir haben.

Kontrollkästchen-Präferenz

Eine CheckBoxPreference ist einfach ein CheckBox-Widget, das im Einstellungsbildschirm enthalten ist. Diese Preference gibt den Wert "true" zurück, wenn sie aktiviert ist, oder "false" andernfalls. Mit anderen Worten, es gibt abhängig vom Status des Widgets einen booleschen Wert zurück.

1	<CheckBoxPreference
2	android:key="checkbox"
3	android:summary="Tap to check if on or off"
4	android:title="Checkbox Preference" />

Andere Attribute, die Sie zu einer CheckBoxPreference hinzufügen können, sind:

android:summaryOff: legt die Zusammenfassung für die Preference in einem Einstellungsbildschirm fest, wenn sie nicht markiert ist.
android:summaryOn: legt die Zusammenfassung für die Preference in einem Einstellungsbildschirm fest, wenn sie aktiviert ist.
android:disableDependentsState: Der Zustand (true für on oder false für off), der bewirkt, dass abhängige Personen deaktiviert werden. Kann ein boolescher Wert sein, z. B. "true" oder "false".

Schalterpräferenz

SwitchPreference führt ähnliche Funktionen wie CheckBoxPreference aus. Es bietet eine umschaltbare Option mit zwei Zuständen ("ein" oder "aus"). Dies verwendet ein Switch-Widget, mit dem der Benutzer nach links ("aus") und nach rechts ("ein") gleiten kann. Diese Preference enthält auch die oben für die CheckBoxPreference beschriebenen Attribute. Darüber hinaus hat es die folgenden Attribute:

android:switchTextOff: Setzt den Text, der auf dem Schalter selbst verwendet wird, wenn er sich im "Aus"-Zustand befindet.
android:switchTextOn: Setzt den Text, der auf dem Schalter selbst verwendet wird, wenn er sich im "on"-Zustand befindet.

<SwitchPreference
            android:key="switch"
            android:title="Switch Preference"
            android:summary="Click to switch on or off"
            android:defaultValue="true"/>

EditText-Präferenz

Wenn diese Preference angeklickt wird, wird ein Dialogfeld angezeigt, in dem der Benutzer einen Eingabetext eingeben kann. Es verwendet das EditText-Widget – einschließlich aller Attribute dieses Widgets, mit denen Sie bereits vertraut sind.

<EditTextPreference
            android:dialogTitle="Enter a text"
            android:key="text"
            android:summary="Click to show a text entry dialog"
            android:title="EditText Preference"
            android:inputType="text"/>

Beachten Sie, dass der in den SharedPreferences gespeicherte Wert eine Zeichenfolge ist.

Listenpräferenz

Diese Art von Preference zeigt beim Antippen eine Liste von Einträgen in einem Dialogfeld an. Hier können Sie ein Paar von String-Array-Ressourcen in Ihrem bevorzugten XML angeben. Diese String-Array-Ressource enthält einfach eine Sammlung von Strings. Diese Ressource befindet sich unter res/values/arrays.xml.

<?xml version="1.0" encoding="utf-8"?>
<resources>
    <string-array name="settings_list_preference_titles">
        <item>15 minutes</item>
        <item>30 minutes</item>
        <item>1 hour</item>
        <item>3 hours</item>
        <item>6 hours</item>
        <item>Never</item>
    </string-array>
    <string-array name="settings_list_preference_values">
        <item>15</item>
        <item>30</item>
        <item>60</item>
        <item>180</item>
        <item>360</item>
        <item>-1</item>
    </string-array>
</resources>

Hier ist unser Beispiel für ListPreference, das diese Ressource verwendet.

<ListPreference
        android:dialogTitle="Select duration"
        android:entries="@array/settings_list_preference_titles"
        android:entryValues="@array/settings_list_preference_values"
        android:key="list"
        android:summary="Click to show a list to choose from"
        android:title="List Preference" />

Wir legen die Einträge und Eintragswerte mit den Attributen android:entries bzw. android:entryValues fest.

android:entries: das für Menschen lesbare Array, das als Liste dargestellt werden soll.
android:entryValues: das Array, um den Wert zu finden, der für eine Voreinstellung gespeichert werden soll, wenn ein Eintrag aus Einträgen ausgewählt wird.

Wenn wir beispielsweise die Anzahl der Minuten in jeder Dauer als Eingabewerte verwenden, wenn der Benutzer eine Zeitdauer auswählt (z. B. 30 Minuten), wird der entsprechende ganzzahlige Wert in SharedPreferences (z. B. 30) gespeichert.

MultiSelect-Listen-Präferenz

Dieser ähnelt ListPreference, hat jedoch keine Optionsfelder, sondern Kontrollkästchen. Mit anderen Worten, der Benutzer kann mehrere Elemente im Dialog auswählen. Beachten Sie, dass das Ergebnis in einem „String-Set“ in den SharedPreferences gespeichert wird. Dies kann mit getStringSet() abgerufen werden.

<MultiSelectListPreference
            android:dialogTitle="Dialog title"
            android:entries="@array/settings_multi_select_list_preference_titles"
            android:entryValues="@array/settings_multi_select_list_preference_values"
            android:key="multi_select_list"
            android:title="Multiselect title" />

Klingelton-Präferenz

Wenn eine RingtonePreference angetippt wird, wird ein Dialogfeld mit der Liste der verfügbaren Klingeltöne auf dem Gerät oder Emulator angezeigt.

<RingtonePreference
            android:key="ringtone"
            android:showDefault="true"
            android:showSilent="true"
            android:summary="Pick a ringtone you like"
            android:title="Ringtone Preference" />

android:showDefault: Ob die Option Standardklingelton angezeigt wird.
android:showSilent: Ob eine Silent-Option in der Liste angezeigt wird. Der Benutzer kann diese Option auswählen, wenn er keinen Klingelton abspielen möchte.

Beachten Sie, dass der in den SharedPreferences gespeicherte Wert für diese Einstellung eine spezielle Zeichenfolge ist. Dieser spezielle String ist ein URI, der auf einen ContentProvider zeigt.

4. Erstellen von Einstellungsgruppen

Es wird zu einem Problem, wenn Sie eine lange Liste von Einstellungen oder Einstellungen haben, da Benutzer möglicherweise Probleme haben, diese zu scannen oder zu verstehen. Um dieses Problem zu lösen, können wir unsere Präferenzen gruppieren. Sehen Sie sich noch einmal den Screenshot der Chrome-App an, die ich Ihnen am Anfang gezeigt habe. Beachten Sie, dass die Einstellungen in zwei Kategorien unterteilt sind: Grundlagen und Erweitert. Dies erleichtert es dem Benutzer, die Präferenzen zu verstehen und die Liste nicht zu überladen erscheinen zu lassen.

Schauen wir uns nun an, wie einfach es ist, diese Aufgabe auszuführen.

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

    <PreferenceCategory android:title="Basic Settings">
        <CheckBoxPreference
                android:key="checkbox"
                android:summary="Tap to check if on or off"
                android:title="Checkbox Preference"/>
        ...
    </PreferenceCategory>

    <PreferenceCategory android:title="Advanced Settings">
        <ListPreference
                android:dialogTitle="Select duration"
                android:entries="@array/settings_list_preference_titles"
                android:entryValues="@array/settings_list_preference_values"
                android:key="list"
                android:summary="Click to show a list to choose from"
                android:title="List Preference"/>
        ...
    </PreferenceCategory>
</PreferenceScreen>

Wir umgeben einfach die Einstellungen, die wir gruppieren möchten, in einem <PreferenceCategory>-Tag und geben jeder Gruppe einen Titel mit dem android:title-Attribut.

Preferences grouped with PreferenceCategory

5. Eine Absicht starten

Beachten Sie, dass es möglich ist, eine Aktivität zu öffnen, indem Sie einfach auf ein Einstellungselement im Einstellungsbildschirm klicken. Dies kann praktisch sein, wenn Sie eine Webseite öffnen möchten. Hier ist der Code, um das zu tun:

<Preference
        android:summary="Click to start an activity"
        android:title="Preference">
    <intent
            android:action="com.chikeandroid.settingsscreendemo.SETTING_START_ACTIVITY"
            android:targetClass="com.chikeandroid.settingsscreendemo.MyActivity"
            android:targetPackage="com.chikeandroid.settingsscreendemo" />
</Preference>

Hier haben wir ein <intent>-Element innerhalb des <Preference>-Elements hinzugefügt.

android:action: legt die Aktion für den Intent fest (dies ähnelt dem Aufrufen von setAction() für ein Intent-Objekt).
android:targetClass: legt den Klassenteil des Komponentennamens fest (wie der Aufruf von setComponent() für ein Intent-Objekt).
android:targetPackage: legt den Paketteil des Komponentennamens fest.
android:data: legt die zuzuweisenden Daten fest (wie der Aufruf von setData() für ein Intent-Objekt).

Um beispielsweise eine Webseite zu öffnen, können Sie Folgendes verwenden:

1	<Preference android:title="@string/prefs_web_page" >
2	<intent android:action="android.intent.action.VIEW"
3	android:data="http://www.example.com" />
4	</Preference>

6. Bindung der Präferenzübersicht an den ausgewählten Wert

Sehen wir uns nun an, wie Sie die Einstellungszusammenfassung mit dem vom Benutzer ausgewählten Wert aktualisieren.

class SettingsActivity : AppCompatActivity() {

    // ... 
    class SettingsFragment : PreferenceFragment() {
        override fun onCreate(savedInstanceState: Bundle?) {
            super.onCreate(savedInstanceState)
            addPreferencesFromResource(R.xml.preferences)

            bindPreferenceSummaryToValue(findPreference("ringtone"))
            bindPreferenceSummaryToValue(findPreference("text"))
            bindPreferenceSummaryToValue(findPreference("list"))
        }
    }
    // ... 
}

In dieser Klasse haben wir eine Hilfsmethode namens bindPreferenceSummaryToValue() erstellt, die sich in unserem Begleitobjekt befindet, um den Zusammenfassungstext der Einstellungen mit dem vom Benutzer ausgewählten Wert zu aktualisieren. Wir haben ihm ein Preference-Objekt als Argument übergeben. findPreference() gibt eine Preference zurück, die den Schlüssel der Preference verwendet.

class SettingsActivity : AppCompatActivity() {
    // ...
    companion object {
        
        /**
         * A preference value change listener that updates the preference's summary
         * to reflect its new value.
         */
        private val sBindPreferenceSummaryToValueListener = Preference.OnPreferenceChangeListener { preference, value ->

            val stringValue = value.toString()

            if (preference is ListPreference) {
                // For list preferences, look up the correct display value in
                // the preference's 'entries' list.
                val listPreference = preference
                val index = listPreference.findIndexOfValue(stringValue)

                // Set the summary to reflect the new value.
                preference.setSummary(
                        if (index >= 0)
                            listPreference.entries[index]
                        else
                            null)

            } else if (preference is RingtonePreference) {
                // For ringtone preferences, look up the correct display value
                // using RingtoneManager.
                if (TextUtils.isEmpty(stringValue)) {
                    // Empty values correspond to 'silent' (no ringtone).
                    preference.setSummary("Silent")

                } else {
                    val ringtone = RingtoneManager.getRingtone(
                            preference.getContext(), Uri.parse(stringValue))

                    if (ringtone == null) {
                        // Clear the summary if there was a lookup error.
                        preference.setSummary(null)
                    } else {
                        // Set the summary to reflect the new ringtone display
                        // name.
                        val name = ringtone.getTitle(preference.getContext())
                        preference.setSummary(name)
                    }
                }
            }
            else {
                // For all other preferences, set the summary to the value's
                // simple string representation.
                preference.summary = stringValue
            }
            true
        }

        private fun bindPreferenceSummaryToValue(preference: Preference) {
            // Set the listener to watch for value changes.
            preference.onPreferenceChangeListener = sBindPreferenceSummaryToValueListener

            // Trigger the listener immediately with the preference's
            // current value.
            sBindPreferenceSummaryToValueListener.onPreferenceChange(preference,
                    PreferenceManager
                            .getDefaultSharedPreferences(preference.context)
                            .getString(preference.key, ""))
        }
    }
}

Wir haben eine Variable sBindPreferenceSummaryToValueListener, die eine Instanz von Preference.OnPreferenceChangeListener ist. Dies ist einfach ein Einstellungsänderungs-Listener, der uns hilft, die Einstellungszusammenfassung auf den vom Benutzer ausgewählten Wert zu aktualisieren. Wir prüfen auf Sonderfälle, z. B. wenn die ausgewählte Einstellung eine RingtonePreference oder eine ListPreference ist. Für diese Einstellungstypen führen wir eine spezielle Behandlung durch, um die Zusammenfassungszeichenfolge zu erhalten. Wenn die Einstellung keines ist (wie eine EditTextPreference), setzen wir einfach die Zusammenfassung auf den Zeichenfolgenwert der Einstellung.

Innerhalb von bindPreferenceSummaryToValue() setzen wir den Einstellungsänderungs-Listener, indem wir onPreferenceChangeListener (in Java stattdessen setOnPreferenceChangeListener) für das Preference-Objekt aufrufen.

Führen Sie nun das Projekt erneut aus, um zu sehen, wie alles funktioniert!

Settings screen showing changed summary in response to selection

7. Abrufen von Präferenzwerten

Um mit dem Abrufen von Präferenzwerten für den Einstellungsbildschirm zu beginnen, rufen wir getDefaultSharedPreference() auf, das sich in der PreferenceManager-Klasse befindet, und übergeben ihr ein Context-Objekt der Präferenzen, deren Werte gesucht werden. Beachten Sie, dass wir die Werte aus den standardmäßigen SharedPreferences für unsere Anwendung abrufen.

val prefs = PreferenceManager.getDefaultSharedPreferences(this)
prefs.getBoolean("checkbox", false).toString()
prefs.getString("ringtone", "<unset>")
prefs.getString("text", "<unset>")
prefs.getString("list", "<unset>")

Sie rufen die entsprechende Getter-Methode für den Typ auf, von dem wir den Wert in SharedPreferences abrufen möchten. Sie übergeben ihm den Schlüssel als erstes Argument und der Standardwert ist das zweite Argument.

8. Bonus: Verwenden von Android Studio-Vorlagen

Nachdem Sie nun die erforderlichen APIs kennengelernt haben, um einen Einstellungsbildschirm in Android von Grund auf neu zu erstellen, zeige ich Ihnen eine Verknüpfung, die es beim nächsten Mal schneller macht. Sie können eine Vorlage verwenden, anstatt einen Einstellungsbildschirm von Grund auf neu zu programmieren.

Android Studio bietet Codevorlagen, die den Best Practices für Android-Design und -Entwicklung entsprechen. Diese vorhandenen Codevorlagen (verfügbar in Java und Kotlin) können Ihnen helfen, Ihr Projekt schnell zu starten. Eine solche Vorlage kann verwendet werden, um einen Einstellungsbildschirm zu erstellen.

Um diese praktische Funktion für ein neues Projekt zu verwenden, starten Sie zuerst Android Studio.

Android Studios Create Android Project dialog

Geben Sie den Anwendungsnamen ein und klicken Sie auf die Schaltfläche Weiter. Sie können die Standardeinstellungen im Dialogfeld Android-Zielgeräte unverändert belassen.

Klicken Sie erneut auf die Schaltfläche Weiter.

Android studios Add an Activity to Mobile dialog

Scrollen Sie im Dialogfeld Aktivität zu Mobile hinzufügen nach unten und wählen Sie Einstellungen Aktivität. Klicken Sie danach auf die Schaltfläche Weiter.

Android Studios Configure Activity dialog

Im letzten Dialog können Sie den Aktivitätsnamen, den Layoutnamen oder den Titel nach Belieben umbenennen. Klicken Sie abschließend auf die Schaltfläche Fertig stellen, um alle Konfigurationen zu akzeptieren.

Android Studio hat uns jetzt geholfen, ein Projekt mit einer Einstellungsaktivität zu erstellen. Wirklich cool! Es wird dringend empfohlen, den generierten Code zu erkunden.

Sie können auch Vorlagen für ein bereits vorhandenes Android Studio-Projekt verwenden. Gehen Sie einfach zu Datei > Neu > Aktivität > Einstellungen Aktivität.

Navigation flow to creating a new settings activity in Android Studio

Beachten Sie, dass die in Android Studio enthaltenen Vorlagen gut für einfache Layouts und die Erstellung einfacher Apps geeignet sind. Wenn Sie jedoch Ihre App wirklich in Schwung bringen möchten, sollten Sie einige der App-Vorlagen in Betracht ziehen, die von Envato Market erhältlich sind.

Sie sind eine enorme Zeitersparnis für erfahrene Entwickler, da sie ihnen helfen, den Aufwand für die Erstellung einer App von Grund auf zu überwinden und ihre Talente stattdessen auf die einzigartigen und angepassten Teile der Erstellung einer neuen App zu konzentrieren

Abschluss

In diesem Tutorial haben Sie gelernt, wie Sie App-Einstellungen in Android von Grund auf neu erstellen. Wir haben auch untersucht, wie Sie die Android Studio-Vorlagen einfach und schnell zum Erstellen von App-Einstellungen verwenden können.

Ich empfehle dringend, die offiziellen Materialdesign-Richtlinien für Einstellungen zu lesen, um mehr darüber zu erfahren, wie Sie Einstellungen in Android richtig entwerfen und verwenden. Sehen Sie sich auch den offiziellen API-Leitfaden an, um mehr über andere APIs zum Erstellen einer Einstellungsaktivität zu erfahren.

Um mehr über das Programmieren für Android zu erfahren, sehen Sie sich einige unserer anderen Kurse und Tutorials hier auf Envato Tuts+ an!