Criar modificadores personalizados

O uso de uma fábrica de modificadores combináveis para criar um modificador também permite usar APIs de composição de nível mais alto, como animate*AsState e outras APIs de animação com suporte ao estado do Compose. Por exemplo, o snippet a seguir mostra um modificador que anima uma mudança alfa quando ativado/desativado:

@Composable
fun Modifier.fade(enable: Boolean): Modifier {
    val alpha by animateFloatAsState(if (enable) 0.5f else 1.0f)
    return this then Modifier.graphicsLayer { this.alpha = alpha }
}
CustomModifierSnippets.kt

Se o modificador personalizado for um método de conveniência para fornecer valores padrão de um CompositionLocal, a maneira mais fácil de implementar isso é usar uma fábrica de modificadores combináveis:

@Composable
fun Modifier.fadedBackground(): Modifier {
    val color = LocalContentColor.current
    return this then Modifier.background(color.copy(alpha = 0.5f))
}
CustomModifierSnippets.kt

Essa abordagem tem algumas ressalvas, que são detalhadas nas seções a seguir.

Os valores CompositionLocal são resolvidos no local de chamada da fábrica de modificadores

Ao criar um modificador personalizado usando uma fábrica de modificadores combináveis, os locais de composição recebem o valor da árvore de composição em que são criados, não usados. Isso pode levar a resultados inesperados. Por exemplo, considere o exemplo de modificador local de composição mencionado anteriormente, implementado de maneira um pouco diferente usando uma função combinável:

@Composable
fun Modifier.myBackground(): Modifier {
    val color = LocalContentColor.current
    return this then Modifier.background(color.copy(alpha = 0.5f))
}

@Composable
fun MyScreen() {
    CompositionLocalProvider(LocalContentColor provides Color.Green) {
        // Background modifier created with green background
        val backgroundModifier = Modifier.myBackground()

        // LocalContentColor updated to red
        CompositionLocalProvider(LocalContentColor provides Color.Red) {

            // Box will have green background, not red as expected.
            Box(modifier = backgroundModifier)
        }
    }
}
CustomModifierSnippets.kt

Se não for assim que você espera que o modificador funcione, use um Modifier.Node personalizado. Os locais de composição serão resolvidos corretamente no site de uso e poderão ser elevados com segurança.

Os modificadores de função combináveis nunca são ignorados

Os modificadores de fábrica combináveis nunca são ignorados porque as funções combináveis que têm valores de retorno não podem ser ignoradas. Isso significa que a função modificadora será chamada em cada recomposição, o que pode ser caro se ela for recomposta com frequência.

Os modificadores de função combináveis precisam ser chamados em uma função combinável

Como todas as funções combináveis, um modificador de fábrica combinável precisa ser chamado de dentro da composição. Isso limita o local em que um modificador pode ser elevado, já que ele nunca pode ser elevado para fora da composição. Em comparação, as fábricas de modificadores não combináveis podem ser elevadas para fora das funções combináveis para permitir uma reutilização mais fácil e melhorar a performance:

val extractedModifier = Modifier.background(Color.Red) // Hoisted to save allocations

@Composable
fun Modifier.composableModifier(): Modifier {
    val color = LocalContentColor.current.copy(alpha = 0.5f)
    return this then Modifier.background(color)
}

@Composable
fun MyComposable() {
    val composedModifier = Modifier.composableModifier() // Cannot be extracted any higher
}
CustomModifierSnippets.kt

Implementar o comportamento do modificador personalizado usando Modifier.Node

Modifier.Node é uma API de nível mais baixo para criar modificadores no Compose. É a mesma API em que o Compose implementa os próprios modificadores e é a maneira mais eficiente de criar modificadores personalizados.

Implementar um modificador personalizado usando Modifier.Node

Há três partes para implementar um modificador personalizado usando Modifier.Node:

• Uma Modifier.Node implementação que contém a lógica e o estado do modificador.
• Um ModifierNodeElement que cria e atualiza instâncias de nó modificador.
• Uma fábrica de modificadores opcional, conforme detalhado anteriormente.

As classes ModifierNodeElement não têm estado e novas instâncias são alocadas a cada recomposição, enquanto as classes Modifier.Node podem ter estado e sobreviver a várias recomposições, e até mesmo ser reutilizadas.

A seção a seguir descreve cada parte e mostra um exemplo de criação de um modificador personalizado para desenhar um círculo.

Modifier.Node

A implementação de Modifier.Node (neste exemplo, CircleNode) implementa a funcionalidade do modificador personalizado.

// Modifier.Node
private class CircleNode(var color: Color) : DrawModifierNode, Modifier.Node() {
    override fun ContentDrawScope.draw() {
        drawCircle(color)
    }
}
CustomModifierSnippets.kt

Neste exemplo, ele desenha o círculo com a cor transmitida para a função modificadora.

Um nó implementa Modifier.Node, bem como zero ou mais tipos de nó. Há diferentes tipos de nó com base na funcionalidade exigida pelo modificador. O exemplo anterior precisa ser capaz de desenhar, então ele implementa DrawModifierNode, que permite substituir o método de desenho.

Os tipos disponíveis são os seguintes:

Os nós são invalidados automaticamente quando a atualização é chamada no elemento correspondente. Como nosso exemplo é um DrawModifierNode, sempre que a atualização é chamada no elemento, o nó aciona uma nova renderização e a cor é atualizada corretamente. É possível desativar a invalidação automática, conforme detalhado na seção Desativar a invalidação automática de nós.

ModifierNodeElement

Um ModifierNodeElement é uma classe imutável que contém os dados para criar ou atualizar o modificador personalizado:

// ModifierNodeElement
private data class CircleElement(val color: Color) : ModifierNodeElement<CircleNode>() {
    override fun create() = CircleNode(color)

    override fun update(node: CircleNode) {
        node.color = color
    }
}
CustomModifierSnippets.kt

As implementações de ModifierNodeElement precisam substituir os seguintes métodos:

1. create: essa é a função que instancia o nó modificador. Ela é chamada para criar o nó quando o modificador é aplicado pela primeira vez. Normalmente, isso equivale a construir o nó e configurá-lo com os parâmetros transmitidos à fábrica de modificadores.
2. update: essa função é chamada sempre que esse modificador é fornecido no mesmo local em que o nó já existe, mas uma propriedade foi alterada. Isso é determinado pelo método equals da classe. O nó modificador criado anteriormente é enviado como um parâmetro para a chamada update. Nesse ponto, atualize as propriedades dos nós para corresponder aos parâmetros atualizados. A capacidade de reutilização dos nós dessa maneira é fundamental para os ganhos de performance que Modifier.Node oferece. Portanto, é necessário atualizar o nó atual em vez de criar um novo no método update. No exemplo do círculo, a cor do nó é atualizada.

Além disso, as implementações de ModifierNodeElement também precisam implementar equals e hashCode. update só será chamado se uma comparação de igualdade com o elemento anterior retornar "false".

O exemplo anterior usa uma classe de dados para fazer isso. Esses métodos são usados para verificar se um nó precisa ser atualizado ou não. Se o elemento tiver propriedades que não contribuem para a necessidade de atualização de um nó ou se você quiser evitar classes de dados por motivos de compatibilidade binária, implemente manualmente equals e hashCode. Por exemplo, o elemento modificador de preenchimento.

Fábrica de modificadores

Essa é a superfície da API pública do modificador. A maioria das implementações cria o elemento modificador e o adiciona à cadeia de modificadores:

// Modifier factory
fun Modifier.circle(color: Color) = this then CircleElement(color)
CustomModifierSnippets.kt

Exemplo completo

Essas três partes se unem para criar o modificador personalizado para desenhar um círculo usando as APIs Modifier.Node:

// Modifier factory
fun Modifier.circle(color: Color) = this then CircleElement(color)

// ModifierNodeElement
private data class CircleElement(val color: Color) : ModifierNodeElement<CircleNode>() {
    override fun create() = CircleNode(color)

    override fun update(node: CircleNode) {
        node.color = color
    }
}

// Modifier.Node
private class CircleNode(var color: Color) : DrawModifierNode, Modifier.Node() {
    override fun ContentDrawScope.draw() {
        drawCircle(color)
    }
}
CustomModifierSnippets.kt

Situações comuns usando Modifier.Node

Ao criar modificadores personalizados com Modifier.Node, confira algumas situações comuns que podem ocorrer.

Nenhum parâmetro

Se o modificador não tiver parâmetros, ele nunca precisará ser atualizado e, além disso, não precisará ser uma classe de dados. Confira a seguir um exemplo de implementação de um modificador que aplica uma quantidade fixa de preenchimento a um elemento combinável:

fun Modifier.fixedPadding() = this then FixedPaddingElement

data object FixedPaddingElement : ModifierNodeElement<FixedPaddingNode>() {
    override fun create() = FixedPaddingNode()
    override fun update(node: FixedPaddingNode) {}
}

class FixedPaddingNode : LayoutModifierNode, Modifier.Node() {
    private val PADDING = 16.dp

    override fun MeasureScope.measure(
        measurable: Measurable,
        constraints: Constraints
    ): MeasureResult {
        val paddingPx = PADDING.roundToPx()
        val horizontal = paddingPx * 2
        val vertical = paddingPx * 2

        val placeable = measurable.measure(constraints.offset(-horizontal, -vertical))

        val width = constraints.constrainWidth(placeable.width + horizontal)
        val height = constraints.constrainHeight(placeable.height + vertical)
        return layout(width, height) {
            placeable.place(paddingPx, paddingPx)
        }
    }
}
CustomModifierSnippets.kt

Locais de composição de referência

Os modificadores Modifier.Node não observam automaticamente as mudanças nos objetos de estado do Compose, como CompositionLocal. A vantagem dos modificadores Modifier.Node em relação aos modificadores criados apenas com uma fábrica combinável é que eles podem ler o valor do local de composição de onde o modificador é usado na árvore de interface, não onde o modificador é alocado, usando currentValueOf.

No entanto, as instâncias de nó modificador não observam automaticamente as mudanças de estado. Para reagir automaticamente a uma mudança local de composição, você pode ler o valor atual dela em um escopo:

• DrawModifierNode: ContentDrawScope
• LayoutModifierNode: MeasureScope & IntrinsicMeasureScope
• SemanticsModifierNode: SemanticsPropertyReceiver

Este exemplo observa o valor de LocalContentColor para desenhar um plano de fundo com base na cor. Como ContentDrawScope observa as mudanças de snapshot, isso é renderizado automaticamente quando o valor de LocalContentColor muda:

class BackgroundColorConsumerNode :
    Modifier.Node(),
    DrawModifierNode,
    CompositionLocalConsumerModifierNode {
    override fun ContentDrawScope.draw() {
        val currentColor = currentValueOf(LocalContentColor)
        drawRect(color = currentColor)
        drawContent()
    }
}
CustomModifierSnippets.kt

Para reagir a mudanças de estado fora de um escopo e atualizar automaticamente o modificador, use um ObserverModifierNode.

Por exemplo, Modifier.scrollable usa essa técnica para observar mudanças em LocalDensity. Um exemplo simplificado é mostrado no exemplo a seguir:

class ScrollableNode :
    Modifier.Node(),
    ObserverModifierNode,
    CompositionLocalConsumerModifierNode {

    // Place holder fling behavior, we'll initialize it when the density is available.
    val defaultFlingBehavior = DefaultFlingBehavior(splineBasedDecay(UnityDensity))

    override fun onAttach() {
        updateDefaultFlingBehavior()
        observeReads { currentValueOf(LocalDensity) } // monitor change in Density
    }

    override fun onObservedReadsChanged() {
        // if density changes, update the default fling behavior.
        updateDefaultFlingBehavior()
    }

    private fun updateDefaultFlingBehavior() {
        val density = currentValueOf(LocalDensity)
        defaultFlingBehavior.flingDecay = splineBasedDecay(density)
    }
}
CustomModifierSnippets.kt

Animar um modificador

As implementações de Modifier.Node têm acesso a um coroutineScope. Isso permite o uso das APIs Animatable do Compose. Por exemplo, este snippet modifica o CircleNode mostrado anteriormente para aparecer e desaparecer repetidamente:

class CircleNode(var color: Color) : Modifier.Node(), DrawModifierNode {
    private lateinit var alpha: Animatable<Float, AnimationVector1D>

    override fun ContentDrawScope.draw() {
        drawCircle(color = color, alpha = alpha.value)
        drawContent()
    }

    override fun onAttach() {
        alpha = Animatable(1f)
        coroutineScope.launch {
            alpha.animateTo(
                0f,
                infiniteRepeatable(tween(1000), RepeatMode.Reverse)
            ) {
            }
        }
    }
}
CustomModifierSnippets.kt

Compartilhar o estado entre modificadores usando a delegação

Os modificadores Modifier.Node podem delegar a outros nós. Há muitos casos de uso para isso, como extrair implementações comuns em diferentes modificadores, mas também pode ser usado para compartilhar o estado comum entre modificadores.

Por exemplo, uma implementação básica de um nó modificador clicável que compartilha dados de interação:

class ClickableNode : DelegatingNode() {
    val interactionData = InteractionData()
    val focusableNode = delegate(
        FocusableNode(interactionData)
    )
    val indicationNode = delegate(
        IndicationNode(interactionData)
    )
}
CustomModifierSnippets.kt

Desativar a invalidação automática de nós

Os nós Modifier.Node são invalidados automaticamente quando o ModifierNodeElement correspondente chama a atualização. Para modificadores complexos, talvez você queira desativar esse comportamento para ter um controle mais refinado sobre quando o modificador invalida as fases.

Isso é particularmente útil se o modificador personalizado modificar o layout e o desenho. A desativação da invalidação automática permite invalidar o desenho apenas quando propriedades relacionadas ao desenho, como color, mudam. Isso evita a invalidação do layout e pode melhorar a performance do modificador.

Um exemplo hipotético disso é mostrado no exemplo a seguir com um modificador que tem um lambda color, size e onClick como propriedades. Esse modificador invalida apenas o que é necessário, ignorando qualquer invalidação desnecessária:

class SampleInvalidatingNode(
    var color: Color,
    var size: IntSize,
    var onClick: () -> Unit
) : DelegatingNode(), LayoutModifierNode, DrawModifierNode {
    override val shouldAutoInvalidate: Boolean
        get() = false

    private val clickableNode = delegate(
        ClickablePointerInputNode(onClick)
    )

    fun update(color: Color, size: IntSize, onClick: () -> Unit) {
        if (this.color != color) {
            this.color = color
            // Only invalidate draw when color changes
            invalidateDraw()
        }

        if (this.size != size) {
            this.size = size
            // Only invalidate layout when size changes
            invalidateMeasurement()
        }

        // If only onClick changes, we don't need to invalidate anything
        clickableNode.update(onClick)
    }

    override fun ContentDrawScope.draw() {
        drawRect(color)
    }

    override fun MeasureScope.measure(
        measurable: Measurable,
        constraints: Constraints
    ): MeasureResult {
        val size = constraints.constrain(size)
        val placeable = measurable.measure(constraints)
        return layout(size.width, size.height) {
            placeable.place(0, 0)
        }
    }
}
CustomModifierSnippets.kt