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:
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!
// 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.
Aqui está o código problemático:
// 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 oStackinteiro seja reconstruído, o que não é necessário! -
O widget
PositionedTransitionjá é umAnimatedWidget, 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.
Para organizar itens de lista verticalmente, use um
Column.Se a lista deve ser rolável, use um
ListViewem vez disso.-
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.)
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.
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.
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.
Como melhoramos o tempo de renderização da página web da Flutter Gallery em mais de 2x com uma única linha de código
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).
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).
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).
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.
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:
-
Otimizando o desempenho de apps web Flutter com tree shaking e carregamento sob demanda
Construindo widgets Flutter performáticos (este artigo)
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.