Gerenciamento de animações com Flutter e Flux/Redux
As arquiteturas de aplicação Flux e Redux funcionam bem com frameworks de view reativos como o Flutter
As arquiteturas Flux e Redux funcionam bem com frameworks de interface reativos como o Flutter. As duas arquiteturas compartilham duas ideias poderosas: criar um fluxo de dados unidirecional na aplicação e uma separação clara entre a lógica de negócio e a lógica de apresentação.
Nem sempre fica claro onde encaixar o gerenciamento de estado das animações dentro dessas arquiteturas. Esta é uma proposta de uma forma simples de incorporar a lógica de animação em aplicações Redux ou Flux.
Esta é uma versão expandida de uma lightning talk que dei na DartConf 2018: Gerenciamento de animações com Flutter e Redux (YouTube).
O jogo 2048
Para fins desta discussão, vou explicar a abordagem percorrendo uma implementação de exemplo do jogo 2048 usando Flutter e uma arquitetura Redux.
(Caso você não conheça o jogo, experimente esta versão web.)
Criando o 2048 com Flutter e Redux (sem animações)
O exemplo usa um fluxo de dados típico do Redux:

Os dados fluem da seguinte forma:
A view responde aos eventos do usuário despachando actions para a store do Redux.
A store calcula novos estados da aplicação em resposta às actions e publica esses estados.
Os estados publicados são consumidos pela lógica da view, que atualiza a tela.
O estado do jogo é definido por uma matriz 4x4 de inteiros (uma lista de listas em Dart). Zeros representam células vazias, e valores inteiros representam cada tile:
[0, 0, 0, 2],
[0, 0, 0, 4],
[0, 0, 0, 0],
[0, 0, 0, 0],
Representa:

O estado do jogo oferece quatro operações: moveLeft, moveRight, moveUp e moveDown.
Aqui está um exemplo de teste unitário para a operação moveRight:
test('move right', () {
BoardState state = new BoardState([
[0, 2, 0, 0],
[0, 2, 0, 2],
[8, 0, 4, 4],
[2, 2, 0, 2],
]);
expect(state.moveRight().tiles, [
[0, 0, 0, 2],
[0, 0, 0, 4],
[0, 0, 8, 8],
[0, 0, 2, 4],
]);
});
O usuário move os tiles com um gesto de arrastar. O código da UI configura um gesture detector e responde aos eventos de arraste despachando actions para a store. O gesture detector é definido assim:
return new GestureDetector(
behavior: HitTestBehavior.opaque,
onHorizontalDragEnd: (DragEndDetails d) {
if (d.primaryVelocity > 0) {
GameRedux.dispatch(context, moveRight());
} else {
GameRedux.dispatch(context, moveLeft());
}
},
//...
Por fim, a UI precisa atualizar a tela sempre que o estado do jogo muda. Sem introduzir animações, isso é direto: a UI assina as atualizações da store e reconstrói a árvore de widgets do Flutter toda vez que a store publica um novo estado.
Até aqui, mantivemos uma separação clara entre a lógica da UI (mapear um estado da aplicação para uma árvore de widgets e os handlers de eventos que despacham actions) e a lógica de negócio (a store).
Adicionando animações de transição
O jogo 2048 não é o mesmo sem animações, e queremos adicioná-las:

Nem sempre fica claro onde manter a lógica de animação numa arquitetura Redux. Até agora, nosso jogo de exemplo tem uma separação clara entre lógica de negócio e lógica de UI, mas onde colocar o código de animação?
Uma abordagem possível é rastrear a posição intermediária de cada tile como parte do estado da aplicação, na store. Isso, na prática, torna a animação parte da lógica de negócio.
Outra abordagem, a que eu prefiro neste caso, coloca essa animação (assim como todas as animações “cosméticas”) na camada de apresentação. Isso simplifica o grafo de estados e a nossa lógica de negócio.
Estados de transição “cosméticos” e “reais”
Fazemos distinção entre 2 tipos de estados de transição:
-
Real estado de transição A aplicação espera por um evento externo (que não seja um tick de animação). Por exemplo, um arquivo está carregando, ou a lente da câmera está se movendo para a posição. Durante a transição (o arquivo está carregando, a lente está se movendo), a aplicação precisa esperar, então o usuário também precisa esperar.
-
Estado de transição cosmético A aplicação faz algo parecer, de forma sintética, durar mais do que realmente dura. Por exemplo, animar os tiles deslizando é uma transição cosmética: nada impede a aplicação de processar imediatamente o próximo evento como se a transição já tivesse terminado. Transições cosméticas costumam ser usadas para deixar a experiência do usuário mais fluida.
Algumas observações a mais sobre transições cosméticas:
-
Elas costumam ser curtas, já que queremos que a aplicação pareça responsiva, e não queremos introduzir atrasos desnecessários (ou irritantes).
-
São comuns em apps mobile e, na nossa experiência, podem gerar bugs por causa de conflitos de transição (mais sobre isso abaixo).
-
Elas existem para criar uma UX mais agradável, então preferimos mantê-las fora da camada de lógica de negócio.
Animações “fire-and-forget”
Para executar uma animação, o estado dela (progresso) precisa ser rastreado em algum lugar. Frequentemente usamos abstrações “fire-and-forget” com animações, basicamente delegando o gerenciamento do estado da animação para outro código. Uma desvantagem do “fire-and-forget” é que limitamos a visibilidade e o controle que temos sobre o progresso da animação (e, assim, a flexibilidade do que pode ser feito enquanto ela roda). A vantagem é que isso mantém o código que chama mais simples (sem precisar gerenciar o estado da animação), e delegar esse gerenciamento permite que o framework otimize o desempenho. Por exemplo, no Android, algumas animações “fire-and-forget” são executadas na RenderThread.
Descobrindo se e qual transição mostrar
Nosso exemplo mantém a lógica de animação na camada de UI, que reconstrói a árvore de widgets em resposta às atualizações de estado.
O primeiro problema que encontramos é que a atualização da store, que inclui apenas o último estado, não é informação suficiente para descobrir qual transição mostrar.
Por exemplo, quando a UI recebe uma atualização da store com o seguinte estado:
[0, 0, 0, 2],
[0, 0, 0, 4],
[0, 0, 0, 0],
[0, 0, 0, 0]
Só com essa informação, é possível mostrar qualquer uma das seguintes transições:



Para lidar com essa ambiguidade, fornecemos mais informações nas atualizações da store: além do novo estado, a atualização inclui o estado anterior e a ação que disparou a atualização. Essa tripla é suficiente para descobrir qual transição devemos disparar (*):


- Considerando que estamos partindo de um estado sem transição; veja mais sobre isso abaixo.
Conflitos de transição
Uma coisa que precisamos levar em conta é que o usuário pode disparar eventos enquanto uma animação está em andamento. Por exemplo, enquanto os tiles deslizam para a direita, o usuário pode deslizar para cima, interrompendo a primeira animação.
Conflitos de transição são uma causa comum de bugs em aplicações. Às vezes, animações entram em conflito (mesmo quando aparentemente não têm relação entre si), deixando a UI em um estado inconsistente. Esses bugs podem ser difíceis de diagnosticar: um usuário relata que a UI está inconsistente, e não sabe como reproduzir (o que geralmente acaba sendo algo como “toque no botão A e toque rapidamente no botão B”).
Às vezes, esses bugs não são fáceis de corrigir, e os desenvolvedores recorrem a uma solução rápida e improvisada, como “desabilite o botão A enquanto a animação estiver rodando”, o que pode introduzir bugs mais sutis. Um exemplo desse tipo de bug que se tornou público é o bug “1+2+3” da calculadora do iPhone. (Você já lidou com um bug de conflito de animação que possa compartilhar publicamente? Adoraria ouvir sobre isso nos comentários!)
Lidando com conflitos de transição
As animações do jogo 2048 são transições “cosméticas”: são curtas e não devem atrasar o usuário de realizar a próxima ação. Além disso, a camada de lógica de negócio não conhece essas transições. Em qualquer momento, a UI pode disparar uma ação (moveLeft/moveRight/…) e a store publica um novo estado para a UI.
É assim que o código da UI responde às atualizações de estado:
Encerrar quaisquer transições em andamento.
-
Calcular a próxima transição com base na tripla (previousState, action, state) publicada com a atualização da store.
“Fire-and-forget” a animação de transição. (*)
Vejamos o que acontece quando ocorre um conflito de transição. Na gravação de tela a seguir, deslizo para a esquerda e, enquanto os tiles deslizam para a esquerda, deslizo para baixo (os círculos brancos são indicadores de toque):

Isso resulta em um efeito de jump cut: a animação moveLeft termina imediatamente, e a animação moveDown começa.
Embora nem sempre seja a forma ideal de resolver conflitos de animação, defendo que, neste caso e em muitos outros casos de conflitos de transição cosmética, o jump cut é uma solução aceitável. Animações de transição cosméticas costumam ser curtas (a animação foi artificialmente desacelerada na gravação anterior), o que faz o jump cut parecer natural e responsivo.
Obtemos essa resolução padrão de conflitos “de graça” desde que a nossa UI mantenha este contrato: Dado que a última atualização da store foi (stateA, action, stateB), a UI está mostrando o stateB ou mostrando uma transição para o stateB. Se você estiver usando Flutter, provavelmente é isso que a sua UI já faz.
Observe que o código da nossa UI faz um gerenciamento de estado mínimo e simples: ele apenas mantém a capacidade de encerrar uma transição em andamento.
- Não é exatamente “fire-and-forget”, já que precisamos fornecer uma forma de encerrar a animação.
Uma resolução de conflito de animação mais elegante
Para componentes em que o jump cut não é suficiente, você pode gerenciar mais do estado da animação na camada de UI e fornecer um tratamento personalizado para conflitos de transição. Essa abordagem não ajuda com a resolução personalizada de conflitos de animação, mas também não a torna mais difícil. A vantagem é que você usa o tratamento personalizado onde quiser, e os outros conflitos caem por padrão no efeito jump cut.
Resumo
Neste artigo, implementamos o jogo 2048 com uma arquitetura Redux simples, mantendo uma separação limpa entre a lógica de negócio e a de apresentação. Mantivemos o gerenciamento de estado das transições cosméticas fora da lógica de negócio. Por fim, conseguimos manter um gerenciamento de estado mínimo na camada de UI e resolvemos conflitos de animação de forma simples e razoável.
Você pode encontrar o código de exemplo do 2048 (não polido!) no GitHub.