Mover visualização usando animação com rolagem

Experimente trabalhar com o Compose

O Jetpack Compose é o kit de ferramentas de IU recomendado para Android. Aprenda a usar animações no Compose.

AnimationSpec de mola →

A animação baseada em deslizamento usa uma força de atrito proporcional à velocidade de um objeto. Use-o para animar uma propriedade de um objeto e encerrar a animação gradualmente. Ela tem um impulso inicial, que é recebido principalmente da velocidade do gesto, e desacelera gradualmente. A animação chega ao fim quando a velocidade dela é baixa o suficiente para não fazer mudanças visíveis na tela do dispositivo.

Para saber mais sobre temas relacionados, leia os seguintes guias:

• Movimento baseado em física
• Animar movimentos com física relacionada a objetos elásticos

Adicionar a biblioteca AndroidX

Para usar as animações baseadas em física, adicione a biblioteca AndroidX ao seu projeto da seguinte maneira:

1. Abra o arquivo build.gradle relativo ao módulo do seu app.
2. Adicione a biblioteca AndroidX à seção dependencies.

   Groovy

           dependencies {
               implementation 'androidx.dynamicanimation:dynamicanimation:1.0.0'
           }
           

   Kotlin

           dependencies {
               implementation("androidx.dynamicanimation:dynamicanimation:1.0.0")
           }
           

Criar uma animação de rolagem

A classe FlingAnimation permite criar uma animação de deslizamento rápido para um objeto. Para criar uma animação de deslizamento rápido, crie uma instância da classe FlingAnimation e forneça um objeto e a propriedade dele que você quer animar.

val fling = FlingAnimation(view, DynamicAnimation.SCROLL_X)

FlingAnimation fling = new FlingAnimation(view, DynamicAnimation.SCROLL_X);

Definir a velocidade

A velocidade inicial define a velocidade com que uma propriedade de animação muda no início da animação. A velocidade inicial padrão é definida como zero pixel por segundo. Portanto, é necessário definir uma velocidade inicial para garantir que a animação não termine imediatamente.

É possível usar um valor fixo como velocidade inicial ou basear esse valor na velocidade de um gesto de toque. Se você optar por fornecer um valor fixo, defina-o em dp por segundo e converta-o em pixels por segundo. Definir o valor em dp por segundo permite que a velocidade seja independente da densidade e dos formatos de um dispositivo. Para mais informações sobre como converter a velocidade inicial em pixels por segundo, consulte a seção Como converter dp por segundo em pixels por segundo em Animação de mola.

Para definir a velocidade, chame o método setStartVelocity() e transmita a velocidade em pixels por segundo. O método retorna o objeto de rolagem rápida em que a velocidade é definida.

Observação:use as classes GestureDetector.OnGestureListener e VelocityTracker para recuperar e calcular a velocidade dos gestos de toque, respectivamente.

Definir um intervalo de valores de animação

Você pode definir os valores mínimo e máximo da animação quando quiser restringir o valor da propriedade a um determinado intervalo. Esse controle de intervalo é particularmente útil ao animar propriedades que têm um intervalo intrínseco, como alfa (de 0 a 1).

Observação: quando o valor de uma animação de deslizamento rápido atinge o valor mínimo ou máximo, ela é encerrada.

Para definir os valores mínimo e máximo, chame os métodos setMinValue() e setMaxValue(), respectivamente. Ambos os métodos retornam o objeto de animação para o qual você definiu o valor.

Definir o atrito

O método setFriction() permite mudar o atrito da animação. Ele define a rapidez com que a velocidade diminui em uma animação.

Observação: se você não definir o atrito no início da animação, ela vai usar um valor padrão de 1.

O método retorna o objeto cuja animação usa o valor de fricção fornecido.

Código de amostra

O exemplo abaixo ilustra uma rolagem horizontal. A velocidade capturada do rastreador de velocidade é velocityX, e os limites de rolagem são definidos como 0 e maxScroll. O atrito é definido como 1,1.

FlingAnimation(view, DynamicAnimation.SCROLL_X).apply {
    setStartVelocity(-velocityX)
    setMinValue(0f)
    setMaxValue(maxScroll)
    friction = 1.1f
    start()
}

FlingAnimation fling = new FlingAnimation(view, DynamicAnimation.SCROLL_X);
fling.setStartVelocity(-velocityX)
        .setMinValue(0)
        .setMaxValue(maxScroll)
        .setFriction(1.1f)
        .start();

Definir a mudança mínima visível

Ao animar uma propriedade personalizada que não está definida em pixels, defina a mudança mínima do valor da animação que é visível para os usuários. Ele determina um limite razoável para encerrar a animação.

Não é necessário chamar esse método ao animar DynamicAnimation.ViewProperty porque a mudança mínima visível é derivada da propriedade. Exemplo:

• O valor padrão de mudança mínima visível é de 1 pixel para propriedades de visualização, como TRANSLATION_X, TRANSLATION_Y, TRANSLATION_Z, SCROLL_X e SCROLL_Y.
• Para animações que usam rotação, como ROTATION, ROTATION_X e ROTATION_Y, a mudança mínima visível é MIN_VISIBLE_CHANGE_ROTATION_DEGREES ou 1/10 pixel.
• Para animações que usam opacidade, a mudança visível mínima é MIN_VISIBLE_CHANGE_ALPHA ou 1/256.

Para definir a mudança mínima visível de uma animação, chame o método setMinimumVisibleChange() e transmita uma das constantes mínimas visíveis ou um valor que você precisa calcular para uma propriedade personalizada. Para mais informações sobre como calcular esse valor, consulte a seção Como calcular um valor mínimo de mudança visível.

anim.minimumVisibleChange = DynamicAnimation.MIN_VISIBLE_CHANGE_SCALE

anim.setMinimumVisibleChange(DynamicAnimation.MIN_VISIBLE_CHANGE_SCALE);

Observação: você só precisa transmitir um valor ao animar uma propriedade personalizada que não está definida em pixels.

Calcular um valor de mudança mínima visível

Para calcular o valor mínimo de mudança visível de uma propriedade personalizada, use a seguinte fórmula:

Mudança mínima visível = intervalo do valor da propriedade personalizada / intervalo da animação em pixels

Por exemplo, a propriedade que você quer animar passa de 0 para 100. Isso corresponde a uma mudança de 200 pixels. De acordo com a fórmula, o valor mínimo de mudança visível é 100 / 200, que é igual a 0,5 pixel.