Flutter Outline, Hot Reload e a implementação de uma prévia de widget ao vivo
Veja como a view Flutter Outline e o hot reload viabilizam uma prévia de widget ao vivo no plugin do IntelliJ.
No M22 do plugin Flutter para IntelliJ, adicionamos uma nova janela de ferramenta: a view Flutter Outline. Ela mostra a estrutura dos seus arquivos Dart — as classes, os campos e os métodos — assim como a janela Structure padrão do IntelliJ. Mas, quando o arquivo selecionado contém código de UI do Flutter, ela também mostra a hierarquia de widgets — a associação entre widgets pais e filhos:

O que há de novo?
Agora, com o M23, introduzimos um novo recurso experimental: uma renderização ao vivo, dentro do IntelliJ, do widget que está sendo desenvolvido. Ele pode ser ativado na página de preferências do Flutter no IntelliJ:

Para que isso funcione com um widget, a classe do widget precisa definir um construtor forDesignTime(). O motivo é que os widgets geralmente são criados com parâmetros de construtor específicos do contexto. Ao renderizar a prévia do widget, não necessariamente sabemos os valores certos para esses parâmetros. Então, deixamos que o usuário os forneça por meio desse construtor com nome especial.
Já recebemos vários comentários de que o código de UI do Flutter pode ficar bem longo e de que pode ser difícil construir um modelo mental e navegar enquanto se programa. Percebemos que uma apresentação visual e uma sincronização bidirecional entre o código e sua apresentação visual poderiam ajudar a resolver os dois problemas.
O código de um widget que pode ser visualizado pode ficar assim:
import 'package:flutter/material.dart';
class MyWidget extends StatelessWidget {
final String firstText;
MyWidget(this.firstText);
factory MyWidget.forDesignTime() {
return new MyWidget('AA');
}
@override
Widget build(BuildContext context) {
return new Column(
crossAxisAlignment: CrossAxisAlignment.center,
children: <Widget>[
buildText(firstText),
buildText('BBBB'),
buildText('CCCCCC'),
buildText('DDDDDDDD'),
],
);
}
Text buildText(String text) {
return new Text(text, style: const TextStyle(fontSize: 24.0));
}
}
e a prévia dele ficaria parecida com isto:

Ao testar isso, você vai notar que a área de prévia mostra o layout de vários tipos diferentes de widgets (construídos com um construtor forDesignTime()), e ela é atualizada automaticamente conforme você digita.
Como funciona?
A view de prévia ao vivo combina tecnologias do hot reload, do binário de testes headless do Flutter e do Dart Analysis Server, com uma implementação no IntelliJ.
Nas edições de arquivo
Quando você abre um arquivo Dart no IntelliJ, o plugin Flutter se inscreve nos eventos de Flutter Outline do Dart Analysis Server. Toda vez que um arquivo muda, um novo evento ‘Flutter Outline’ é enviado ao IntelliJ com informações estruturadas sobre o conteúdo do arquivo. Essas informações incluem classes, métodos e campos, além de dados sobre os widgets do Flutter criados no arquivo. Itens do Flutter são criados para cada instanciação de uma subclasse de Widget e para cada referência a uma variável tipada como Widget ou a uma invocação de método.
Para mapear instâncias de widgets em tempo de execução de volta às localizações no código-fonte onde foram criadas, reescrevemos o código-fonte do usuário para atribuir um ID único a cada widget criado. Você pode ver o código instrumentado aqui:
import 'package:flutter/material.dart';
class MyWidget extends StatelessWidget {
final String firstText;
MyWidget(this.firstText);
factory MyWidget.forDesignTime() {
return _registerWidgetInstance(0, new MyWidget('AA'));
}
@override
Widget build(BuildContext context) {
return _registerWidgetInstance(1, new Column(
crossAxisAlignment: CrossAxisAlignment.center,
children: <Widget>[
_registerWidgetInstance(2, buildText(firstText)),
_registerWidgetInstance(3, buildText('BBBB')),
_registerWidgetInstance(4, buildText('CCCCCC')),
_registerWidgetInstance(5, buildText('DDDDDDDD')),
],
));
}
Text buildText(String text) {
return _registerWidgetInstance(6, new Text(text, style: const TextStyle(fontSize: 24.0)));
}
}
final flutterDesignerWidgets = <int, Widget>{};
T _registerWidgetInstance<T extends Widget>(int id, T widget) {
flutterDesignerWidgets[id] = widget;
return widget;
}
Esse código instrumentado também volta como parte da resposta do analysis server.
Preenchendo a view de estrutura
Essas informações são usadas para preencher a parte em árvore da view de estrutura. Conforme o usuário muda a seleção no arquivo, pedimos uma nova renderização da prévia usando o widget selecionado no momento.
Iniciando o servidor de renderização
Usamos uma ferramenta padrão do Flutter, que permite a execução headless de código Flutter: o binário flutter_tester. Você pode pensar nele como parte da Dart VM com a biblioteca dart:ui e as ligações com o Skia, exatamente como em um dispositivo móvel, mas no seu desktop. Escrevemos dois arquivos em um diretório temporário: o próprio código instrumentado e o servidor de renderização. O servidor de renderização fica escutando o stdin à espera do comando de renderização, instancia o widget a ser renderizado, coloca-o em um MaterialApp, obtém as informações de posicionamento de cada widget e devolve ao cliente informações em JSON, com os limites mapeados para os identificadores de widget correspondentes.
Fazendo hot reload do código instrumentado
Mas executar uma nova instância do flutter_tester a cada ciclo seria lento demais: leva cerca de 1000 ms para a Dart VM iniciar e o JIT rodar. Então, em vez de criar um novo processo a cada vez, usamos mais um recurso incrível do Flutter e do Dart: o hot reload. Atualizamos o arquivo do servidor de renderização para usar o novo tamanho da área de prévia, o novo nome da classe do widget a ser instanciado e, claro, escrevemos o código recém-instrumentado no arquivo para renderizar. Depois, pedimos à Dart VM que faça hot reload do ponto de entrada (no nosso caso, o servidor de renderização), e ela pega todas as mudanças. O processo inteiro leva apenas cerca de 100 ms, ou seja, 10 vezes mais rápido que a renderização inicial, a frio.
Isso funciona bem quando você alterna entre arquivos do mesmo pacote, porque o conjunto de pacotes permanece o mesmo (e executamos o flutter_tester com esse conjunto). Mas quando você muda para um arquivo de outro pacote, reiniciamos o processo. Também encerramos o processo se a renderização não acontecer rápido o suficiente, atualmente com um limite de 2000 ms. Assim, se houver um erro de compilação ou de execução, depois que você corrigi-lo o processo do servidor de renderização acabará tendo êxito e você verá a renderização.
Pintura no IntelliJ
Depois que o plugin Flutter para o IntelliJ obtém o contorno e o conjunto correspondente de limites de cada widget, ele pinta o layout do widget na área de visualização usando componentes Swing padrão. Essa prévia permite selecionar o contorno de um widget e ver a entrada correspondente na árvore de visualização e no código-fonte.
Testando na prática
Então, vá até o painel de preferências, ative a live preview e nos conte o que você achou! Esperamos que ela ajude você a editar e entender seu código Flutter e suas UIs.