El puente de paginación para iOS

// Una función que traduce un LoadState a una frase. `when` elige una rama
// según el tipo; `is` pregunta «¿es de este tipo?».
fun describir(estado: LoadState): String = when (estado) {
    is LoadState.Loading -> "cargando"
    // `estado.endOfPaginationReached` solo existe en NotLoading: dentro de esta rama Kotlin ya sabe que lo es.
    is LoadState.NotLoading -> if (estado.endOfPaginationReached) "no hay más páginas" else "en reposo"
    is LoadState.Error -> "falló: ${estado.error.message}"   // `error` es la excepción que llevaba dentro
}
 
println(describir(LoadState.Loading))
println(describir(LoadState.NotLoading(endOfPaginationReached = false)))
println(describir(LoadState.NotLoading(endOfPaginationReached = true)))
println(describir(LoadState.Error(IOException("sin red"))))

cargando
en reposo
no hay más páginas
falló: sin red

class ContadorDeLibros(
    paginas: Flow<PagingData<String>>,     // un flujo de páginas: cada PagingData es «lo cargado»
    hilo: CoroutineDispatcher,             // el «dispatcher»: decide en qué hilo corre cada corrutina
) {
    private val scope = CoroutineScope(SupervisorJob() + hilo)
 
    private val _cuantos = MutableStateFlow(0)
    val cuantos: StateFlow<Int> = _cuantos.asStateFlow()
 
    // 1. Se hereda de PagingDataPresenter y se rellena el único método abstracto:
    //    Paging lo llama cada vez que la lista cambia (llegan datos, se borran, se recarga).
    // 2. `mainContext`: el dispatcher con el que Paging procesa esos eventos. Si no se
    //    pasa, usa Dispatchers.Main, el que corre en el hilo principal de la plataforma.
    private val presentador = object : PagingDataPresenter<String>(mainContext = hilo) {
        override suspend fun presentPagingDataEvent(event: PagingDataEvent<String>) {
            // 3. `snapshot()` es una foto de lo cargado ahora; `.items` es su lista.
            _cuantos.value = snapshot().items.size
        }
    }
 
    init {
        // 4. `collectFrom` le entrega al presentador cada PagingData nuevo del flujo.
        scope.launch { paginas.collect { presentador.collectFrom(it) } }
    }
 
    fun cerrar() = scope.cancel()          // cancela las corrutinas del scope
}
 
// Una sola página ya hecha, con tres libros:
val paginas = flowOf(PagingData.from(listOf("Libro 1", "Libro 2", "Libro 3")))
// Dentro de un test con `runTest`; `UnconfinedTestDispatcher` es un dispatcher de prueba (se explica justo debajo, en el ejercicio):
val contador = ContadorDeLibros(paginas, UnconfinedTestDispatcher(testScheduler))
println("libros leídos: ${contador.cuantos.value}")

libros leídos: 3

src/commonMain/kotlin/com/sebastiannarvaez/pokedex/feature/list/PagedListState.kt

package com.sebastiannarvaez.pokedex.feature.list
 
import com.sebastiannarvaez.pokedex.core.UiError        // el error ya traducido de la lección anterior
import com.sebastiannarvaez.pokedex.domain.Pokemon      // lo que se pinta en cada tarjeta
 
/**
 * La lista paginada, en un solo objeto que una interfaz pueda pintar.
 */
data class PagedListState(
    val items: List<Pokemon> = emptyList(),   // lo cargado hasta ahora
    /** La primera carga, o un tirón para refrescar. */
    val cargando: Boolean = false,
    /** Se está pidiendo la página siguiente. */
    val cargandoMas: Boolean = false,
    /** El error de la carga inicial. Deja la pantalla en blanco con su aviso. */
    val error: UiError? = null,               // `?` = puede ser null: null significa «sin error»
    /** El error al pedir la página siguiente. La lista sigue ahí. */
    val errorAlAmpliar: UiError? = null,
) {
    // Una propiedad calculada: ni cargando, ni con error, ni un solo elemento.
    val vacia: Boolean get() = items.isEmpty() && !cargando && error == null
}

val cosas: List<Any> = listOf("texto", 42)       // una lista que mezcla tipos
for (cosa in cosas) {
    val numero = cosa as? Int                    // Int si es un entero; null si no lo es
    println("$cosa -> $numero")
}
try {
    val a = cosas[0] as Int                      // «texto» no es un Int: lanza ClassCastException
    println(a)
} catch (e: ClassCastException) {
    println("as a secas: falla con ClassCastException")
}

texto -> null
42 -> 42
as a secas: falla con ClassCastException

package com.sebastiannarvaez.pokedex.feature.list
 
import androidx.paging.LoadState                              // Loading / Error / NotLoading
import androidx.paging.PagingDataEvent                        // lo que Paging cuenta que ha cambiado
import androidx.paging.PagingDataPresenter                    // la clase de la que se hereda
import com.rickclephas.kmp.nativecoroutines.NativeCoroutinesState   // hace `state` visible desde Swift
import com.sebastiannarvaez.pokedex.core.AppDispatchers       // los hilos, como dependencia
import com.sebastiannarvaez.pokedex.core.aAppError            // de la lección anterior: excepción → AppError
import com.sebastiannarvaez.pokedex.core.aUiError             // AppError → texto para pintar
import com.sebastiannarvaez.pokedex.domain.Pokemon
import kotlinx.coroutines.CoroutineScope
import kotlinx.coroutines.SupervisorJob
import kotlinx.coroutines.cancel
import kotlinx.coroutines.flow.MutableStateFlow
import kotlinx.coroutines.flow.StateFlow
import kotlinx.coroutines.flow.asStateFlow
import kotlinx.coroutines.launch
 
class PokemonListPresenter internal constructor(
    private val viewModel: PokemonListViewModel,   // de donde salen las páginas
    // Los hilos se inyectan en vez de usar `Dispatchers.Main` a pelo, para
    // poder sustituirlos en un test.
    private val dispatchers: AppDispatchers,
) {
 
    // El alcance de todas las corrutinas del presentador. Hay que cancelarlo (`close`).
    private val scope = CoroutineScope(SupervisorJob() + dispatchers.main)
 
    // Empieza en «cargando»: la primera página todavía no ha llegado.
    private val _state = MutableStateFlow(PagedListState(cargando = true))
 
    @NativeCoroutinesState                          // Swift lo ve como un valor + una secuencia
    val state: StateFlow<PagedListState> = _state.asStateFlow()
 
    // Un objeto anónimo que hereda de PagingDataPresenter, la clase base que
    // también usa Compose; solo hay que decir qué hacer con cada evento.
    // `mainContext`: el hilo en el que Paging procesa sus eventos. Se le pasa el
    // mismo hilo inyectado que usa el `scope`: en la app es el principal y en un
    // test es el de prueba.
    private val presenter = object : PagingDataPresenter<Pokemon>(mainContext = dispatchers.main) {
        override suspend fun presentPagingDataEvent(event: PagingDataEvent<Pokemon>) {
            // Cualquier evento (inserción, borrado, recarga) se resuelve igual: se
            // vuelve a leer la instantánea entera. Para unos cientos de elementos es
            // más barato que llevar las diferencias a mano, y no hay forma de equivocarse.
            publicar()
        }
    }
 
    init {
        scope.launch {
            // Cada `PagingData` nuevo que emite el ViewModel se le entrega al presentador.
            viewModel.pokemon.collect { presenter.collectFrom(it) }
        }
        scope.launch {
            // Y cada cambio de estado de carga (cargando, error…) también se publica.
            presenter.loadStateFlow.collect { publicar() }
        }
    }
 
    /** Avisa de que la interfaz está mirando esa posición, para pedir más. */
    fun loadAround(index: Int) {
        if (index in 0 until presenter.size) presenter[index]   // acceder al elemento ES avisar a Paging
    }
 
    fun retry() = presenter.retry()       // reintenta lo que falló (el botón «Reintentar»)
 
    fun refresh() = presenter.refresh()   // vuelve a cargar desde el principio
 
    /** Hay que llamarlo al desaparecer la pantalla, o las corrutinas siguen. */
    fun close() = scope.cancel()
 
    // Convierte lo que Paging sabe en el estado plano de arriba.
    private fun publicar() {
        // `CombinedLoadStates`: el estado de carga de refresh, prepend y append juntos
        // (`null` hasta que Paging informa por primera vez, de ahí los `?.`).
        val estados = presenter.loadStateFlow.value
        val refresh = estados?.refresh              // el estado de la carga inicial / refresco
        val append = estados?.append                // el estado de «pedir la página siguiente»
        val items = presenter.snapshot().items      // la foto de lo cargado ahora
 
        _state.value = PagedListState(
            items = items,
            cargando = refresh is LoadState.Loading,
            cargandoMas = append is LoadState.Loading,
            // `as?` saca el error solo si de verdad lo es; después se traduce con lo del paso anterior.
            error = (refresh as? LoadState.Error)?.error?.aAppError()?.aUiError(),
            errorAlAmpliar = (append as? LoadState.Error)?.error?.aAppError()?.aUiError(),
        )
    }
}

package com.sebastiannarvaez.pokedex.feature.list
 
import androidx.lifecycle.ViewModelProvider                // lo que crea un ViewModel dentro de un almacén
import androidx.lifecycle.ViewModelStoreOwner              // el dueño del almacén: lo da Swift
import androidx.lifecycle.viewmodel.initializer
import androidx.lifecycle.viewmodel.viewModelFactory
import com.sebastiannarvaez.pokedex.core.AppDispatchers
import org.koin.mp.KoinPlatform                            // da acceso al Koin ya arrancado
 
/**
 * Lo único que Swift necesita saber de la lista.
 */
fun pokemonListPresenter(owner: ViewModelStoreOwner): PokemonListPresenter {
    val koin = KoinPlatform.getKoin()                      // el grafo de dependencias (Koin), ya arrancado
    val viewModel = ViewModelProvider.create(
        owner = owner,                                     // el ViewModel queda guardado en el almacén de Swift
        // «Si no existe aún, créalo con Koin»: la fábrica solo se usa la primera vez.
        factory = viewModelFactory { initializer { koin.get<PokemonListViewModel>() } },
    )[PokemonListViewModel::class]                         // y se pide por su tipo
 
    // El presentador se monta sobre ese ViewModel y los hilos de la app.
    return PokemonListPresenter(viewModel, koin.get<AppDispatchers>())
}