Android Academy · Lección

Por qué usar Paging

El coste de cargarlo todo de una vez

Por qué usar Paging es una lección gratuita de Android Academy en CoddyKit. Esta es la lección 1 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de Android Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de Android Academy incluye 4 lecciones en total.

Cargarlo todo es costoso

Imagine un feed con 50,000 elementos. Si los obtiene y mantiene todos a la vez, desperdicia memoria, ralentiza la red y congela la interfaz mientras se analiza la respuesta.

La mayoría de los usuarios solo recorren las primeras pantallas. La paginación consiste en cargar los datos en pequeños bloques (páginas) a medida que el usuario se desplaza, en lugar de cargarlos todos al principio.

El problema en el código

Un enfoque ingenuo carga la lista completa en memoria. Aunque el servidor lo admita, la respuesta puede ser enorme y la lista analizada puede ocupar la mayor parte del heap.

Este patrón no escala y puede provocar OutOfMemoryError con conjuntos de datos grandes.

// Anti-pattern: load the whole table at once
suspend fun loadAllArticles(): List<Article> {
    // Could be tens of thousands of rows / megabytes of JSON
    return api.getArticles(limit = 50_000)
}

// UI holds ALL of them in memory at once
val articles = loadAllArticles()
LazyColumn {
    items(articles) { article -> ArticleRow(article) }
}

Cómo es una página

Una página es una pequeña parte del conjunto de datos, normalmente de 20 a 50 elementos. El servidor devuelve una página junto con un indicador de la siguiente (un número, un desplazamiento o un token).

La aplicación mantiene solo unas pocas páginas en memoria y descarta las anteriores cuando el usuario deja de desplazarse por ellas.

data class ArticlePage(
    val items: List<Article>,
    val nextKey: Int?   // null means no more pages
)

// Example REST call returning one page
suspend fun getArticlePage(page: Int, size: Int = 20): ArticlePage

Conozca Paging 3

Paging 3 es la biblioteca de Jetpack que se encarga de todas las partes complejas de la paginación:

Solicitar la siguiente página cuando el usuario se acerca al final de la lista
Mantener solo una ventana de elementos en memoria
Exponer los estados de carga y error
Compatibilidad integrada con coroutines, Flow y Jetpack Compose

Cómo añadir la dependencia

Paging 3 se distribuye como artefactos independientes: uno de ejecución y otro de integración con Compose. Añádalos al archivo build.gradle.kts de su módulo.

El artefacto paging-compose proporciona funciones auxiliares para LazyColumn.

// build.gradle.kts (module)
dependencies {
    val pagingVersion = "3.3.6"
    implementation("androidx.paging:paging-runtime:$pagingVersion")
    implementation("androidx.paging:paging-compose:$pagingVersion")
}

Las tres piezas principales

Paging 3 gira en torno a tres tipos que utilizará una y otra vez:

PagingSource - sabe cómo cargar una página desde un origen
Pager - configura y produce un flujo de datos paginados
PagingData - el contenedor de elementos, emitido como un Flow

Crearemos cada uno de ellos en las próximas lecciones.

PagingData y el Flow

Su repositorio expone un Flow<PagingData<T>>. La interfaz de usuario lo recopila y muestra los elementos que están cargados en ese momento.

Usted nunca tiene que ensamblar la lista completa; Paging transmite los elementos a la interfaz de usuario bajo demanda.

import androidx.paging.Pager
import androidx.paging.PagingConfig
import androidx.paging.PagingData
import kotlinx.coroutines.flow.Flow

class ArticleRepository(private val api: ArticleApi) {
    fun articles(): Flow<PagingData<Article>> = Pager(
        config = PagingConfig(pageSize = 20)
    ) {
        ArticlePagingSource(api)
    }.flow
}

PagingConfig controla la ventana

PagingConfig ajusta cómo Paging carga y conserva los datos:

pageSize - elementos por solicitud de página
prefetchDistance - distancia hasta el borde a la que se activa la siguiente carga
enablePlaceholders - muestra espacios reservados para los elementos que aún no se han cargado
maxSize - límite de elementos que se conservan en memoria

import androidx.paging.PagingConfig

val config = PagingConfig(
    pageSize = 20,
    prefetchDistance = 5,
    enablePlaceholders = false,
    maxSize = 100
)

Red o base de datos, o ambas

Un PagingSource puede obtener datos de una API REST, una base de datos de Room o cualquier origen personalizado.

Para lograr una verdadera experiencia offline-first, puede combinar ambos mediante un RemoteMediator (que se explica en la última lección): la red llena una base de datos local y la interfaz de usuario obtiene las páginas de esa base de datos.

Desplazamiento fluido y menos memoria

Con la paginación, el desplazamiento sigue siendo fluido porque cada solicitud es pequeña y la ventana en memoria está limitada por maxSize.

Los indicadores de carga y error están disponibles mediante LoadState, por lo que puede mostrar un indicador de carga al final o un botón de reintento sin tener que gestionar ese estado manualmente.

// LoadState exposes loading/error per direction
when (val state = adapterLoadState.append) {
    is LoadState.Loading -> showBottomSpinner()
    is LoadState.Error -> showRetry(state.error)
    is LoadState.NotLoading -> hideBottomSpinner()
}

Cuándo necesita paginación

Utilice Paging 3 cuando:

El conjunto de datos sea grande o ilimitado (feeds, resultados de búsqueda, historial de chat)
Los datos provengan de una API de red que devuelva páginas o cursores
Quiera una interfaz automática para los estados de carga y error, además de controlar el uso de memoria

Para una lista corta y fija (como un menú de ajustes), un LazyColumn normal es más sencillo y perfectamente válido.

Comprobación rápida

¿Cuál es la principal ventaja de usar Paging 3 para una lista grande?

Resumen: por qué usar Paging

Ha aprendido por qué cargarlo todo de una vez perjudica el rendimiento y el uso de memoria, y cómo Paging 3 resuelve este problema.

Los datos se cargan en pequeñas páginas mientras el usuario se desplaza
Las tres piezas principales son PagingSource, Pager y PagingData
PagingConfig ajusta el tamaño de página, la precarga y la ventana de memoria
Paging se integra con coroutines, Flow y Compose, y proporciona estados de carga y error automáticamente

Siguiente: crear un PagingSource y conectarlo a un Pager.

Preguntas frecuentes

¿La lección «Por qué usar Paging» es gratis?

Sí — el texto completo de «Por qué usar Paging» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de Android Academy, actualiza a CoddyKit PRO. El curso de Android Academy incluye 4 lecciones en total.

¿Qué aprenderé en «Por qué usar Paging»?

El coste de cargarlo todo de una vez Practicas Android Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar Android Academy?

No se requiere experiencia previa. Android Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 1 de 4.

¿Cuánto tiempo toma la lección «Por qué usar Paging»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de Android Academy?

Sí. Cada lección de Android Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

← Volver a Android Academy