Jetpack DataStore: The Modern Replacement for SharedPreferences

// 1. Create the DataStore once, at the top level of a Kotlin file
val Context.settingsDataStore by preferencesDataStore(
    name = "user_settings"
)

// 2. Define the preference keys
object SettingsKeys {
    val DARK_MODE = booleanPreferencesKey("dark_mode")
    val FONT_SIZE = intPreferencesKey("font_size")
    val USERNAME = stringPreferencesKey("username")
    val ONBOARDING_COMPLETE = booleanPreferencesKey("onboarding_complete")
    val NOTIFICATIONS_ENABLED = booleanPreferencesKey("notifications_enabled")
}

// 3. Read with Flow
class SettingsRepository(private val context: Context) {

    val userSettings: Flow<UserSettings> = context.settingsDataStore.data
        .map { prefs ->
            UserSettings(
                darkMode = prefs[SettingsKeys.DARK_MODE] ?: false,
                fontSize = prefs[SettingsKeys.FONT_SIZE] ?: 16,
                username = prefs[SettingsKeys.USERNAME] ?: "Guest",
                notificationsEnabled = prefs[SettingsKeys.NOTIFICATIONS_ENABLED] ?: true
            )
        }

    // 4. Write inside a transaction
    suspend fun setDarkMode(enabled: Boolean) {
        context.settingsDataStore.edit { prefs ->
            prefs[SettingsKeys.DARK_MODE] = enabled
        }
    }

    suspend fun updateFontSize(size: Int) {
        context.settingsDataStore.edit { prefs ->
            prefs[SettingsKeys.FONT_SIZE] = size.coerceIn(12, 32)
        }
    }

    // Two values, one transaction: both are written or neither is
    suspend fun completeOnboarding(username: String) {
        context.settingsDataStore.edit { prefs ->
            prefs[SettingsKeys.ONBOARDING_COMPLETE] = true
            prefs[SettingsKeys.USERNAME] = username
        }
    }
}

// app/src/main/proto/user_preferences.proto
syntax = "proto3";

option java_package = "com.myapp.datastore";
option java_multiple_files = true;

message UserPreferences {
    bool dark_mode = 1;
    int32 font_size = 2;
    string username = 3;
    bool onboarding_complete = 4;

    enum Theme {
        SYSTEM = 0;
        LIGHT = 1;
        DARK = 2;
    }
    Theme theme = 5;
}

// Serializer (required by DataStore)
object UserPreferencesSerializer : Serializer<UserPreferences> {
    override val defaultValue: UserPreferences =
        UserPreferences.getDefaultInstance()

    override suspend fun readFrom(input: InputStream): UserPreferences {
        try {
            return UserPreferences.parseFrom(input)
        } catch (e: InvalidProtocolBufferException) {
            throw CorruptionException("Cannot read proto.", e)
        }
    }

    override suspend fun writeTo(t: UserPreferences, output: OutputStream) {
        t.writeTo(output)
    }
}

// Create the DataStore once, at the top level
val Context.userPrefsStore: DataStore<UserPreferences> by dataStore(
    fileName = "user_preferences.pb",
    serializer = UserPreferencesSerializer
)

class UserPrefsRepository(private val context: Context) {

    val preferences: Flow<UserPreferences> = context.userPrefsStore.data

    suspend fun setTheme(theme: UserPreferences.Theme) {
        context.userPrefsStore.updateData { current ->
            current.toBuilder()
                .setTheme(theme)
                .build()
        }
    }

    suspend fun updateProfile(username: String, fontSize: Int) {
        context.userPrefsStore.updateData { current ->
            current.toBuilder()
                .setUsername(username)
                .setFontSize(fontSize)
                .build()
        }
    }
}

// Preferences DataStore with migration
val Context.settingsDataStore by preferencesDataStore(
    name = "user_settings",
    produceMigrations = { context ->
        listOf(
            SharedPreferencesMigration(
                context = context,
                sharedPreferencesName = "legacy_settings",
                keysToMigrate = setOf("dark_mode", "font_size", "username")
            )
        )
    }
)

// Proto DataStore with a custom mapping.
// The mapping only sets values, so running it twice gives the same result.
val Context.userPrefsStore: DataStore<UserPreferences> by dataStore(
    fileName = "user_preferences.pb",
    serializer = UserPreferencesSerializer,
    produceMigrations = { context ->
        listOf(
            SharedPreferencesMigration(
                context = context,
                sharedPreferencesName = "legacy_settings"
            ) { sharedPrefs, currentData ->
                currentData.toBuilder().apply {
                    if (sharedPrefs.contains("dark_mode")) {
                        val dark = sharedPrefs.getBoolean("dark_mode", false)
                        darkMode = dark
                        theme = if (dark) {
                            UserPreferences.Theme.DARK
                        } else {
                            UserPreferences.Theme.LIGHT
                        }
                    }
                    if (sharedPrefs.contains("font_size")) {
                        fontSize = sharedPrefs.getInt("font_size", 16)
                    }
                    if (sharedPrefs.contains("username")) {
                        username = sharedPrefs.getString("username", "") ?: ""
                    }
                }.build()
            }
        )
    }
)

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

    val uiState: StateFlow<UserSettings> = settingsRepo.userSettings
        .stateIn(
            scope = viewModelScope,
            started = SharingStarted.WhileSubscribed(5_000),
            initialValue = UserSettings()
        )

    fun setDarkMode(enabled: Boolean) {
        viewModelScope.launch {
            // No manual state update: the Flow from DataStore emits
            settingsRepo.setDarkMode(enabled)
        }
    }

    fun updateFontSize(newSize: Int) {
        viewModelScope.launch {
            settingsRepo.updateFontSize(newSize)
        }
    }
}

@Composable
fun SettingsScreen(viewModel: SettingsViewModel = hiltViewModel()) {
    val state by viewModel.uiState.collectAsStateWithLifecycle()

    // Local state while dragging; one write when the drag ends
    var draftSize by remember(state.fontSize) {
        mutableFloatStateOf(state.fontSize.toFloat())
    }

    Column(modifier = Modifier.padding(16.dp)) {
        Switch(
            checked = state.darkMode,
            onCheckedChange = { viewModel.setDarkMode(it) }
        )
        Slider(
            value = draftSize,
            valueRange = 12f..32f,
            onValueChange = { draftSize = it },
            onValueChangeFinished = {
                viewModel.updateFontSize(draftSize.toInt())
            }
        )
        Text(
            text = "Logged in as ${state.username}",
            fontSize = draftSize.sp
        )
    }
}