Android Academy · Lezione

Perché usare il paging

Il costo di caricare tutto in una volta

Perché usare il paging è una lezione Android Academy gratuita su CoddyKit. Questa è la lezione 1 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento Android Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Android Academy include 4 lezioni in totale.

Caricare tutto è costoso

Immagini un feed con 50.000 elementi. Se li recupera e li mantiene tutti in memoria contemporaneamente, spreca memoria, rallenta la rete e blocca l'interfaccia mentre viene analizzata la risposta.

La maggior parte degli utenti scorre solo le prime schermate. Il paging consiste nel caricare i dati in piccoli blocchi (pagine) man mano che l'utente scorre, invece di caricarli tutti subito.

Il problema nel codice

Un approccio ingenuo carica l'intero elenco in memoria. Anche se il server lo supporta, la risposta può essere enorme e l'elenco analizzato può occupare la maggior parte dell'heap.

Questo schema non è scalabile e, con dataset di grandi dimensioni, rischia di causare OutOfMemoryError.

// 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) }
}

Com'è fatta una pagina

Una pagina è una piccola porzione del dataset, spesso composta da 20-50 elementi. Il server restituisce una pagina insieme a un riferimento alla pagina successiva (un numero, un offset o un token).

L'app mantiene in memoria solo poche pagine ed elimina quelle vecchie quando l'utente si allontana scorrendo.

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

Ecco Paging 3

Paging 3 è la libreria Jetpack che gestisce per Lei tutti gli aspetti complessi della paginazione:

Richiedere la pagina successiva quando l'utente si avvicina alla fine dell'elenco
Mantenere in memoria solo una finestra di elementi
Esporre gli stati di caricamento e di errore
Supporto integrato per coroutine, Flow e Jetpack Compose

Aggiunta della dipendenza

Paging 3 viene distribuito come artefatti separati: un runtime e un'integrazione con Compose. Li aggiunga nel file build.gradle.kts del modulo.

L'artefatto paging-compose fornisce helper per LazyColumn.

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

I tre elementi fondamentali

Paging 3 ruota attorno a tre tipi che utilizzerà continuamente:

PagingSource - sa come caricare una pagina da una sorgente
Pager - configura e produce un flusso di dati paginati
PagingData - il contenitore degli elementi, emessi come Flow

Costruiremo ciascuno di questi elementi nelle prossime lezioni.

PagingData e il Flow

Il repository espone un Flow<PagingData<T>>. L'interfaccia utente lo raccoglie e visualizza gli elementi attualmente caricati.

Non deve mai assemblare manualmente l'elenco completo: Paging trasmette gli elementi all'interfaccia utente su richiesta.

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 controlla la finestra

PagingConfig regola il modo in cui Paging carica e conserva i dati:

pageSize - numero di elementi per richiesta di pagina
prefetchDistance - distanza dal bordo alla quale attivare il caricamento successivo
enablePlaceholders - mostrare slot segnaposto per gli elementi non ancora caricati
maxSize - limite al numero di elementi conservati in memoria

import androidx.paging.PagingConfig

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

Rete o database, oppure entrambi

Un PagingSource può recuperare dati da un'API REST, da un database Room o da qualsiasi sorgente personalizzata.

Per una vera esperienza offline-first, combini le due sorgenti con un RemoteMediator (che verrà illustrato nell'ultima lezione): la rete riempie un database locale e l'interfaccia utente esegue la paginazione su quel database.

Scorrimento fluido, meno memoria

Con la paginazione, lo scorrimento rimane fluido perché ogni richiesta è minima e la finestra in memoria è limitata da maxSize.

Gli indicatori di caricamento e di errore sono disponibili automaticamente tramite LoadState, quindi può mostrare un indicatore nella parte inferiore o un pulsante per riprovare senza dover gestire manualmente lo stato.

// 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()
}

Quando serve la paginazione

Scelga Paging 3 quando:

Il dataset è grande o non ha dimensioni finite (feed, risultati di ricerca, cronologia delle chat)
I dati provengono da un'API di rete che restituisce pagine o cursori
Desidera una gestione automatica dell'interfaccia di caricamento/errore e della memoria

Per un elenco breve e fisso (ad esempio un menu delle impostazioni), un semplice LazyColumn è più facile da usare e va benissimo.

Verifica rapida

Qual è il principale vantaggio dell'utilizzo di Paging 3 per un elenco di grandi dimensioni?

Riepilogo: perché usare Paging

Ha imparato perché caricare tutto in una volta penalizza le prestazioni e la memoria e come Paging 3 risolve il problema.

I dati vengono caricati in piccole pagine mentre l'utente scorre
I tre elementi fondamentali sono PagingSource, Pager e PagingData
PagingConfig regola le dimensioni delle pagine, il prefetch e la finestra di memoria
Paging si integra con coroutine, Flow e Compose e fornisce automaticamente gli stati di caricamento/errore

Prossimo argomento: creare un PagingSource e collegarlo a un Pager.

Domande Frequenti

La lezione «Perché usare il paging» è gratuita?

Sì — il testo completo di «Perché usare il paging» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso Android Academy, passa a CoddyKit PRO. Il corso Android Academy include 4 lezioni in totale.

Cosa imparerò in «Perché usare il paging»?

Il costo di caricare tutto in una volta Eserciti Android Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare Android Academy?

Non è richiesta alcuna esperienza precedente. Android Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 1 di 4.

Quanto tempo richiede la lezione «Perché usare il paging»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione Android Academy?

Sì. Ogni lezione Android Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

← Torna a Android Academy