Android Academy · Aula

Recomposição explicada

Entenda como o Compose atualiza a interface.

Recomposição explicada é uma aula grátis de Android Academy no CoddyKit. Esta é a aula 2 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.

O que é recomposição?

Recomposição é o Compose executar novamente suas funções composáveis para atualizar a interface quando o estado que elas leem muda. É assim que a tela permanece sincronizada com seus dados.

Acionada por leituras do estado

O Compose acompanha quais elementos composáveis leem cada estado. Quando um valor de estado muda, somente os elementos composáveis que o leram são programados para serem recompostos.

Inteligente e seletiva

A recomposição é seletiva: o Compose tenta executar novamente o mínimo possível. Uma alteração em uma parte do estado não redesenha a tela inteira — apenas as partes que dependem dela.

Ignorando execuções

Se as entradas de um elemento composável não mudaram, o Compose pode ignorar completamente sua nova execução. Isso mantém a recomposição barata até mesmo em telas complexas.

Os elementos composáveis são executados com frequência

Como a recomposição pode ocorrer com frequência e em qualquer ordem, seus elementos composáveis devem ser seguros para serem executados novamente. Chamá-los várias vezes deve produzir a mesma interface para o mesmo estado.

Evite efeitos colaterais

Não execute efeitos colaterais (chamadas de rede, gravação de arquivos ou alteração de variáveis compartilhadas) diretamente no corpo de um elemento composável. Eles podem ser executados a cada recomposição. Em vez disso, use o estado e as APIs de efeitos.

// BAD: runs on every recomposition
@Composable
fun Bad() {
    saveToDatabase()
    Text("Hi")
}

Independência da ordem

Você não pode depender de que os elementos composáveis sejam executados em uma ordem específica ou em uma thread específica. Trate cada chamada como independente. Essa liberdade permite que o Compose faça otimizações tão agressivas.

Ler versus não ler

Somente os elementos composáveis que leem um estado são recompostos quando ele muda. Se um Text nunca lê count, alterar count não o afetará.

@Composable
fun Demo() {
    var count by remember { mutableStateOf(0) }
    Text("Static")          // never recomposes from count
    Text("Count: $count")    // recomposes when count changes
    Button(onClick = { count++ }) { Text("+") }
}

Evite loops de recomposição

Gravar no estado durante a composição (e não dentro de um evento) pode causar um loop infinito de recomposição. Atualize o estado somente a partir de retornos de chamada como onClick, nunca diretamente no corpo.

Parece automático

Do seu ponto de vista, a recomposição é automática. Você declara a interface como uma função do estado, altera o estado nos retornos de chamada, e o Compose executa novamente os elementos composáveis corretos.

Juntando tudo

Este contador demonstra a recomposição: tocar nele altera count, o Compose executa novamente o Text que faz a leitura, e o novo número aparece.

@Composable
fun Counter() {
    var count by remember { mutableStateOf(0) }
    Button(onClick = { count++ }) {
        Text(text = "Count: $count")
    }
}

Verificação rápida

Quando o Compose recompõe um elemento composável?

Recapitulação

Essenciais da recomposição:

Alterações no estado acionam a execução novamente dos elementos composáveis que leem esse estado.
Ela é seletiva e pode ignorar elementos composáveis que não foram alterados.
Os elementos composáveis devem não produzir efeitos colaterais e ser seguros para executar novamente em qualquer ordem.

Perguntas Frequentes

A aula “Recomposição explicada” é grátis?

Sim — o texto completo de “Recomposição explicada” é 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 “Recomposição explicada”?

Entenda como o Compose atualiza a interface. 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 2 de 4.

Quanto tempo leva a aula “Recomposição explicada”?

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