Android Academy · Leçon

Préférences DataStore

Remplacez SharedPreferences par la bibliothèque moderne DataStore. Lisez les données sous forme de Kotlin Flow, écrivez-les avec edit{} et gérez les erreurs en toute sécurité.

Leçon 5 sur 613 étapes

Préférences DataStore est une leçon Android Academy gratuite sur CoddyKit. Ceci est la leçon 5 sur 6. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Android Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Android Academy comprend 6 leçons au total.

Pourquoi utiliser DataStore ?

DataStore est le remplacement moderne de SharedPreferences. Il résout plusieurs problèmes réels :

SharedPreferences bloque le thread de l’interface utilisateur — DataStore est entièrement asynchrone
SharedPreferences peut générer des exceptions non interceptées — DataStore gère les erreurs via Flow
DataStore garantit la sécurité des types (Preferences) ou la sécurité du schéma (Proto)
Fonctionne nativement avec les Coroutines et Flow de Kotlin

Deux types de DataStore

Choisissez le type adapté à votre cas d'utilisation :

DataStore de préférences — paires clé-valeur, sans schéma requis. La configuration la plus simple. Idéal pour les paramètres de l'application et les préférences utilisateur.
Proto DataStore — objets typés utilisant Protocol Buffers. Nécessite un fichier de schéma .proto. Idéal lorsque vous disposez de données structurées.

Cette leçon porte sur le DataStore de préférences.

Ajout de la dépendance

Ajoutez DataStore à app/build.gradle :

// app/build.gradle
dependencies {
    implementation 'androidx.datastore:datastore-preferences:1.1.1'
    // Coroutines (likely already in your project)
    implementation 'org.jetbrains.kotlinx:kotlinx-coroutines-android:1.7.3'
}

Création d'une instance DataStore

Créez le DataStore une seule fois à l'aide du délégué de niveau supérieur. Cela se fait généralement dans un fichier indépendant :

import android.content.Context
import androidx.datastore.core.DataStore
import androidx.datastore.preferences.core.Preferences
import androidx.datastore.preferences.preferencesDataStore

// Top-level property — creates a single DataStore instance per Context
val Context.dataStore: DataStore<Preferences> by preferencesDataStore(name = "user_prefs")

Définition des clés

Les clés sont des objets dont le type est vérifié, et non de simples chaînes de caractères. Créez-les avec la bonne fonction fabrique :

import androidx.datastore.preferences.core.booleanPreferencesKey
import androidx.datastore.preferences.core.intPreferencesKey
import androidx.datastore.preferences.core.stringPreferencesKey

object PreferencesKeys {
    val DARK_MODE    = booleanPreferencesKey("dark_mode")
    val USER_NAME    = stringPreferencesKey("user_name")
    val LAUNCH_COUNT = intPreferencesKey("launch_count")
}

Écriture des données

Écrivez dans une coroutine à l'aide de edit { } :

import androidx.datastore.preferences.core.edit

// In a ViewModel or Repository:
suspend fun saveDarkMode(enabled: Boolean) {
    context.dataStore.edit { prefs ->
        prefs[PreferencesKeys.DARK_MODE] = enabled
    }
}

suspend fun incrementLaunchCount() {
    context.dataStore.edit { prefs ->
        val current = prefs[PreferencesKeys.LAUNCH_COUNT] ?: 0
        prefs[PreferencesKeys.LAUNCH_COUNT] = current + 1
    }
}

Lecture des données avec un flux

DataStore expose les données sous forme de Flow. Utilisez map pour extraire la valeur dont vous avez besoin :

import kotlinx.coroutines.flow.Flow
import kotlinx.coroutines.flow.map

val darkModeFlow: Flow<Boolean> = context.dataStore.data
    .map { prefs ->
        prefs[PreferencesKeys.DARK_MODE] ?: false  // default = false
    }

val userNameFlow: Flow<String> = context.dataStore.data
    .map { prefs ->
        prefs[PreferencesKeys.USER_NAME] ?: "Guest"
    }

Collecte dans un ViewModel

Exposez les flux de DataStore depuis un ViewModel en utilisant stateIn pour une collecte efficace :

class SettingsViewModel(private val repo: SettingsRepository) : ViewModel() {

    val isDarkMode: StateFlow<Boolean> = repo.darkModeFlow
        .stateIn(
            scope = viewModelScope,
            started = SharingStarted.WhileSubscribed(5000),
            initialValue = false
        )

    fun toggleDarkMode(enabled: Boolean) {
        viewModelScope.launch {
            repo.saveDarkMode(enabled)
        }
    }
}

Observation dans une Activity ou un Fragment

Collectez le StateFlow dans l'interface utilisateur à l'aide de lifecycleScope.launch :

// In Fragment:
lifecycleScope.launch {
    viewLifecycleOwner.repeatOnLifecycle(Lifecycle.State.STARTED) {
        viewModel.isDarkMode.collect { darkMode ->
            binding.switchDarkMode.isChecked = darkMode
            AppCompatDelegate.setDefaultNightMode(
                if (darkMode) AppCompatDelegate.MODE_NIGHT_YES
                else AppCompatDelegate.MODE_NIGHT_FOLLOW_SYSTEM
            )
        }
    }
}

Gestion des erreurs

DataStore émet IOException si le fichier est corrompu. Interceptez-la dans le pipeline de votre flux :

import kotlinx.coroutines.flow.catch
import java.io.IOException

val safeFlow: Flow<Boolean> = context.dataStore.data
    .catch { exception ->
        if (exception is IOException) {
            emit(emptyPreferences())   // return defaults
        } else {
            throw exception
        }
    }
    .map { prefs ->
        prefs[PreferencesKeys.DARK_MODE] ?: false
    }

DataStore ou SharedPreferences

Résumé des raisons pour lesquelles DataStore est préférable :

DataStore lit et écrit automatiquement sur un thread d'arrière-plan — aucun risque d'ANR
apply() de SharedPreferences peut échouer silencieusement ; DataStore propage les erreurs via le flux
DataStore est réactif — l'interface utilisateur se met automatiquement à jour lorsque les données changent
SharedPreferences ne propose aucun mécanisme de migration ; DataStore intègre SharedPreferencesMigration

Vérification rapide

Quel est le principal mécanisme utilisé par DataStore pour exposer ses données au reste de l'application ?

Réponds-y dans la leçon interactive

Récapitulatif : préférences DataStore

DataStore est la méthode moderne pour conserver des données simples :

Ajoutez la dépendance datastore-preferences
Créez une instance unique avec le délégué preferencesDataStore
Définissez des clés dont le type est vérifié avec stringPreferencesKey, booleanPreferencesKey, etc.
Écrivez avec dataStore.edit { } dans une coroutine
Lisez les données sous forme de Flow avec dataStore.data.map { }
Gérez IOException avec .catch { emit(emptyPreferences()) }

Ensuite : créez des adaptateurs de listes efficaces avec DiffUtil.

Gratuit pour commencer

Apprends Kotlin avec un tuteur IA — gratuit

Écris et exécute du vrai code dans ton navigateur, obtiens de l'aide instantanée d'un tuteur IA disponible 24h/24, et reprends là où tu t'es arrêté sur le web ou dans l'app.

Cours: 36
Leçons: 152

Commencer gratuitement Voir le cours complet

Questions Fréquemment Posées

La leçon « Préférences DataStore » est-elle gratuite ?

Oui — le texte complet de « Préférences DataStore » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Android Academy, passe à CoddyKit PRO. Le cours Android Academy comprend 6 leçons au total.

Qu'est-ce que j'apprendrai dans « Préférences DataStore » ?

Remplacez SharedPreferences par la bibliothèque moderne DataStore. Lisez les données sous forme de Kotlin Flow, écrivez-les avec edit{} et gérez les erreurs en toute sécurité. Tu pratiques Android Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer Android Academy ?

Aucune expérience préalable n'est requise. Android Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 5 sur 6.

Combien de temps prend la leçon « Préférences DataStore » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon Android Academy ?

Oui. Chaque leçon Android Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

← Retour à Android Academy