El RemoteMediator: la red llena la base

// El almacén central: 45 frutas, y una red que a veces falla.
val almacen = (1..45).map { "fruta-$it" }
var hayRed = true
 
fun pedirAlAlmacen(cuantas: Int, desde: Int): List<String> {
    if (!hayRed) throw RuntimeException("sin red")        // el camión no llega
    return almacen.drop(desde).take(cuantas)               // salta `desde` y toma `cuantas`
}
 
enum class Carga { EMPEZAR, SEGUIR }                        // como los LoadType, con otros nombres
 
class Reponedor(
    val estanteria: MutableList<String>,                    // lo que se ve en la tienda («la base»)
) {
    var siguiente: Int? = null                              // el marcapáginas; null = se acabó
 
    // Devuelve true si fue bien y false si falló. Nunca lanza.
    fun reponer(carga: Carga, cuantas: Int): Boolean {
        val desde = when (carga) {
            Carga.EMPEZAR -> 0                              // empezar es volver al principio
            Carga.SEGUIR -> siguiente ?: return true        // sin marcapáginas no hay nada que seguir
        }
        return try {
            val traidas = pedirAlAlmacen(cuantas, desde)
            // Todo o nada: la estantería nueva se prepara aparte y se cambia de golpe.
            val nueva = if (carga == Carga.EMPEZAR) mutableListOf() else estanteria.toMutableList()
            nueva += traidas                                // `+=` con una lista: añade todos sus elementos al final
            estanteria.clear()
            estanteria += nueva                             // lo mismo: la estantería recibe todos los de `nueva`
            // Una caja corta quiere decir que el almacén se vació.
            siguiente = if (traidas.size < cuantas) null else desde + cuantas
            println("$carga: ${estanteria.size} en la estantería, sigue en $siguiente")
            true
        } catch (e: RuntimeException) {
            // El fallo no toca la estantería: se cuenta y ya.
            println("$carga: falló (${e.message}); la estantería se queda con ${estanteria.size}")
            false
        }
    }
}
 
fun main() {
    val r = Reponedor(mutableListOf())
    r.reponer(Carga.EMPEZAR, 20)
    r.reponer(Carga.SEGUIR, 20)
    hayRed = false
    r.reponer(Carga.SEGUIR, 20)
    r.reponer(Carga.EMPEZAR, 20)
    hayRed = true
    r.reponer(Carga.SEGUIR, 20)
    r.reponer(Carga.SEGUIR, 20)
}

EMPEZAR: 20 en la estantería, sigue en 20
SEGUIR: 40 en la estantería, sigue en 40
SEGUIR: falló (sin red); la estantería se queda con 40
EMPEZAR: falló (sin red); la estantería se queda con 40
SEGUIR: 45 en la estantería, sigue en null

package com.sebastiannarvaez.pokedex.data
 
import androidx.paging.ExperimentalPagingApi
import androidx.paging.LoadType
import androidx.paging.PagingState
import androidx.paging.RemoteMediator
import androidx.room3.withWriteTransaction
import com.sebastiannarvaez.pokedex.data.local.LISTA_POKEMON
import com.sebastiannarvaez.pokedex.data.local.PokedexDatabase
import com.sebastiannarvaez.pokedex.data.local.PokemonEntity
import com.sebastiannarvaez.pokedex.data.local.RemoteKeysEntity
import com.sebastiannarvaez.pokedex.data.local.aEntidad
import kotlinx.coroutines.CancellationException
 
/**
 * Llena la base desde la red. **No** le da nada a la pantalla.
 *
 * La pantalla lee solo de la base (el `PagingSource` de Room). Cuando esa
 * lectura llega al final de lo guardado, Paging llama a este mediador para
 * que traiga la pagina siguiente y la escriba en la tabla; Room avisa del
 * cambio y la lista se repinta sola. Asi la base es la unica fuente de verdad
 * de la pantalla, y sin red se sigue viendo lo que ya se guardo.
 *
 * Es el patron que recomienda Google para «red y base de datos»:
 * https://developer.android.com/topic/libraries/architecture/paging/v3-network-db
 */
@OptIn(ExperimentalPagingApi::class)
internal class PokemonRemoteMediator(
    private val red: PokemonRepository,
    private val db: PokedexDatabase,
    /** El reloj, inyectado como en los favoritos: los tests fijan la hora. */
    private val ahora: () -> Long,
) : RemoteMediator<Int, PokemonEntity>() {
 
    private val pokemonDao = db.pokemonDao()
    private val clavesDao = db.remoteKeysDao()
 
    override suspend fun load(loadType: LoadType, state: PagingState<Int, PokemonEntity>): MediatorResult {
        val claves = clavesDao.get(LISTA_POKEMON)
 
        // Donde empieza la pagina que hay que traer.
        val offset = when (loadType) {
            // Refrescar es empezar de cero.
            LoadType.REFRESH -> 0
            // La lista solo avanza: por arriba no hay nada que cargar.
            LoadType.PREPEND -> return MediatorResult.Success(endOfPaginationReached = true)
            LoadType.APPEND -> {
                // Sin claves, el primer refresco aun no ha escrito nada: no es
                // el final, Paging volvera a llamar cuando lo haya.
                if (claves == null) return MediatorResult.Success(endOfPaginationReached = false)
                // Con claves y sin siguiente, la lista se acabo.
                claves.nextOffset ?: return MediatorResult.Success(endOfPaginationReached = true)
            }
        }
 
        val limit = state.config.pageSize
        return try {
            val pagina = red.page(limit = limit, offset = offset)
            // Si la pagina viene corta, no hay mas: igual que en el PagingSource.
            val fin = pagina.size < limit
 
            // Todo o nada: si algo falla a mitad, la base queda como estaba.
            // Sin la transaccion, un refresco podria borrar la lista y no
            // llegar a escribir la nueva, y la pantalla se quedaria vacia.
            db.withWriteTransaction {
                if (loadType == LoadType.REFRESH) {
                    pokemonDao.clearAll()
                    clavesDao.clearAll()
                }
                pokemonDao.insertAll(pagina.mapIndexed { i, p -> p.aEntidad(position = offset + i) })
                clavesDao.save(
                    RemoteKeysEntity(
                        lista = LISTA_POKEMON,
                        nextOffset = if (fin) null else offset + limit,
                        // La edad de la copia es la de su primera pagina: al
                        // ampliar se conserva la fecha del ultimo refresco.
                        actualizadoEn = if (loadType == LoadType.REFRESH) ahora()
                        else claves?.actualizadoEn ?: ahora(),
                    ),
                )
            }
            MediatorResult.Success(endOfPaginationReached = fin)
        } catch (e: CancellationException) {
            // Cancelar no es fallar: se relanza, como en el PagingSource.
            throw e
        } catch (e: Throwable) {
            // Lo guardado no se toca. Paging lo convierte en un LoadState.Error
            // del mediador, y la pantalla decide como contarlo.
            MediatorResult.Error(e)
        }
    }
 
}

src/jvmTest/kotlin/com/sebastiannarvaez/pokedex/data/PokemonRemoteMediatorTest.kt

package com.sebastiannarvaez.pokedex.data
 
import androidx.paging.ExperimentalPagingApi
import androidx.paging.LoadType
import androidx.paging.PagingConfig
import androidx.paging.PagingSource
import androidx.paging.PagingState
import androidx.paging.RemoteMediator.MediatorResult
import com.sebastiannarvaez.pokedex.data.local.LISTA_POKEMON
import com.sebastiannarvaez.pokedex.data.local.PokemonEntity
import com.sebastiannarvaez.pokedex.data.local.RemoteKeysEntity
import com.sebastiannarvaez.pokedex.data.local.createDatabase
import com.sebastiannarvaez.pokedex.data.local.getDatabaseBuilder
import com.sebastiannarvaez.pokedex.dobles.FakePokeApi
import com.sebastiannarvaez.pokedex.dobles.TestDispatchers
import kotlin.test.AfterTest
import kotlin.test.Test
import kotlin.test.assertEquals
import kotlin.test.assertIs
import kotlin.test.assertNull
import kotlinx.coroutines.test.StandardTestDispatcher
import kotlinx.coroutines.test.TestScope
import kotlinx.coroutines.test.runTest
 
/**
 * El mediador, llamado a mano: sin pantalla y sin Pager.
 *
 * Es como lo prueba la guia de Google: se le pide un `load` con un
 * `PagingState` vacio y se mira que dejo en la base. La red es el
 * `FakePokeApi` de los dobles; la base, una de verdad en memoria.
 */
@OptIn(ExperimentalPagingApi::class)
class PokemonRemoteMediatorTest {
 
    private val db = createDatabase(getDatabaseBuilder())
    private var reloj = 1_000_000L
 
    @AfterTest
    fun cerrar() = db.close()
 
    /**
     * Un mediador con su propia red. Sin conexion = otro mediador sobre la misma base.
     * Ojo: `api` vale por defecto `FakePokeApi(total, falla)`, es decir, usa los
     * dos parametros de antes. Si pasas tu propio `api`, `total` y `falla` se ignoran.
     */
    private fun TestScope.mediador(total: Int = 60, falla: Boolean = false, api: FakePokeApi = FakePokeApi(total, falla)) =
        PokemonRemoteMediator(
            red = PokemonRepository(api, TestDispatchers(StandardTestDispatcher(testScheduler))),
            db = db,
            ahora = { reloj },
        )
 
    /** Lo que Paging le pasa al mediador. Aqui solo importa el tamano de pagina. */
    private val estado = PagingState<Int, PokemonEntity>(
        pages = emptyList(),
        anchorPosition = null,
        config = PagingConfig(pageSize = 20), // las paginas de veinte de la lista
        leadingPlaceholderCount = 0,
    )
 
    private suspend fun idsGuardados(): List<Int> {
        val pagina = db.pokemonDao().pagingSource().load(
            PagingSource.LoadParams.Refresh(key = null, loadSize = 1000, placeholdersEnabled = false),
        ) as PagingSource.LoadResult.Page
        return pagina.data.map { it.id }
    }
}

    @Test
    fun refrescarLlenaLaBase() = runTest {
        val resultado = mediador().load(LoadType.REFRESH, estado)
 
        // assertIs comprueba que es un Success y, ademas, le dice a Kotlin que
        // desde aqui `resultado` ya es un Success: por eso se puede leer su
        // `endOfPaginationReached` (el compilador lo llama «smart cast»).
        assertIs<MediatorResult.Success>(resultado)
        assertEquals(false, resultado.endOfPaginationReached)
        assertEquals((1..20).toList(), idsGuardados())
        val claves = db.remoteKeysDao().get(LISTA_POKEMON)
        assertEquals(20, claves?.nextOffset)
        assertEquals(reloj, claves?.actualizadoEn)
    }
 
    @Test
    fun ampliarAnadeLaPaginaSiguiente() = runTest {
        val m = mediador()
        m.load(LoadType.REFRESH, estado)
 
        m.load(LoadType.APPEND, estado)
 
        // Del 1 al 40, en orden y sin huecos: la segunda pagina va detras.
        assertEquals((1..40).toList(), idsGuardados())
        assertEquals(40, db.remoteKeysDao().get(LISTA_POKEMON)?.nextOffset)
    }

    @Test
    fun laListaSeAcabaConLaPaginaCorta() = runTest {
        val api = FakePokeApi(total = 25)
        val m = mediador(api = api)
        m.load(LoadType.REFRESH, estado)
 
        val ultima = m.load(LoadType.APPEND, estado)
 
        assertIs<MediatorResult.Success>(ultima)
        assertEquals(true, ultima.endOfPaginationReached)
        assertNull(db.remoteKeysDao().get(LISTA_POKEMON)?.nextOffset)
 
        // Una vez acabada, ampliar ya no gasta red.
        val llamadas = api.llamadasAlListado
        val otra = m.load(LoadType.APPEND, estado)
        assertEquals(true, (otra as MediatorResult.Success).endOfPaginationReached)
        assertEquals(llamadas, api.llamadasAlListado)
    }
 
    @Test
    fun sinRedLoGuardadoSeConserva() = runTest {
        mediador().load(LoadType.REFRESH, estado)
 
        val sinRed = mediador(falla = true)
        val alAmpliar = sinRed.load(LoadType.APPEND, estado)
        val alRefrescar = sinRed.load(LoadType.REFRESH, estado)
 
        // Los dos fallan, y los dos lo dicen: no se tragan el error.
        assertIs<MediatorResult.Error>(alAmpliar)
        assertIs<MediatorResult.Error>(alRefrescar)
        // Y ninguno toca la base: el refresco fallido NO la vacia.
        assertEquals((1..20).toList(), idsGuardados())
        assertEquals(20, db.remoteKeysDao().get(LISTA_POKEMON)?.nextOffset)
    }

    @Test
    fun refrescarBorraLoViejoYEmpiezaDeCero() = runTest {
        // Una copia vieja: un Pokemon que ya no esta y claves de una copia con tres paginas.
        db.pokemonDao().insertAll(listOf(PokemonEntity(id = 999, name = "viejo", types = "", position = 0)))
        db.remoteKeysDao().save(RemoteKeysEntity(LISTA_POKEMON, nextOffset = 60, actualizadoEn = 0))
 
        mediador().load(LoadType.REFRESH, estado)
 
        assertEquals((1..20).toList(), idsGuardados())
        assertEquals(20, db.remoteKeysDao().get(LISTA_POKEMON)?.nextOffset)
    }

./gradlew :shared:jvmTest --tests "*PokemonRemoteMediatorTest*"
./gradlew :shared:jvmTest

./gradlew :shared:compileKotlinIosSimulatorArm64