El repositorio y el ViewModel de los ajustes

src/commonMain/kotlin/com/sebastiannarvaez/pokedex/feature/settings/Settings.kt

package com.sebastiannarvaez.pokedex.feature.settings
 
// Los tres temas posibles.
enum class Tema { SISTEMA, CLARO, OSCURO }
 
// Todas las preferencias de la app juntas, cada una con su valor por defecto.
data class Settings(
    val tema: Tema = Tema.SISTEMA,            // no decidir por el usuario: sigue al sistema
    val favoritosPorNumero: Boolean = false,  // false = lo más reciente primero
)

src/commonMain/kotlin/com/sebastiannarvaez/pokedex/data/SettingsRepository.kt

import java.io.IOException
import kotlinx.coroutines.flow.Flow
import kotlinx.coroutines.flow.catch
import kotlinx.coroutines.flow.flow
import kotlinx.coroutines.runBlocking
 
// Un sensor de temperatura que da una lectura y luego falla con el error que le pasemos.
fun sensor(fallo: Exception): Flow<Int> = flow {
    emit(20)        // primera lectura
    throw fallo     // y se rompe
}
 
// Solo se atrapa el error de lectura (IOException); cualquier otro se vuelve a lanzar.
fun Flow<Int>.conRepuesto(): Flow<Int> = catch { e ->
    if (e !is IOException) throw e
    println("aviso: ${e.message}")
    emit(-1)        // valor de reemplazo
}
 
fun main() = runBlocking {
    sensor(IOException("sensor desconectado")).conRepuesto().collect { println("lectura: $it") }
    try {
        sensor(IllegalStateException("error de programación")).conRepuesto().collect { println("lectura: $it") }
    } catch (e: IllegalStateException) {
        println("llega el error: ${e.message}")
    }
}

lectura: 20
aviso: sensor desconectado
lectura: -1
lectura: 20
llega el error: error de programación

// Hoy la app tiene este orden de tallas...
enum class TallaAntes { PEQUENA, MEDIANA, GRANDE }
// ...y en la versión siguiente alguien las reordena.
enum class TallaDespues { GRANDE, MEDIANA, PEQUENA }
 
fun main() {
    val elegida = TallaAntes.GRANDE
    val guardadoPosicion = elegida.ordinal   // 2: su posición en la lista
    val guardadoNombre = elegida.name        // "GRANDE": su nombre
 
    println("Guardado: posición $guardadoPosicion, nombre $guardadoNombre")
    // Al abrir la versión nueva, se lee lo guardado:
    println("Leído por posición: ${TallaDespues.entries[guardadoPosicion]}")
    println("Leído por nombre:   ${TallaDespues.valueOf(guardadoNombre)}")
    // Un nombre que ya no existe lanza una excepción; runCatching la convierte en null.
    println("Nombre borrado:     ${runCatching { TallaDespues.valueOf("ENORME") }.getOrNull() ?: TallaDespues.MEDIANA}")
}

Guardado: posición 2, nombre GRANDE
Leído por posición: PEQUENA
Leído por nombre:   GRANDE
Nombre borrado:     MEDIANA

package com.sebastiannarvaez.pokedex.data
 
import androidx.datastore.core.DataStore
import androidx.datastore.core.IOException
import androidx.datastore.preferences.core.Preferences
import androidx.datastore.preferences.core.booleanPreferencesKey
import androidx.datastore.preferences.core.edit
import androidx.datastore.preferences.core.emptyPreferences
import androidx.datastore.preferences.core.stringPreferencesKey
import com.sebastiannarvaez.pokedex.core.Log
import com.sebastiannarvaez.pokedex.feature.settings.Settings
import com.sebastiannarvaez.pokedex.feature.settings.Tema
import kotlinx.coroutines.flow.Flow
import kotlinx.coroutines.flow.catch
import kotlinx.coroutines.flow.map
 
// Lee y escribe las preferencias. `internal`: las pantallas lo usan a través
// del ViewModel, no directamente.
internal class SettingsRepository(private val store: DataStore<Preferences>) {
 
    // Las etiquetas con las que cada valor se guarda dentro del fichero.
    // Cada clave lleva su tipo: leer `tema` como Boolean no compila.
    // `companion object`: miembros de la clase, no de cada instancia, y aquí
    // `private`: solo esta clase los ve (más en «object, companion y vararg»).
    private companion object {
        val CLAVE_TEMA = stringPreferencesKey("tema")
        val CLAVE_ORDEN = booleanPreferencesKey("favoritos_por_numero")
    }
 
    // Lectura: un Flow que emite las preferencias cada vez que cambian.
    val settings: Flow<Settings> = store.data
        .catch { causa ->
            // Solo se atrapa el error de DISCO (`IOException`: fichero ilegible
            // o corrupto). Cualquier otro es un fallo de programación y se
            // vuelve a lanzar para que se oiga.
            if (causa !is IOException) throw causa
            // Si leer el fichero falla, se avisa en el registro y se sigue con
            // las preferencias vacías (= los valores por defecto).
            Log.w("no se pudieron leer las preferencias", causa)
            emit(emptyPreferences())
        }
        .map { prefs ->
            Settings(
                // Lo guardado es un texto. `?.let` lo intenta convertir en `Tema` solo si hay texto;
                // si no hay texto o no corresponde a ningún Tema, `?:` pone SISTEMA.
                tema = prefs[CLAVE_TEMA]?.let { runCatching { Tema.valueOf(it) }.getOrNull() } ?: Tema.SISTEMA,
                favoritosPorNumero = prefs[CLAVE_ORDEN] ?: false,   // sin valor guardado: false
            )
        }
 
    // Escritura: `edit` abre una transacción; al salir del bloque se escribe todo.
    suspend fun cambiarTema(tema: Tema) {
        // Dentro de `edit`, `it` son las preferencias editables: `it[CLAVE] = valor` escribe.
        store.edit { it[CLAVE_TEMA] = tema.name }   // se guarda el NOMBRE del Tema
    }
 
    suspend fun cambiarOrden(porNumero: Boolean) {
        store.edit { it[CLAVE_ORDEN] = porNumero }
    }
}

src/commonMain/kotlin/com/sebastiannarvaez/pokedex/feature/settings/SettingsViewModel.kt

package com.sebastiannarvaez.pokedex.feature.settings
 
import androidx.lifecycle.ViewModel
import androidx.lifecycle.viewModelScope
import com.sebastiannarvaez.pokedex.data.SettingsRepository
import kotlinx.coroutines.flow.SharingStarted
import kotlinx.coroutines.flow.StateFlow
import kotlinx.coroutines.flow.stateIn
import kotlinx.coroutines.launch
 
// `internal constructor`: solo código de `shared` puede construirlo, porque su
// parámetro (`SettingsRepository`) también es `internal`. Las apps no lo
// construyen: se lo piden a Koin.
class SettingsViewModel internal constructor(
    private val repository: SettingsRepository,
) : ViewModel() {
 
    // El flujo del repositorio como StateFlow: siempre tiene un valor actual.
    // `stateIn` lo convierte; `WhileSubscribed(5_000)` lo mantiene vivo mientras
    // alguien lo mire y 5 s más (sobrevive a girar la pantalla); `Settings()` es
    // el valor mientras DataStore lee el fichero ([StateFlow y SharedFlow] lo explica).
    val settings: StateFlow<Settings> = repository.settings
        .stateIn(viewModelScope, SharingStarted.WhileSubscribed(5_000), Settings())
 
    // Cada gesto de la pantalla es una escritura (suspend) lanzada desde aquí.
    fun cambiarTema(tema: Tema) {
        viewModelScope.launch { repository.cambiarTema(tema) }
    }
 
    fun cambiarOrden(porNumero: Boolean) {
        viewModelScope.launch { repository.cambiarOrden(porNumero) }
    }
}

import com.sebastiannarvaez.pokedex.data.SettingsRepository
import com.sebastiannarvaez.pokedex.feature.settings.SettingsViewModel

    single { SettingsRepository(get()) }

    viewModelOf(::SettingsViewModel)

MissingKoinDefinitionException: Missing definition for
'[field:'store' - type:'androidx.datastore.core.DataStore']' in definition
'[Singleton: 'com.sebastiannarvaez.pokedex.data.SettingsRepository']'.

import androidx.datastore.core.DataStore

        pokedexModule.verify(
            extraTypes = listOf(
                HttpClientEngine::class,
                // El almacén lo registra `platformModule` (uno por plataforma),
                // y `verify` solo mira `pokedexModule`.
                DataStore::class,
            ),
        )

src/jvmTest/kotlin/com/sebastiannarvaez/pokedex/feature/settings/SettingsTest.kt

package com.sebastiannarvaez.pokedex.feature.settings
 
import app.cash.turbine.test
import com.sebastiannarvaez.pokedex.data.SettingsRepository
import com.sebastiannarvaez.pokedex.data.local.createSettingsStore
import kotlin.io.path.createTempDirectory
import kotlin.test.Test
import kotlin.test.assertEquals
import kotlin.test.assertFalse
import kotlin.test.assertIs
import kotlin.test.assertTrue
import kotlinx.coroutines.test.runTest
 
class SettingsTest {
 
    // Un repositorio nuevo sobre un fichero temporal nuevo: cada test parte de cero.
    private fun repo(): SettingsRepository {
        val ruta = createTempDirectory("prefs").resolve("pokedex.preferences_pb").toString()
        return SettingsRepository(createSettingsStore(ruta))
    }
 
    @Test
    fun sinNadaGuardadoMandaElSistema() = runTest {
        repo().settings.test {
            val inicial = awaitItem()                 // la primera emisión del flujo
            // El último argumento de cada aserción es el mensaje que sale si falla.
            assertEquals(Tema.SISTEMA, inicial.tema, "sin nada guardado, el tema es el del sistema")
            assertFalse(inicial.favoritosPorNumero, "sin nada guardado, lo más reciente va primero")
            cancelAndIgnoreRemainingEvents()
        }
    }
 
    @Test
    fun elCambioLlegaComoEmision() = runTest {
        val repo = repo()
 
        repo.settings.test {
            assertEquals(Tema.SISTEMA, awaitItem().tema)   // 1.ª emisión: el valor por defecto
            repo.cambiarTema(Tema.OSCURO)                   // se escribe...
            assertEquals(Tema.OSCURO, awaitItem().tema, "tras escribir llega una emisión nueva")
            cancelAndIgnoreRemainingEvents()
        }
    }
 
    @Test
    fun loGuardadoSeLeeDesdeElMismoAlmacen() = runTest {
        val ruta = createTempDirectory("prefs").resolve("pokedex.preferences_pb").toString()
        val almacen = createSettingsStore(ruta)          // UN almacén...
 
        SettingsRepository(almacen).cambiarOrden(porNumero = true)
 
        // ...y un repositorio distinto sobre ese mismo almacén: ve lo guardado.
        SettingsRepository(almacen).settings.test {
            assertTrue(awaitItem().favoritosPorNumero, "otro repositorio sobre el mismo almacén ve lo guardado")
            cancelAndIgnoreRemainingEvents()
        }
    }
 
    @Test
    fun elTemaGuardadoSeRecuperaPorSuNombre() = runTest {
        val repo = repo()
        repo.cambiarTema(Tema.CLARO)
 
        repo.settings.test {
            assertEquals(Tema.CLARO, awaitItem().tema, "el tema guardado se recupera por su nombre")
            cancelAndIgnoreRemainingEvents()
        }
    }
 
    @Test
    fun dosAlmacenesSobreElMismoFicheroSeOyen() = runTest {
        val ruta = createTempDirectory("prefs").resolve("pokedex.preferences_pb").toString()
        val primero = createSettingsStore(ruta)
        SettingsRepository(primero).cambiarOrden(porNumero = true)
 
        val segundo = createSettingsStore(ruta)   // un SEGUNDO almacén sobre el mismo fichero
 
        SettingsRepository(segundo).settings.test {
            // DataStore protesta con una `IllegalStateException` al leer del segundo
            // almacén. Como el `catch` del repositorio es estrecho, el error llega.
            val error = awaitError()
            assertIs<IllegalStateException>(error)
        }
    }
}

./gradlew :shared:jvmTest --tests "*SettingsTest*" --rerun -i

Warn: (Pokedex) no se pudieron leer las preferencias
java.lang.IllegalStateException: There are multiple DataStores active for the same file: …
…
TurbineAssertionError: Expected error but found Item(Settings(tema=SISTEMA, favoritosPorNumero=false))