Recomposed
Recomposition

Recomposição, Layout e DrawScope: Uma Ideia, Três Fases

Oct 4, 2026 · 5 min read

Recomposição, Layout e DrawScope: Uma Ideia, Três Fases

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çãoOrçamento por frame
60 Hz16,6 ms
90 Hz11,1 ms
120 Hz8,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 chama drawContent(), 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 bloco onDrawBehind { } ou onDrawWithContent { } 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/opacity vai direto para a composição, sem reflow nem repintura; animar width/top forç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() e markNeedsPaint() como os três botões literais de invalidação em um RenderObject. Chamar o mais barato que ainda está correto é exatamente a mesma disciplina de ler o estado na fase certa do Compose.
  • Sistema View clássico do Android: invalidate() (apenas desenho) versus requestLayout() (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 sistema View nunca foi declarativo desde o início.
  • UIKit: setNeedsDisplay() versus setNeedsLayout() traça a mesma linha, menos uma fase de composição, igual ao sistema View clássico acima.
  • SwiftUI: a mesma divisão em três fases, soletrada como reavaliação do body (composição), sizeThatFits/placeSubviews do protocolo Layout (layout), e GraphicsContext do Canvas (desenho), mesmo espaço de pixels, origem no canto superior esquerdo, mesma pegadinha de traço centralizado do DrawScope. O "leia tarde, não cedo" da Dica 1 tem uma contrapartida direta em Animatable: um Shape ou ViewModifier declara var animatableData, e o SwiftUI interpola e rerrenderiza isso a cada frame via layout/desenho sem nunca reinvocar o body.
Keep reading

Related reads

Receba novos posts no seu e-mail