Android Academy · Aula

Por que usar paginação

O custo de carregar tudo de uma vez.

Por que usar paginação é uma aula grátis de Android Academy no CoddyKit. Esta é a aula 1 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Android Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Android Academy inclui 4 aulas no total.

Carregar tudo é caro

Imagine um feed com 50.000 itens. Se você buscar e mantiver todos de uma vez, desperdiçará memória, deixará a rede mais lenta e congelará a interface enquanto a resposta é analisada.

A maioria dos usuários só percorre as primeiras telas. Paginação significa carregar os dados em pequenos blocos (páginas) conforme o usuário rola a tela, em vez de carregar tudo de uma vez.

O problema no código

Uma abordagem ingênua carrega a lista inteira na memória. Mesmo que o servidor ofereça suporte a isso, a resposta pode ser enorme, e a lista analisada ocupa a maior parte do heap.

Esse padrão não escala e pode causar OutOfMemoryError em conjuntos de dados 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) }
}

Como é uma página

Uma página é uma pequena parte do conjunto de dados, geralmente com 20 a 50 itens. O servidor retorna uma página e um ponteiro para a próxima página (um número, deslocamento ou token).

O aplicativo mantém apenas algumas páginas na memória e descarta as antigas conforme o usuário se afasta delas ao rolar.

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

Conheça o Paging 3

O Paging 3 é a biblioteca do Jetpack que cuida de todas as partes complexas da paginação para você:

Solicitar a próxima página quando o usuário se aproxima do fim da lista
Manter apenas uma janela de itens na memória
Disponibilizar estados de carregamento e erro
Oferecer suporte integrado a corrotinas, Flow e Jetpack Compose

Adicionando a dependência

O Paging 3 é distribuído como artefatos separados: um de execução e outro de integração com o Compose. Adicione-os ao arquivo build.gradle.kts do módulo.

O artefato paging-compose fornece 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")
}

As três partes principais

O Paging 3 gira em torno de três tipos que você usará repetidamente:

PagingSource - sabe como carregar uma página de uma fonte
Paginação - configura e produz um fluxo de dados paginados
PagingData - o contêiner de itens, emitido como um Flow

Criaremos cada um deles nas próximas lições.

PagingData e o Flow

Seu repositório expõe um Flow<PagingData<T>>. A interface coleta esse fluxo e renderiza os itens que estão carregados no momento.

Você nunca precisa montar a lista inteira por conta própria: a paginação envia os itens para a interface sob 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 a janela

PagingConfig ajusta como a paginação carrega e mantém os dados:

pageSize - itens por solicitação de página
prefetchDistance - distância até a borda que dispara o próximo carregamento
enablePlaceholders - exibir espaços reservados para itens ainda não carregados
maxSize - limite de itens mantidos na memória

import androidx.paging.PagingConfig

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

Rede ou banco de dados — ou ambos

Uma PagingSource pode obter dados de uma API REST, de um banco de dados Room ou de qualquer fonte personalizada.

Para uma experiência realmente baseada no uso off-line, combine os dois com um RemoteMediator (abordado na última lição): a rede preenche um banco de dados local, e a interface pagina os dados desse banco.

Rolagem suave, menos memória

Com a paginação, a rolagem permanece suave porque cada solicitação é pequena e a janela mantida na memória é limitada por maxSize.

Os indicadores de carregamento e erro são disponibilizados automaticamente por meio de LoadState, permitindo exibir um indicador na parte inferior ou um botão de nova tentativa sem precisar controlar isso 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()
}

Quando você precisa de paginação

Use o Paging 3 quando:

O conjunto de dados for grande ou ilimitado (feeds, resultados de pesquisa, histórico de conversas)
Os dados vierem de uma API de rede que retorne páginas ou cursores
Você quiser uma interface automática de carregamento/erro e controle de memória

Para uma lista curta e fixa (como um menu de configurações), uma LazyColumn simples é mais prática e funciona perfeitamente.

Verificação rápida

Qual é o principal benefício de usar o Paging 3 para uma lista grande?

Recapitulação: por que usar paginação

Você aprendeu por que carregar tudo de uma vez prejudica o desempenho e a memória, e como o Paging 3 resolve esse problema.

Os dados são carregados em pequenas páginas conforme o usuário rola
As três partes principais são PagingSource, Pager e PagingData
PagingConfig ajusta o tamanho da página, a pré-busca e a janela de memória
A paginação integra-se a corrotinas, Flow e Compose, além de fornecer estados de carregamento/erro automaticamente

Próximo: criar uma PagingSource e conectá-la a um Pager.

Perguntas Frequentes

A aula “Por que usar paginação” é grátis?

Sim — o texto completo de “Por que usar paginação” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Android Academy, atualize para CoddyKit PRO. O curso de Android Academy inclui 4 aulas no total.

O que vou aprender em “Por que usar paginação”?

O custo de carregar tudo de uma vez. Você pratica Android Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Android Academy?

Nenhuma experiência prévia é necessária. Android Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 1 de 4.

Quanto tempo leva a aula “Por que usar paginação”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Android Academy?

Sim. Cada aula de Android Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

← Voltar para Android Academy