Ustawienia   Należy do Android Jetpack.

Ustawienia umożliwiają użytkownikom zmianę sposobu działania i sposobu działania aplikacji. Mogą one wpływać na działanie aplikacji w tle, np. częstotliwość synchronizowania danych przez aplikację z chmurą lub mieć szerszy zasięg, np. zmianę zawartości i sposobu prezentacji interfejsu użytkownika.

Uwaga: w tym dokumencie opisano, jak używać biblioteki ustawień AndroidaX. Od wersji 10 Androida biblioteka android.preference została wycofana.

Aby zintegrować z aplikacją ustawienia, które można skonfigurować przez użytkownika, użyj biblioteki preferencji AndroidaX. Ta biblioteka zarządza interfejsem użytkownika i działa z miejscem na dane, dzięki czemu możesz definiować tylko indywidualne ustawienia, które może konfigurować użytkownik. Biblioteka zawiera motyw Material Design, który zapewnia spójne wrażenia użytkownika na różnych urządzeniach i w różnych wersjach systemu operacyjnego.

Rozpocznij

Preference to podstawowy element biblioteki preferencji. Ekran ustawień zawiera hierarchię Preference. Hierarchię możesz zdefiniować jako zasób XML lub utworzyć ją w kodzie.

W następnych sekcjach opisaliśmy, jak utworzyć prosty ekran ustawień za pomocą biblioteki AndroidX Preference.

Zanim zaczniesz, dodaj do pliku build.gradle zależność biblioteki preferencji:

Groovy

dependencies {
    implementation "androidx.preference:preference-ktx:1.2.0"
}

Kotlin

dependencies {
    implementation("androidx.preference:preference-ktx:1.2.0")
}

Po zsynchronizowaniu Gradle możesz przejść do części XML zadania.

Tworzenie hierarchii

W projekcie przejdź do folderu res/xml, utwórz plik preferences.xml i dodaj do niego ten kod:

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

    <SwitchPreferenceCompat
        app:key="notifications"
        app:title="Enable message notifications"/>

    <Preference
        app:key="feedback"
        app:title="Send feedback"
        app:summary="Report technical issues or suggest new features"/>

</PreferenceScreen>

Ta hierarchia zawiera 2 obiekty Preference: SwitchPreferenceCompat, który pozwala użytkownikom włączać i wyłączać ustawienie, oraz podstawowy obiekt Preference bez widgeta.

Podczas tworzenia hierarchii każdy element Preference musi mieć unikalny klucz.

Uwaga: aby dowiedzieć się, jak uporządkować ekran ustawień, zapoznaj się z wytycznymi dotyczącymi projektowania ustawień Androida.

Rozwijanie hierarchii

Aby zawyżyć hierarchię na podstawie atrybutu XML, utwórz PreferenceFragmentCompat, zastąp onCreatePreferences() i podaj zasób XML do powiększenia, jak pokazano w tym przykładzie:

Kotlin

class MySettingsFragment : PreferenceFragmentCompat() {
    override fun onCreatePreferences(savedInstanceState: Bundle?, rootKey: String?) {
        setPreferencesFromResource(R.xml.preferences, rootKey)
    }
}

Java

public class MySettingsFragment extends PreferenceFragmentCompat {
    @Override
    public void onCreatePreferences(Bundle savedInstanceState, String rootKey) {
        setPreferencesFromResource(R.xml.preferences, rootKey);
    }
}

Następnie możesz dodać tę Fragment do Activity tak samo jak każdą inną Fragment:

Kotlin

class MySettingsActivity : AppCompatActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        supportFragmentManager
                .beginTransaction()
                .replace(R.id.settings_container, MySettingsFragment())
                .commit()
    }
}

Java

public class MySettingsActivity extends AppCompatActivity {
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        getSupportFragmentManager()
                .beginTransaction()
                .replace(R.id.settings_container, new MySettingsFragment())
                .commit();
    }
}

Wynik przedstawia poniższy obraz:

Rysunek 1. Ekran ustawień utworzony za pomocą 2 obiektów Preference.

Monitorowanie ustawień

Aby uzyskać zdarzenie, gdy zmieni się Twoje preferencje, zarejestruj dla niego detektor:

Kotlin

findPreference<SwitchPreferenceCompat>("notifications")
    ?.setOnPreferenceChangeListener { _, newValue ->
        Log.d("Preferences", "Notifications enabled: $newValue")
        true // Return true if the event is handled.
    }

findPreference<Preference>("feedback")
    ?.setOnPreferenceClickListener {
        Log.d("Preferences", "Feedback was clicked")
        true // Return true if the click is handled.
    }

Java

SwitchPreferenceCompat notificationsPref = findPreference("notifications");

if (notificationsPref != null) {
    notificationsPref.setOnPreferenceChangeListener((preference, newValue) -> {
        Log.d("Preferences", String.format("Notifications enabled: %s", newValue));
        return true; // Return true if the event is handled.
    });
}

Preference feedbackPref = findPreference("feedback");

if (feedbackPref != null) {
    feedbackPref.setOnPreferenceClickListener((preference) -> {
        Log.d("Preferences", "Feedback was clicked");
        return true; // Return true if the event is handled.
    });
}

Odczyt bieżącej wartości preferencji

Funkcja PreferenceFragmentCompat ukrywa znaczną część maszyn używanych do zapisywania i odczytywania ustawień. Jednak wszystko jest przechowywane za pomocą funkcji SharedPreferences, a wartości te możesz odczytać w zwykły sposób za pomocą funkcji SharedPreferences:

Kotlin

val preferences = PreferenceManager.getDefaultSharedPreferences(this).all

preferences.forEach {
    Log.d("Preferences", "${it.key} -> ${it.value}")
}

Java

var preferences = PreferenceManager.getDefaultSharedPreferences(context).getAll();

preferences.forEach((key, value) ->{
    Log.d("Preferences", String.format("%s -> %s", key, value));
});

Poprzedni fragment kodu pobiera wystąpienie domyślnego obiektu SharedPreferences w aplikacji, uzyskuje dostęp do wszystkich zapisanych wartości, przechodzi przez nie w pętli i wypisuje je w Logcat.