Criando widgets Flutter performáticos

Aprenda técnicas para reduzir trabalho desnecessário e criar widgets Flutter mais performáticos.

Este artigo faz parte de uma série desenvolvida depois que a equipe de Material do Flutter trabalhou para tornar o app Flutter Gallery mais performático na web. No entanto, as dicas deste artigo se aplicam a todos os apps Flutter. Pule para o final para encontrar os outros artigos desta série.

Por Anthony Robledo e Pierre-Louis Guidez

Todos os widgets stateless e stateful implementam os métodos build(), que definem como eles são renderizados. Uma tela de um app pode ter centenas ou até milhares de widgets. Esses widgets podem ser construídos apenas uma vez, ou várias vezes se houver uma animação ou algum tipo de interação. Embora construir widgets seja relativamente rápido no Flutter, é preciso ficar atento a quando e ao que você decide construir.

Este artigo fala sobre construir apenas o que você precisa e apenas quando você precisa. Depois, compartilhamos como usamos essa abordagem para alcançar uma melhoria significativa de desempenho no app web Flutter Gallery. Também vamos compartilhar dicas práticas de como diagnosticar problemas semelhantes no seu app web.

Construa apenas quando necessário

Uma otimização importante é construir widgets somente quando isso for absolutamente necessário.

Chame setState() com critério

Chamar setState agenda a chamada de um método build(). Fazer isso com frequência demais pode prejudicar o desempenho de uma tela.

Considere a animação a seguir, em que a exibição da frente (a tela preta) é animada para deslizar para baixo e revelar o verso (o tabuleiro de xadrez), de forma semelhante ao comportamento de uma bottom sheet. O widget da frente é simples, mas o de trás é pesado:

Uma animação suave
Uma animação suave
dart
Stack(
   children: [
     Back(),
     PositionedTransition(
       rect: RelativeRectTween(
         begin: RelativeRect.fromLTRB(0, 0, 0, 0),
         end: RelativeRect.fromLTRB(0, MediaQuery.of(context).size.height, 0, 0),
       ).animate(_animationController),
       child: Front(),
     )
   ],
 ),

Você pode ficar tentado a configurar o widget pai assim, mas, nesse cenário, isso está errado!

dart
// BAD CODE
@override
void initState() {
 super.initState();
 _animationController = AnimationController(
   duration: Duration(seconds: 3),
   vsync: this,
 );
 _animationController.addListener(() {
   setState(() {
     // Rebuild when animation ticks.
   });
 });
}

Isso não é performático! Por quê?

Porque a animação está fazendo trabalho desnecessário.

Uma animação travada
Uma animação travada

Aqui está o código problemático:

dart
// BAD CODE
_animationController.addListener(() {
 setState(() {
   // Rebuild when animation ticks.
 });
});
  • Esse estilo de animação é recomendado quando você precisa animar o widget inteiro, mas não é isso que estamos fazendo aqui.

  • Chamar setState() no listener da animação faz com que o Stack inteiro seja reconstruído, o que não é necessário!

  • O widget PositionedTransition já é um AnimatedWidget, então ele se reconstrói automaticamente quando a animação avança.

  • Chamar setState() não é necessário aqui!

Mesmo com o widget de trás pesado, ele consegue animar suavemente a 60 FPS. Para mais sobre como chamar setState com critério, veja Animações travadas no Flutter: como não usar setState.

Construa apenas o que é necessário

Além de construir apenas quando for necessário, você quer construir somente a parte da UI que realmente muda. A seção a seguir foca em criar listas performáticas.

Prefira ListView.builder()

Primeiro, vamos cobrir brevemente o básico de exibir listas.

  1. Para organizar itens de lista verticalmente, use um Column.

  2. Se a lista deve ser rolável, use um ListView em vez disso.

  3. Se a lista tiver muitos itens, use o construtor ListView.builder, que cria os itens conforme eles entram na tela durante a rolagem, em vez de criar todos de uma vez. Isso traz benefícios óbvios de desempenho para itens de lista complexos e subárvores de widgets profundas.

Para ilustrar os benefícios de ListView.builder em relação a ListView quando você tem um grande número de itens de lista, vamos ver alguns exemplos.

Execute o ListView exemplo no DartPad a seguir. Observe que todos os 8 itens são criados. (Clique em Console no canto inferior esquerdo para exibir o console e depois clique em Executar. A janela de saída não tem barra de rolagem, mas você pode rolar o conteúdo e observar o console para ver o que é criado e construído, e quando.)

dart
ListView(
  children: [
    _ListItem(index: 0),
    _ListItem(index: 1),
    _ListItem(index: 2),
    _ListItem(index: 3),
    _ListItem(index: 4),
    _ListItem(index: 5),
    _ListItem(index: 6),
    _ListItem(index: 7),
  ],
);

Em seguida, execute o ListView.builder exemplo no DartPad. Observe que apenas os itens visíveis são criados. Conforme você rola, ele cria (e constrói) novas linhas.

dart
ListView.builder(
  itemBuilder: (context, index) {
    return _ListItem(index: index);
  },
  itemCount: 8,
);

Agora, execute o exemplo no DartPad em que os filhos de ListView são criados com antecedência, todos de uma vez, quando o próprio ListView é criado. Nesse cenário, é mais eficiente usar o construtor ListView.

dart
final listItems = [
  _ListItem(index: 0),
  _ListItem(index: 1),
  _ListItem(index: 2),
  _ListItem(index: 3),
  _ListItem(index: 4),
  _ListItem(index: 5),
  _ListItem(index: 6),
  _ListItem(index: 7),
];
​
@override
Widget build(BuildContext context) {
  // This offers no benefit, it is actually more efficient to use the ListView constructor instead.
  return ListView.builder(
    itemBuilder: (context, index) {
      return listItems[index];
    },
    itemCount: 8,
  );
}

Para mais sobre a construção preguiçosa de listas, veja Slivers, Demystified.

A Flutter Gallery oferece suporte a mais de 100 locales; esses locales são listados usando, adivinhe só, um ListView.builder. Ao obter informações de rebuild de widgets, percebemos que esses itens da lista estavam sendo construídos sem necessidade na inicialização. Não era óbvio que esses itens eram o problema, já que estavam dentro de dois níveis de menus recolhidos: o próprio painel de configurações e o expansion tile de locales (como se viu, o painel de configurações era renderizado de forma ‘invisível’ usando um ScaleTransition, o que significa que ele estava sendo construído).

Painel de configurações da Flutter Gallery com as opções de locale expandidas
Painel de configurações da Flutter Gallery com as opções de locale expandidas

Basta definir a propriedade itemCount de ListView.builder como 0 para as categorias de configuração não expandidas, e garantimos que os itens da lista sejam construídos apenas para a categoria expandida e visível. A PR de uma linha que resolveu o problema melhorou o tempo de renderização na web em mais de 2x. O segredo foi identificar a construção excessiva de widgets.

Vendo a contagem de builds de widgets do seu app

Embora o Flutter construa de forma muito eficiente, há casos em que construir em excesso pode causar problemas de desempenho. Existem algumas formas de identificar reconstruções excessivas de widgets.

Usando o Android Studio/IntelliJ

Desenvolvedores do Android Studio e do IntelliJ podem usar as ferramentas integradas para mostrar as informações de rebuild dos widgets.

Modificando o framework

Se você usa outro editor, ou quer saber as informações de rebuild dos widgets para a web, pode fazer isso adicionando um pouco de código ao framework.

Exemplo de saída:

RaisedButton 1
RawMaterialButton 2
ExpensiveWidget 538
Header 5

Localize <Flutter path>/packages/flutter/lib/src/widgets/framework.dart. Adicione o código a seguir, que conta o número de vezes que os widgets são construídos na inicialização e exibe os resultados após um intervalo (aqui, 10 segundos).

dart
bool _outputScheduled = false;
Map<String, int> _outputMap = <String, int>{};
void _output(Widget widget) {
  final String typeName = widget.runtimeType.toString();
  if (_outputMap.containsKey(typeName)) {
    _outputMap[typeName] = _outputMap[typeName] + 1;
  } else {
    _outputMap[typeName] = 1;
  }
  if (_outputScheduled) {
    return;
  }
  _outputScheduled = true;
  Timer(const Duration(seconds: 10), () {
    _outputMap.forEach((String key, int value) {
      switch (widget.runtimeType.toString()) {
        // Filter out widgets whose build counts we don't care about
        case 'InkWell':
        case 'RawGestureDetector':
        case 'FocusScope':
          break;
        default:
          print('$key $value');
      }
    });
  });
}

Depois, modifique os métodos build de StatelessElement e StatefulElement para chamar _output(widget).

dart
class StatelessElement extends ComponentElement {
  ...
​
@override
  Widget build() {
    final Widget w = widget.build(this);
    _output(w);
    return w;
   }
​
class StatefulElement extends ComponentElement {
...
​
@override
  Widget build() {
    final Widget w = _state.build(this);
    _output(w);
    return w;
  }

Veja o arquivo framework.dart resultante.

Observe que muitas reconstruções não indicam necessariamente um problema. No entanto, elas podem ajudar a depurar problemas de desempenho, verificando, por exemplo, se widgets não visíveis não estão sendo construídos.

Dica apenas para web: você pode adicionar uma função resetOutput (que pode ser chamada pelas ferramentas de desenvolvedor do navegador) para obter a contagem de builds dos widgets em qualquer momento.

dart
import 'dart:js' as js;
​
void resetOutput() {
 _outputScheduled = false;
 _outputMap = <String, int>{};
}
​
void _output(Widget widget) {
  // Add this line
  js.context['resetOutput'] = resetOutput;
  ...

Veja o arquivo framework.dart resultante.

Considerações finais

Depurar desempenho de forma eficaz exige entender o que acontece por baixo dos panos. Essas dicas podem ajudar você a decidir como implementar o próximo método build, para que seu app continue performático em todos os cenários.

Este post faz parte de uma série sobre o que aprendemos ao melhorar o desempenho da Flutter Gallery. Artigos da série Criando apps web Flutter performáticos:

Para informações mais gerais, a documentação sobre desempenho de UI do Flutter é um ótimo lugar para desenvolvedores de todos os níveis começarem.

Obrigado a Shams Zakhour por editar este artigo e a Ferhat Buyukkokten pelas dicas de depuração.

Mais do Flutter