A intuição
Um composable que recompõe a cada pixel de rolagem e outro que apenas remede podem parecer idênticos no preview. Na tela, só um deles acompanha o display, e a diferença nunca está no estado em si, mas em qual fase o lê.
Todo frame passa por três fases, cada uma com seu próprio snapshot observer que só reexecuta para leituras de estado que aconteceram dentro daquela fase:
- Composição: o que existe (a mais cara)
- Layout: onde/quão grande (média)
- Desenho: quais pixels (a mais barata)
O custo não é uniforme entre elas: composição é a fase mais cara de reexecutar, layout é média, desenho é a mais barata.
Então a pergunta que importa não é onde esse valor é usado, é em qual fase estou lendo isso, porque é isso que responde qual é a fase mais barata em que essa leitura pode cair.
Essa hierarquia de custo só importa porque as três fases compartilham um mesmo prazo: o relógio de atualização do display. Composição, layout e desenho precisam terminar antes do próximo tique de , ou o frame anterior é exibido de novo (um frame perdido, visível como engasgo).
| Taxa de atualização | Orçamento por frame |
|---|---|
| 60 Hz | 16,6 ms |
| 90 Hz | 11,1 ms |
| 120 Hz | 8,3 ms |
Esse orçamento compartilhado também é compartilhado de forma desigual: uma recomposição desnecessária custa o mais caro, um re-layout desnecessário custa menos, e um redesenho desnecessário custa o mínimo.
A 120 Hz você só tem 8,3 ms no total para as três fases mais a GPU, então um composable que recompõe a cada pixel de rolagem é a primeira coisa a estourar o orçamento e causar um engasgo.
Dica 1: Recomposição, leia tarde, não cedo
// ❌ offsetPx embutido na cadeia de Modifier em tempo de composição →
// toda mudança reconstrói a cadeia → recompõe a cada pixel de rolagem
Modifier.offset(x = offsetPx.dp)
// ✅ offsetPx lido dentro da lambda de posicionamento, não passado como valor →
// a identidade do Modifier permanece estável, só o posicionamento reexecuta
Modifier.offset { IntOffset(0, offsetPx.roundToInt()) }Modifier.offset(x: Dp, y: Dp) recebe valores simples, então
offsetPx.dp precisa ser resolvido antes da cadeia de Modifier
existir, durante a composição. Toda mudança produz um novo Modifier
e força uma recomposição.
Modifier.offset { IntOffset(...) }, em vez disso, armazena a própria
lambda e só a chama durante o posicionamento, parte da fase de layout,
então a identidade do Modifier nunca muda e a composição nunca
reexecuta. Mesmo State, mesmo efeito na tela, fase diferente
pagando a conta.
A única exceção
Se um nó existe ou não (visible de AnimatedVisibility) precisa
ser decidido na composição; layout e desenho só podem mover ou
repintar o que a composição já emitiu.
Dica 2: Layout, restrições descem, tamanhos sobem, o pai decide a posição
// ❌ lido no corpo do composable → mudança de heightPx recompõe
val heightPx = lerp(maxHeightPx, minHeightPx, collapseFraction()).roundToInt()
Modifier.layout { measurable, constraints ->
val placeable = measurable.measure(constraints.copy(maxHeight = heightPx))
layout(placeable.width, heightPx) {
placeable.placeRelative(0, 0)
}
}
// ✅ lido dentro da própria lambda do modifier → só remede, sem recomposição
Modifier.layout { measurable, constraints -> // constraints: a caixa que devo satisfazer
val heightPx = lerp(maxHeightPx, minHeightPx, collapseFraction()).roundToInt()
val placeable = measurable.measure( // measurable: pendente, sem tamanho até eu chamar isso
constraints.copy(maxHeight = heightPx) // eu escolho o que repassar para baixo (altura fixada)
)
layout(placeable.width, heightPx) { // eu reporto MEU tamanho para cima, ao meu pai
placeable.placeRelative(0, 0) // só eu decido onde o filho fica
}
}Um filho só pode escolher um tamanho dentro da caixa [min, max] que
seu pai lhe entrega; ele nunca escolhe sua própria posição.
Modifier.layout lê estado na fase de layout, custo médio, mais barato
que a composição mas mais caro que o desenho. Então heightPx
precisa ser lido dentro da lambda, mesma lição da Dica 1, ou cada
pixel de arraste de colapso recompõe em vez de apenas remedir.
Dica 3: DrawScope, pixels, origem no canto superior esquerdo e traços centralizados
// ❌ lido no corpo do composable → mudança de progress recompõe
val progress = scrollProgress()
Modifier.drawBehind {
val stroke = 8.dp.toPx()
// recua a metade da largura do traço, ou a metade externa é cortada
drawCircle(Color.Blue.copy(alpha = progress),
radius = size.minDimension / 2 - stroke / 2, style = Stroke(stroke))
}
// ✅ lido dentro da própria lambda do drawBehind → só redesenha, sem recomposição
Modifier.drawBehind {
val stroke = 8.dp.toPx()
val progress = scrollProgress()
drawCircle(Color.Blue.copy(alpha = progress),
radius = size.minDimension / 2 - stroke / 2, style = Stroke(stroke))
}Dentro de DrawScope, tudo já está em pixels, a origem é no
canto superior esquerdo, +y vai para baixo. Traços são
centralizados no caminho, não dentro dele, daí o recuo de meia
espessura acima, ou a metade externa é cortada.
drawBehind: pinta apenas antes do conteúdo próprio do nó, em toda passagem de desenho, sem cache. A opção mais simples quando você só precisa de algo por baixo.drawWithContent: você mesmo chamadrawContent(), então você controla a ordem: antes, depois, ou ambos, colocando essa chamada onde quiser em relação ao seu próprio desenho.drawWithCache: a lambda externa só reexecuta quando o tamanho/layout muda, não a cada frame; construa objetos caros (Brush,Path,Shader) ali uma única vez, e então retorne um blocoonDrawBehind { }ouonDrawWithContent { }que os reutiliza em cada desenho real.
Desenho é a mais barata das três fases para reexecutar, então
progress precisa ser lido dentro de qualquer uma dessas que você
usar, mesma lição das Dicas 1 e 2: ler aqui nunca força uma
re-medição, muito menos uma recomposição.
Em outros lugares: o mesmo fundamento, framework diferente
- Pipeline de renderização do navegador (CSS): recálculo de estilo,
layout (reflow), pintura, composição, a mesma ordem de custo sob
outro nome. Animar
transform/opacityvai direto para a composição, sem reflow nem repintura; animarwidth/topforça o pipeline completo. O conselho de "ficar na thread de composição" é a Dica 1 e 3 deste post, só que enquadrado como dica de performance do DevTools do navegador em vez de uma dica de Compose. - Flutter: a mesma divisão em três fases, soletrada como build,
layout, paint, com
markNeedsBuild(),markNeedsLayout()emarkNeedsPaint()como os três botões literais de invalidação em umRenderObject. Chamar o mais barato que ainda está correto é exatamente a mesma disciplina de ler o estado na fase certa do Compose. - Sistema
Viewclássico do Android:invalidate()(apenas desenho) versusrequestLayout()(medição e layout, depois desenho) é o ancestral direto da distinção das Dicas 2 e 3, menos uma fase de composição, já que o sistemaViewnunca foi declarativo desde o início. - UIKit:
setNeedsDisplay()versussetNeedsLayout()traça a mesma linha, menos uma fase de composição, igual ao sistemaViewclássico acima. - SwiftUI: a mesma divisão em três fases, soletrada como
reavaliação do body (composição),
sizeThatFits/placeSubviewsdo protocoloLayout(layout), eGraphicsContextdoCanvas(desenho), mesmo espaço de pixels, origem no canto superior esquerdo, mesma pegadinha de traço centralizado doDrawScope. O "leia tarde, não cedo" da Dica 1 tem uma contrapartida direta emAnimatable: umShapeouViewModifierdeclaravar animatableData, e o SwiftUI interpola e rerrenderiza isso a cada frame via layout/desenho sem nunca reinvocar obody.



