Do zero ao um com Flutter, parte dois

Descobrindo como animar objetos gráficos compostos no contexto de um app mobile multiplataforma

Descobrindo como animar objetos gráficos compostos no contexto de um app mobile multiplataforma. Acompanhe um entusiasta da mineração de conceitos aprendendo a aplicar o conceito de tween à animação de valores estruturados, exemplificado por gráficos de barras. Amostras de código completas, com tudo incluído.

Edição: atualizado para Dart 2 em 8 de agosto de 2018. Repositório no GitHub e links de diff adicionados em 17 de outubro de 2018.

Como você entra em uma nova área da programação? A experimentação é obviamente a chave, assim como estudar e imitar programas escritos por colegas mais experientes. Pessoalmente, gosto de complementar essas abordagens com a mineração de conceitos: tentar trabalhar a partir de primeiros princípios, identificar conceitos, explorar a força deles e buscar deliberadamente a orientação que eles oferecem. É uma abordagem racionalista que não se sustenta sozinha, mas é intelectualmente estimulante e pode levar a insights mais profundos mais rapidamente.

Esta é a segunda e última parte de uma introdução ao Flutter e aos seus conceitos de widget e tween. No final da parte um, nós chegamos a uma árvore de widgets contendo, entre vários widgets de layout e de gerenciamento de estado,

  • um widget para pintar uma única Bar usando código de desenho personalizado e sensível à animação,

  • um widget de floating action button para iniciar uma mudança animada na altura da barra.

Animando a altura da barra.
Animando a altura da barra.

A animação foi implementada usando um BarTween, e eu afirmei que o conceito de tween escalaria para lidar com situações mais complexas. Aqui, na parte dois, vou cumprir essa afirmação, generalizando o design para barras com mais propriedades e para gráficos de barras contendo várias barras em diferentes configurações.

Vamos começar adicionando cor à nossa barra única. Adicionamos um campo color ao lado do campo height da classe Bar, e atualizamos Bar.lerp para fazer lerp dos dois. Esse padrão é comum:

Faça lerp entre valores compostos fazendo lerp dos componentes correspondentes.

Lembre-se da parte um: “lerp” é a forma abreviada de “linearly interpolate”, ou seja, interpolação linear.

dart
import 'dart:ui' show lerpDouble;
​
import 'package:flutter/animation.dart';
import 'package:flutter/material.dart';
​
class Bar {
  Bar(this.height, this.color);
​
  final double height;
  final Color color;
​
  static Bar lerp(Bar begin, Bar end, double t) {
    return Bar(
      lerpDouble(begin.height, end.height, t),
      Color.lerp(begin.color, end.color, t),
    );
  }
}
​
class BarTween extends Tween<Bar> {
  BarTween(Bar begin, Bar end) : super(begin: begin, end: end);
​
  @override
  Bar lerp(double t) => Bar.lerp(begin, end, t);
}

Repare na utilidade do idiom do método estático lerp aqui. Sem Bar.lerp, lerpDouble (na prática double.lerp), e Color.lerp, teríamos que implementar BarTween criando um Tween<double> para a altura e um Tween<Color> para a cor. Esses tweens seriam campos de instância de BarTween, inicializados pelo seu construtor e usados no seu método lerp. Estaríamos duplicando o conhecimento sobre as propriedades de Bar várias vezes, fora da classe Bar. Quem mantém nosso código provavelmente acharia isso menos que ideal.

Animando a altura e a cor da barra.
Animando a altura e a cor da barra.

Para usar barras coloridas no nosso app, vamos atualizar BarChartPainter para obter a cor da barra a partir do Bar. Em main.dart, precisamos ser capazes de criar um Bar vazio e um Bar aleatório. Vamos usar uma cor totalmente transparente para o primeiro e uma cor aleatória para o segundo. As cores virão de uma ColorPalette simples, que apresentamos rapidamente em um arquivo próprio. Vamos fazer tanto Bar.empty quanto Bar.random serem construtores de fábrica em Bar (listagem de código, diff).

Gráficos de barras envolvem várias barras em diferentes configurações. Para introduzir complexidade aos poucos, nossa primeira implementação será adequada para gráficos de barras que exibem quantidades numéricas para um conjunto fixo de categorias. Exemplos incluem visitantes por dia da semana ou vendas por trimestre. Para esses gráficos, trocar o conjunto de dados por outra semana ou outro ano não muda as categorias usadas, apenas a barra exibida para cada categoria.

Vamos atualizar primeiro main.dart desta vez, substituindo Bar por BarChart e BarTween por BarChartTween (listagem de código, diff).

Para deixar o analisador do Dart satisfeito, criamos a classe BarChart em bar.dart e a implementamos usando uma lista de tamanho fixo de instâncias de Bar. Vamos usar cinco barras, uma para cada dia útil da semana. Depois, precisamos mover a responsabilidade de criar instâncias vazias e aleatórias de Bar para BarChart. Com categorias fixas, um gráfico de barras vazio é razoavelmente considerado uma coleção de barras vazias. Por outro lado, fazer com que um gráfico de barras aleatório seja uma coleção de barras aleatórias deixaria nossos gráficos bem caleidoscópicos. Em vez disso, vamos escolher uma cor aleatória para o gráfico e deixar cada barra, ainda com altura aleatória, herdar essa cor.

dart
import 'dart:math';
import 'dart:ui' show lerpDouble;
​
import 'package:flutter/animation.dart';
import 'package:flutter/material.dart';
​
import 'color_palette.dart';
​
class BarChart {
  static const int barCount = 5;
​
  BarChart(this.bars) {
    assert(bars.length == barCount);
  }
​
  factory BarChart.empty() {
    return BarChart(List.filled(
      barCount,
      Bar(0.0, Colors.transparent),
    ));
  }
​
  factory BarChart.random(Random random) {
    final Color color = ColorPalette.primary.random(random);
    return BarChart(List.generate(
      barCount,
      (i) => Bar(random.nextDouble() * 100.0, color),
    ));
  }
​
  final List<Bar> bars;
​
  static BarChart lerp(BarChart begin, BarChart end, double t) {
    return BarChart(List.generate(
      barCount,
      (i) => Bar.lerp(begin.bars[i], end.bars[i], t),
    ));
  }
}
​
class BarChartTween extends Tween<BarChart> {
  BarChartTween(BarChart begin, BarChart end) : super(begin: begin, end: end);
​
  @override
  BarChart lerp(double t) => BarChart.lerp(begin, end, t);
}
​
class Bar {
  Bar(this.height, this.color);
​
  final double height;
  final Color color;
​
  static Bar lerp(Bar begin, Bar end, double t) {
    return Bar(
      lerpDouble(begin.height, end.height, t),
      Color.lerp(begin.color, end.color, t),
    );
  }
}
​
class BarTween extends Tween<Bar> {
  BarTween(Bar begin, Bar end) : super(begin: begin, end: end);
​
  @override
  Bar lerp(double t) => Bar.lerp(begin, end, t);
}
​
class BarChartPainter extends CustomPainter {
  static const barWidthFraction = 0.75;
​
  BarChartPainter(Animation<BarChart> animation)
      : animation = animation,
        super(repaint: animation);
​
  final Animation<BarChart> animation;
​
  @override
  void paint(Canvas canvas, Size size) {
    void drawBar(Bar bar, double x, double width, Paint paint) {
      paint.color = bar.color;
      canvas.drawRect(
        Rect.fromLTWH(x, size.height - bar.height, width, bar.height),
        paint,
      );
    }
​
    final paint = Paint()..style = PaintingStyle.fill;
    final chart = animation.value;
    final barDistance = size.width / (1 + chart.bars.length);
    final barWidth = barDistance * barWidthFraction;
    var x = barDistance - barWidth / 2;
    for (final bar in chart.bars) {
      drawBar(bar, x, barWidth, paint);
      x += barDistance;
    }
  }
​
  @override
  bool shouldRepaint(BarChartPainter old) => false;
}

O BarChartPainter distribui a largura disponível igualmente entre as barras e faz com que cada barra ocupe 75% da largura disponível para ela.

Gráfico de barras de categorias fixas.
Gráfico de barras de categorias fixas.

Repare como BarChart.lerp é implementado em termos de Bar.lerp, regenerando a estrutura de lista na hora. Gráficos de barras de categorias fixas são valores compostos para os quais faz sentido o lerp componente a componente, exatamente como para barras únicas com várias propriedades (diff).

Há um padrão em jogo aqui. Quando o construtor de uma classe Dart recebe vários parâmetros, você frequentemente pode fazer lerp de cada parâmetro separadamente, e a combinação ficará boa também. E você pode aninhar esse padrão arbitrariamente: um dashboard faria lerp a partir do lerp dos seus gráficos de barras constituintes, que por sua vez fazem lerp a partir do lerp das suas barras, e estas, do lerp da sua altura e cor. E cores são interpoladas fazendo lerp dos seus componentes RGB e alfa. Nas folhas dessa recursão, fazemos lerp de números.

Os matematicamente inclinados podem expressar isso dizendo que o lerp comuta com a estrutura, no sentido de que, para valores compostos *C*(*x*, *y*), temos

*lerp*(*C*(*x*1, *y*1), *C*(*x*2, *y*2), *t*) == *C*(*lerp*(*x*1, *x*2, *t*), *lerp*(*y*1, *y*2, *t*))

Como vimos, isso generaliza bem de dois componentes (altura e cor de uma barra) para um número arbitrário de componentes (as n barras de um gráfico de barras de categorias fixas).

No entanto, há situações em que essa bela imagem deixa de funcionar. Podemos querer animar entre dois valores que não são compostos exatamente da mesma forma. Como exemplo simples, considere animar de um gráfico de barras com dados dos cinco dias úteis da semana para um gráfico que inclua também o fim de semana.

Você pode facilmente chegar a várias soluções ad hoc diferentes para esse problema e, então, pedir ao seu designer de UX que escolha entre elas. Essa é uma abordagem válida, embora eu acredite que vale a pena ter em mente, durante a discussão, a estrutura fundamental comum a essas diferentes soluções: o tween. Lembre-se da parte um:

Anime T traçando um caminho no espaço de todos os T possíveis conforme o valor da animação vai de zero a um. Modele o caminho com um Tween<T>.

A pergunta central a responder com o designer de UX é esta: quais são os valores intermediários entre um gráfico com cinco barras e outro com sete? Uma escolha óbvia é ter seis barras, mas precisamos de mais valores intermediários do que isso para animar suavemente. Precisamos desenhar as barras de forma diferente, saindo do domínio das barras de largura igual e uniformemente espaçadas, ajustadas a 200 pixels. Em outras palavras, o espaço de valores T precisa ser generalizado.

Faça lerp entre valores com estruturas diferentes incorporando-os em um espaço de valores mais gerais, que engloba, como casos especiais, tanto os extremos da animação quanto todos os valores intermediários necessários.

Podemos fazer isso em dois passos. Primeiro, generalizamos Bar para incluir sua coordenada x e sua largura como atributos:

dart
class Bar {
  Bar(this.x, this.width, this.height, this.color);
​
  final double x;
  final double width;
  final double height;
  final Color color;
​
  static Bar lerp(Bar begin, Bar end, double t) {
    return Bar(
      lerpDouble(begin.x, end.x, t),
      lerpDouble(begin.width, end.width, t),
      lerpDouble(begin.height, end.height, t),
      Color.lerp(begin.color, end.color, t),
    );
  }
}

Segundo, fazemos BarChart suportar gráficos com quantidades de barras diferentes. Nossos novos gráficos serão adequados para conjuntos de dados em que a barra i representa o i-ésimo valor de alguma série, como vendas no dia i após o lançamento de um produto. Pensando como programadores, qualquer gráfico desse tipo envolve uma barra para cada valor inteiro de 0 a n, mas a quantidade de barras n pode ser diferente de um gráfico para o próximo.

Considere dois gráficos com cinco e sete barras, respectivamente. As barras para as cinco categorias em comum, 0..5, podem ser animadas de forma composicional, como vimos acima. As barras com índice 5 e 6 não têm equivalente no outro extremo da animação, mas, como agora somos livres para dar a cada barra sua própria posição e largura, podemos introduzir duas barras invisíveis para fazer esse papel. O efeito visual é que as barras 5 e 6 crescem até sua aparência final conforme a animação avança. Animando no sentido contrário, as barras 5 e 6 diminuiriam ou desapareceriam gradualmente.

Faça lerp entre valores compostos fazendo lerp dos componentes correspondentes. Quando um componente está ausente em um dos extremos, use um componente invisível em seu lugar.

Há frequentemente várias maneiras de escolher componentes invisíveis. Digamos que nosso amigável designer de UX decidiu usar barras de largura zero e altura zero, com coordenada x e cor herdadas da sua contraparte visível. Vamos adicionar um método a Bar para criar uma versão colapsada de uma instância dada.

dart
class BarChart {
  BarChart(this.bars);
​
  final List<Bar> bars;
​
  static BarChart lerp(BarChart begin, BarChart end, double t) {
    final barCount = max(begin.bars.length, end.bars.length);
    final bars = List.generate(
      barCount,
      (i) => Bar.lerp(
            begin._barOrNull(i) ?? end.bars[i].collapsed,
            end._barOrNull(i) ?? begin.bars[i].collapsed,
            t,
          ),
    );
    return BarChart(bars);
  }
​
  Bar _barOrNull(int index) => (index < bars.length ? bars[index] : null);
}
​
class BarChartTween extends Tween<BarChart> {
  BarChartTween(BarChart begin, BarChart end) : super(begin: begin, end: end);
​
  @override
  BarChart lerp(double t) => BarChart.lerp(begin, end, t);
}
​
class Bar {
  Bar(this.x, this.width, this.height, this.color);
​
  final double x;
  final double width;
  final double height;
  final Color color;
​
  Bar get collapsed => Bar(x, 0.0, 0.0, color);
​
  static Bar lerp(Bar begin, Bar end, double t) {
    return Bar(
      lerpDouble(begin.x, end.x, t),
      lerpDouble(begin.width, end.width, t),
      lerpDouble(begin.height, end.height, t),
      Color.lerp(begin.color, end.color, t),
    );
  }
}

Integrar o código acima ao nosso app envolve redefinir BarChart.empty e BarChart.random para essa nova configuração. Um gráfico de barras vazio agora pode razoavelmente conter zero barras, enquanto um aleatório pode conter uma quantidade aleatória de barras, todas da mesma cor escolhida aleatoriamente, e cada uma com altura escolhida aleatoriamente. Mas, como posição e largura agora fazem parte da definição de Bar, precisamos que BarChart.random especifique esses atributos também. Parece razoável fornecer BarChart.random com o parâmetro Size do gráfico e, então, aliviar BarChartPainter.paint da maior parte de seus cálculos (listagem de código, diff).

Fazendo lerp de e para barras invisíveis.
Fazendo lerp de e para barras invisíveis.

O leitor atento pode ter notado uma possível ineficiência na nossa definição de BarChart.lerp acima. Estamos criando instâncias colapsadas de Bar apenas para serem passadas como argumentos para Bar.lerp, e isso acontece repetidamente, para cada valor do parâmetro de animação t. A 60 quadros por segundo, isso pode significar muitas instâncias de Bar sendo enviadas ao coletor de lixo, mesmo para uma animação relativamente curta. Existem alternativas:

  • Instâncias colapsadas de Bar podem ser reutilizadas se forem criadas apenas uma vez na classe Bar, em vez de a cada chamada de collapsed. Essa abordagem funciona aqui, mas não é geralmente aplicável.

  • O reuso pode ser feito por BarChartTween em vez disso, fazendo com que seu construtor crie uma lista _tween de instâncias de BarTween usadas durante a criação do gráfico de barras interpolado: (i) => _tweens[i].lerp(t). Essa abordagem quebra com a convenção de usar métodos lerp estáticos em todo lugar. Não há um objeto envolvido no BarChart.lerp estático no qual armazenar a lista de tweens durante a duração da animação. O objeto BarChartTween, por outro lado, é perfeitamente adequado para isso.

  • Uma barra null pode ser usada para representar uma barra colapsada, assumindo uma lógica condicional adequada em Bar.lerp. Essa abordagem é elegante e eficiente, mas exige cuidado para evitar desreferenciar ou interpretar erroneamente null. Ela é comumente usada no SDK do Flutter, onde métodos lerp estáticos tendem a aceitar null como extremo da animação, normalmente interpretando-o como algum tipo de elemento invisível, como uma cor totalmente transparente ou um elemento gráfico de tamanho zero. Como exemplo mais básico, lerpDouble trata null como zero, a menos que ambos os extremos da animação sejam null.

O trecho abaixo mostra o código que escreveríamos seguindo a abordagem null:

dart
class BarChart {
  BarChart(this.bars);
​
  final List<Bar> bars;
​
  static BarChart lerp(BarChart begin, BarChart end, double t) {
    final barCount = max(begin.bars.length, end.bars.length);
    final bars = List.generate(
      barCount,
      (i) => Bar.lerp(begin._barOrNull(i), end._barOrNull(i), t),
    );
    return BarChart(bars);
  }
​
  Bar _barOrNull(int index) => (index < bars.length ? bars[index] : null);
}
​
class BarChartTween extends Tween<BarChart> {
  BarChartTween(BarChart begin, BarChart end) : super(begin: begin, end: end);
​
  @override
  BarChart lerp(double t) => BarChart.lerp(begin, end, t);
}
​
class Bar {
  Bar(this.x, this.width, this.height, this.color);
​
  final double x;
  final double width;
  final double height;
  final Color color;
​
  static Bar lerp(Bar begin, Bar end, double t) {
    if (begin == null && end == null)
      return null;
    return Bar(
      lerpDouble((begin ?? end).x, (end ?? begin).x, t),
      lerpDouble(begin?.width, end?.width, t),
      lerpDouble(begin?.height, end?.height, t),
      Color.lerp((begin ?? end).color, (end ?? begin).color, t),
    );
  }
}

Acho justo dizer que a sintaxe ? do Dart é bem adequada para a tarefa. Mas repare como a decisão de usar barras colapsadas (em vez de, digamos, transparentes) como elementos invisíveis agora está enterrada na lógica condicional em Bar.lerp. Essa é a principal razão pela qual escolhi a solução aparentemente menos eficiente antes. Como sempre em questões de desempenho versus manutenibilidade, sua escolha deve se basear em medições.

Ainda precisamos dar mais um passo antes de abordar a animação de gráficos de barras em toda a sua generalidade. Considere um app que usa um gráfico de barras para mostrar vendas por categoria de produto para um determinado ano. A pessoa usuária pode selecionar outro ano, e o app deve então animar para o gráfico de barras daquele ano. Se as categorias de produto fossem as mesmas nos dois anos, ou fossem iguais exceto por algumas categorias adicionais exibidas à direita em um dos gráficos, poderíamos usar o código existente acima. Mas e se a empresa tivesse as categorias de produto A, B, C e X em 2016, mas tivesse descontinuado B e introduzido D em 2017? Nosso código atual animaria assim:

2016  2017
  A -> A
  B -> C
  C -> D
  X -> X

A animação poderia ser bonita e suave, mas ainda assim seria confusa para a pessoa usuária. Por quê? Porque não preserva a semântica. Ela transforma um elemento gráfico que representa a categoria de produto B em outro que representa a categoria C, enquanto o que representa C vai para outro lugar. Só porque o B de 2016 acontece de ser desenhado na mesma posição onde o C de 2017 aparece depois, não significa que o primeiro deva se transformar no segundo. Em vez disso, o B de 2016 deveria desaparecer, o C de 2016 deveria se mover para a esquerda e se transformar no C de 2017, e o D de 2017 deveria aparecer à sua direita. Podemos implementar essa mistura usando um dos algoritmos mais antigos do livro: a intercalação de listas ordenadas.

Faça lerp entre valores compostos fazendo lerp dos componentes semanticamente correspondentes. Quando os componentes formam listas ordenadas, o algoritmo de merge pode colocar esses componentes no mesmo nível, usando componentes invisíveis conforme necessário para lidar com merges de um só lado.

Tudo o que precisamos é tornar as instâncias de Bar mutuamente comparáveis em uma ordem linear. Assim, podemos fazer o merge da seguinte forma:

dart
  static BarChart lerp(BarChart begin, BarChart end, double t) {
    final bars = <Bar>[];
    final bMax = begin.bars.length;
    final eMax = end.bars.length;
    var b = 0;
    var e = 0;
    while (b + e < bMax + eMax) {
      if (b < bMax && (e == eMax || begin.bars[b] < end.bars[e])) {
        bars.add(Bar.lerp(begin.bars[b], begin.bars[b].collapsed, t));
        b++;
      } else if (e < eMax && (b == bMax || end.bars[e] < begin.bars[b])) {
        bars.add(Bar.lerp(end.bars[e].collapsed, end.bars[e], t));
        e++;
      } else {
        bars.add(Bar.lerp(begin.bars[b], end.bars[e], t));
        b++;
        e++;
      }
    }
    return BarChart(bars);
  }

Concretamente, vamos atribuir a cada barra uma chave de ordenação na forma de um atributo inteiro rank. A posição (rank) pode então ser convenientemente usada também para atribuir a cada barra uma cor da paleta, permitindo acompanhar o movimento de barras individuais na demo da animação.

Um gráfico de barras aleatório agora será baseado em uma seleção aleatória de ranks a incluir (listagem de código, diff).

Categorias arbitrárias. Lerp baseado em merge.
Categorias arbitrárias. Lerp baseado em merge.

Isso funciona bem, mas talvez não seja a solução mais eficiente. Estamos executando repetidamente o algoritmo de merge em BarChart.lerp, uma vez para cada valor de t. Para corrigir isso, vamos implementar a ideia mencionada antes de armazenar informações reutilizáveis em BarChartTween.

dart
class BarChartTween extends Tween<BarChart> {
  BarChartTween(BarChart begin, BarChart end) : super(begin: begin, end: end) {
    final bMax = begin.bars.length;
    final eMax = end.bars.length;
    var b = 0;
    var e = 0;
    while (b + e < bMax + eMax) {
      if (b < bMax && (e == eMax || begin.bars[b] < end.bars[e])) {
        _tweens.add(BarTween(begin.bars[b], begin.bars[b].collapsed));
        b++;
      } else if (e < eMax && (b == bMax || end.bars[e] < begin.bars[b])) {
        _tweens.add(BarTween(end.bars[e].collapsed, end.bars[e]));
        e++;
      } else {
        _tweens.add(BarTween(begin.bars[b], end.bars[e]));
        b++;
        e++;
      }
    }
  }
​
  final _tweens = <BarTween>[];
​
  @override
  BarChart lerp(double t) => BarChart(
        List.generate(
          _tweens.length,
          (i) => _tweens[i].lerp(t),
        ),
      );
}

Agora podemos remover o método BarChart.lerp estático (diff).

Vamos resumir o que aprendemos sobre o conceito de tween até agora:

Anime T traçando um caminho no espaço de todos os T possíveis conforme o valor da animação vai de zero a um. Modele o caminho com um Tween<T>.

Generalize o conceito de T conforme necessário, até que ele englobe todos os extremos da animação e todos os valores intermediários.

Faça lerp entre valores compostos fazendo lerp dos componentes correspondentes.

  • A correspondência deve se basear na semântica, não em coincidências gráficas acidentais.

  • Quando um componente está ausente em um dos extremos da animação, use um componente invisível em seu lugar, possivelmente derivado do outro extremo.

  • Quando os componentes formam listas ordenadas, use o algoritmo de merge para colocar componentes semanticamente correspondentes no mesmo nível, introduzindo componentes invisíveis conforme necessário para lidar com merges de um só lado.

Considere implementar tweens usando métodos Xxx.lerp estáticos para facilitar o reuso em implementações de tween compostas. Quando houver recálculo significativo entre chamadas a Xxx.lerp para um único caminho de animação, considere mover o cálculo para o construtor da classe XxxTween, e deixe suas instâncias guardarem o resultado do cálculo.

Armados com essas ideias, finalmente estamos em posição de animar gráficos mais complexos. Faremos barras empilhadas, barras agrupadas e barras empilhadas+agrupadas em rápida sucessão:

  • Barras empilhadas são usadas para conjuntos de dados em que as categorias são bidimensionais e faz sentido somar a quantidade numérica representada pelas alturas das barras. Um exemplo seria receita por produto e região geográfica. Empilhar por produto facilita comparar o desempenho dos produtos no mercado global. Empilhar por região mostra quais regiões são importantes.
Barras empilhadas.
Barras empilhadas.
  • Barras agrupadas também são usadas para conjuntos de dados com categorias bidimensionais, mas em que não é significativo ou desejável empilhar as barras. Por exemplo, se a quantidade numérica for a participação de mercado em percentual por produto e região, empilhar por produto não faz sentido. Mesmo quando empilhar faz sentido, agrupar pode ser preferível, pois facilita comparações quantitativas nas duas dimensões de categoria ao mesmo tempo.
Barras agrupadas.
Barras agrupadas.
  • Barras empilhadas+agrupadas suportam categorias tridimensionais, como receita por produto, região geográfica e canal de vendas.
Barras empilhadas+agrupadas.
Barras empilhadas+agrupadas.

Nas três variantes, a animação pode ser usada para visualizar mudanças nos conjuntos de dados, introduzindo assim uma dimensão adicional (normalmente o tempo) sem poluir os gráficos.

Para que a animação seja útil e não apenas bonita, precisamos garantir que fazemos lerp apenas entre componentes semanticamente correspondentes. Assim, o segmento da barra usado para representar a receita de um determinado produto/região/canal em 2016 deve se transformar naquele que representa a receita do mesmo produto/região/canal em 2017 (se presente).

O algoritmo de merge pode ser usado para garantir isso. Como você deve ter adivinhado pela discussão anterior, o merge será usado em vários níveis, refletindo a dimensionalidade das categorias. Faremos o merge de stacks e barras em gráficos empilhados, de grupos e barras em gráficos agrupados, e dos três em gráficos empilhados+agrupados.

Para fazer isso sem muita duplicação de código, vamos abstrair o algoritmo de merge em um utilitário geral e colocá-lo em um arquivo próprio, tween.dart:

dart
import 'package:flutter/animation.dart';
import 'package:flutter/material.dart';
​
abstract class MergeTweenable<T> {
  T get empty;
​
  Tween<T> tweenTo(T other);
​
  bool operator <(T other);
}
​
class MergeTween<T extends MergeTweenable<T>> extends Tween<List<T>> {
  MergeTween(List<T> begin, List<T> end) : super(begin: begin, end: end) {
    final bMax = begin.length;
    final eMax = end.length;
    var b = 0;
    var e = 0;
    while (b + e < bMax + eMax) {
      if (b < bMax && (e == eMax || begin[b] < end[e])) {
        _tweens.add(begin[b].tweenTo(begin[b].empty));
        b++;
      } else if (e < eMax && (b == bMax || end[e] < begin[b])) {
        _tweens.add(end[e].empty.tweenTo(end[e]));
        e++;
      } else {
        _tweens.add(begin[b].tweenTo(end[e]));
        b++;
        e++;
      }
    }
  }
​
  final _tweens = <Tween<T>>[];
​
  @override
  List<T> lerp(double t) => List.generate(
        _tweens.length,
        (i) => _tweens[i].lerp(t),
      );
}

A interface MergeTweenable<T> captura precisamente o que é necessário para criar um tween entre duas listas ordenadas de Ts por merge. Vamos instanciar o parâmetro de tipo T com Bar, BarStack e BarGroup, e fazer com que todos esses tipos implementem MergeTweenable<T> (diff).

As implementações empilhada (diff), agrupada (diff) e empilhada+agrupada (diff) foram escritas para serem diretamente comparáveis. Encorajo você a brincar com o código:

  • Altere o número de grupos, stacks e barras criados por BarChart.random.

  • Altere as paletas de cores. Para barras empilhadas+agrupadas usei uma paleta monocromática, porque acho que fica mais bonito. Você e seu designer de UX podem discordar.

  • Substitua BarChart.random e o floating action button por um seletor de ano e crie instâncias de BarChart a partir de conjuntos de dados realistas.

  • Implemente gráficos de barras horizontais.

  • Implemente outros tipos de gráfico (pizza, linha, área empilhada). Anime-os usando MergeTweenable<T> ou similar.

  • Adicione legendas e/ou rótulos e eixos aos gráficos e depois anime-os também.

As tarefas dos dois últimos itens são bastante desafiadoras. Divirta-se.

Mais do Flutter