Local Storage with DataStore

What you'll learn

Not all data needs a database. A theme choice, a username, whether the user has seen onboarding — these are small key–value settings, and Jetpack DataStore is the modern way to store them. It's asynchronous, safe, and Flow-based, so it fits everything you just learned.

By the end you'll be able to:

• Explain what DataStore is and when to use it
• Read preferences as a Flow
• Write preferences with edit
• Understand why it replaces SharedPreferences

What DataStore is

Preferences DataStore stores simple key–value pairs (booleans, strings, numbers) asynchronously. Reads come back as a Flow that re-emits whenever the value changes, and writes are suspend functions that run off the main thread. It's ideal for small, unstructured settings — for structured, queryable data (a list of tasks), use Room in the next module.

// build.gradle:  implementation("androidx.datastore:datastore-preferences:1.x")

// One DataStore for the whole app, created at file scope:
val Context.dataStore by preferencesDataStore(name = "settings")

// Define typed keys:
object SettingsKeys {
    val DARK_MODE = booleanPreferencesKey("dark_mode")
    val USERNAME = stringPreferencesKey("username")
}

Reading preferences

Access the flow via dataStore.data and map it to the key you want, supplying a default for the first run when nothing is stored yet:

class SettingsRepository(private val context: Context) {

    // Reading is a Flow — it emits again whenever the value changes.
    val darkMode: Flow<Boolean> = context.dataStore.data
        .map { prefs -> prefs[SettingsKeys.DARK_MODE] ?: false }   // default false
}

Because it's a Flow, your UI stays in sync automatically: expose it through the ViewModel and collect it with collectAsStateWithLifecycle(), and the moment the setting changes anywhere, every screen reading it updates.

Writing preferences

Writing uses edit, a suspend function you call from a coroutine. Inside the block you set keys on a mutable snapshot; DataStore persists it atomically:

suspend fun setDarkMode(enabled: Boolean) {
    context.dataStore.edit { prefs ->        // edit suspends; runs off the main thread
        prefs[SettingsKeys.DARK_MODE] = enabled
    }
}

From SharedPreferences

The old API, SharedPreferences, is synchronous — its reads can block the main thread — and it has no built-in error handling or reactive updates. DataStore fixes all three: it's coroutine-based (never blocks the UI thread), reports errors through the flow, and pushes updates reactively. For new apps, always prefer DataStore. DataStore can even migrate existing SharedPreferences data for you via SharedPreferencesMigration.

Recap & quick check

For settings, DataStore is perfect. For real structured data — lists you query, sort, and relate — you need a database. Enter Room.