4. Capítulo 3 - Introdução ao Flutter
4.1. Fontes
Documentação oficial: https://docs.flutter.dev, em particular as páginas “What is Flutter?”, “Introduction to widgets” e “State management”. Linguagem [Dart]: https://dart.dev/language
4.2. O que o Flutter não é
Este é o ponto de partida mais importante deste capítulo, pois difere bastante das três versões anteriores deste curso. [Angular], [React], e [Vue.js] produzem todos [JavaScript]/[TypeScript] COMPILADO, que é executado pelo mecanismo [JavaScript] já presente em um navegador; esse mecanismo cuida de todo o trabalho de exibição, por meio do [DOM] e do [CSS]. Uma ferramenta como [Cordova]/[Capacitor] (não usada neste curso) permite, de fato, empacotar esse cliente web em um invólucro mobile, mas o cliente continua então a rodar em um navegador embutido (uma [WebView]), nunca de forma nativa.
O [Flutter] não tem nada a ver com isso. O código [Dart] deste documento é compilado, tanto para mobile quanto para desktop, em código de máquina NATIVO (compilação [AOT], [Ahead-Of-Time], da mesma família de compilação de um programa C++ ou Rust), diretamente executável pelo sistema operacional de destino; ele NÃO exige nenhum interpretador [JavaScript] nem [WebView] de qualquer tipo. O [Flutter] inclui seu próprio mecanismo de renderização gráfica (o [Impeller], que substituiu o [Skia] como mecanismo padrão em dispositivos móveis): a aplicação desenha ela mesma cada um de seus pixels, quadro a quadro, em vez de delegar a exibição aos widgets nativos do sistema operacional (diferentemente do [React Native], que não é usado neste curso e que, em vez disso, controla os componentes de interface reais do [Android]/[iOS]). É essa escolha de arquitetura que permite ao [Flutter] renderizar uma interface idêntica nos três ambientes visados por este documento: não há componentes nativos do sistema operacional cuja aparência possa variar de uma plataforma para outra.
No destino [web], porém, obviamente não há compilação para código de máquina nativo: o comando [flutter build web] compila o código [Dart] para [JavaScript] (ou para [WebAssembly], um destino mais recente), que é executado pelo navegador; porém esse [JavaScript] gerado NÃO manipula o [DOM] nem o [HTML] como o [Vue.js] faz: ele também renderiza diretamente em um único elemento [<canvas>] (ou por meio de elementos [HTML] gerados automaticamente, dependendo do modo de renderização escolhido), reproduzindo assim a mesma aparência do [Flutter] que no mobile e no desktop, em vez de depender de elementos [HTML] estilizados em [CSS].
4.3. O modelo de desenvolvimento do Flutter: tudo é um widget
O [Angular], o [React] e o [Vue.js]—todos os três distinguem a LÓGICA de um componente ([TypeScript]) de sua APRESENTAÇÃO (um template [HTML], que pode ser separado ou integrado conforme o framework; veja o Capítulo 4 do documento sobre [Vue.js] deste curso, “Componentes: arquivos [.vue] e [Composition API]”). O [Flutter] elimina completamente essa distinção: TUDO, em uma interface [Flutter], é um [Widget] (um botão, um texto, uma margem, um alinhamento e uma cor de fundo são, cada um, um widget), e uma interface completa nada mais é que uma ÁRVORE de widgets aninhados uns nos outros, descrita por código [Dart] comum (o método [build(BuildContext context)]) em vez de uma linguagem de template separada; nesse aspecto, o [Flutter] leva ainda mais longe a escolha já feita pelo [React] ([JSX], a partir do [JavaScript], que descreve a interface): enquanto o [JSX] continua sendo uma linguagem de marcação, MISTURADA com [JavaScript], [build(...)] simplesmente devolve uma EXPRESSÃO [Dart]: chamadas de construtores aninhadas ([Scaffold(appBar: ..., body: Column(children: [...]))]), sem nenhuma sintaxe adicional para aprender.
4.4. StatelessWidget e StatefulWidget: enquanto o Vue.js não exige distinção
O [Vue.js] (como o [React] e o [Angular] antes dele neste curso) não faz nenhuma distinção estrutural entre um componente que tem estado mutável e um que não tem: [ref(...)] pode ou não ser chamado dentro de qualquer [<script setup>], sem mudar nada na própria declaração do componente. O [Flutter] IMPÕE essa distinção já na declaração da classe: um [StatelessWidget] (nada muda depois de sua construção; veja [ScheduleView] e [LoginPage] no Capítulo 4) executa novamente seu método [build(...)] SOMENTE quando seus parâmetros mudam; um [StatefulWidget] é associado a uma classe [State<T>] separada (veja [_LoginFormState], [_AppRootState]..., Capítulo 4), que guarda o estado mutável e o método [setState(() { ... })], a chamada EXPLÍCITA que dispara uma nova renderização, ao passo que o [reactive(...)] do lado do [Vue.js] detecta automaticamente cada escrita em propriedade. Essa separação em duas classes (Widget/State) decorre diretamente de uma escolha deliberada de projeto do [Flutter]: um objeto [Widget] é IMUTÁVEL (reconstruído a cada renderização, como um simples objeto de configuração), enquanto o [State] associado a ele SOBREVIVE de uma renderização para a seguinte.
4.5. Compartilhamento de estado entre widgets: provider, o equivalente de provide/inject
O [Vue.js] compartilha estado entre componentes distantes por meio do par [provide]/[inject]; o [React] usa um [Context]; o [Angular] usa um serviço singleton injetável. O [Flutter] não tem nenhum desses mecanismos embutido no próprio framework: é o pacote de terceiros [provider] (veja [pubspec.yaml], Capítulo 4), praticamente indispensável no ecossistema [Flutter], que cumpre esse papel. Seu princípio: uma classe [ChangeNotifier] (uma classe [Dart] comum, que pode notificar seus ouvintes de uma mudança por meio de [notifyListeners()]) é disponibilizada a toda uma subárvore de widgets por um [ChangeNotifierProvider] posicionado em sua raiz (veja [MultiProvider] em [lib/main.dart], que equivale às chamadas [app.provide(key, value)] do lado do [Vue.js]); qualquer widget descendente o relê então usando [context.watch<MyService>()] (assina as mudanças futuras; o equivalente de [useXxx()] do lado do [Vue.js]) ou [context.read<MyService>()] (leitura pontual, sem nova assinatura, uma distinção que o [Vue.js] não precisa fazer).
Diferença fundamental em relação ao [reactive(...)]: um [ChangeNotifier] não detecta NADA automaticamente. [reactive(...)] envolve um objeto em um proxy [JavaScript] que intercepta toda LEITURA e toda ESCRITA de propriedade; um [ChangeNotifier] [Dart] é uma classe comum, e cabe ao desenvolvedor chamar explicitamente [notifyListeners()] depois de toda modificação que deva disparar uma nova renderização, o que exige mais disciplina manual, em troca de um mecanismo que não depende de proxies “mágicos” para ser compreendido.
4.6. Sem linguagem de template separada: renderização condicional e listas
[v-if]/[v-else] e [v-for] ([Vue.js]), assim como [@if]/[@for] do lado do [Angular], ou os operadores ternários && e [.map(...)] do lado do [React], são convertidos, no [Flutter], de volta em expressões [Dart] COMUNS, diretamente dentro de [build(...)]: um [if]/[else] clássico do [Dart] para uma condição, e [.map((element) => Widget(...)).toList()] para uma lista, o mesmo conceito do [.map(...)] do lado do [React], já que o [Flutter], como o [React], não reconhece uma “linguagem de template” separada, distinta da própria linguagem de programação. A sintaxe [if (condition) ...[ WidgetA, WidgetB ]] (“if collection”, usada por exemplo em [lib/app.dart], Capítulo 4) leva essa lógica um passo além do [React]: uma CONDIÇÃO inserida diretamente em uma lista literal de widgets, sem operador ternário nem função intermediária.
4.7. Dart: um primo próximo do TypeScript, não do JavaScript
O [Dart] nunca foi concebido como uma alternativa ao [TypeScript] para a web (ao contrário deste, que foi projetado especificamente como um superconjunto do [JavaScript]): é uma linguagem independente, de tipagem ESTÁTICA desde a origem (sem modo “[any]” implícito), compilada, nunca interpretada como está. Para um desenvolvedor vindo do [TypeScript] (como nas três variantes anteriores deste curso), o essencial se traduz quase diretamente: classes, interfaces (o [Dart] usa [abstract class] ou simples classes implementadas, em vez de uma palavra-chave [interface] separada), genéricos ([ServerResponse<T>], veja o Capítulo 4), [async]/[await] sobre [Future<T>] (o equivalente EXATO de [Promise<T>] no [TypeScript]) e uma verificação de nulabilidade embutida no sistema de tipos ([String?] em vez de uma string sempre presente; o equivalente do modo [strict] do [TypeScript], mas imposto pela própria linguagem e não por uma opção do compilador).
Uma diferença notável, encontrada em todo arquivo do capítulo seguinte que decodifica JSON ([core/models/appointment_models.dart]): o [TypeScript] remove seus tipos em tempo de compilação: uma [interface] é verificada somente em tempo de compilação, e um objeto JSON decodificado é então usado TAL COMO ESTÁ em tempo de execução ([JSON.parse(...) as ServerResponse<T>], uma simples promessa feita ao compilador). O [Dart], por outro lado, tem seus tipos determinados em tempo de execução: [jsonDecode(...)] sempre devolve tipos dinâmicos ([Map<String, dynamic>]), que devem ser explicitamente convertidos em instâncias de classe por meio de um construtor [fromJson(...)] escrito à mão; isso é mais verboso a princípio, mas uma chave ausente ou de tipo inesperado provoca então uma exceção imediata e clara, em vez de se propagar silenciosamente.
4.8. Um primeiro exemplo mínimo
Esta é a menor aplicação [Flutter] que exibe algo na tela; compare-a com [lib/main.dart]/[lib/app.dart] do Capítulo 4, que são bem mais completos, mas construídos com EXATAMENTE os mesmos blocos ([runApp(...)], [MaterialApp] e um widget raiz).
Vamos comentar esse código:
- Linha 1: [import 'package:flutter/material.dart';] — equivale a [import { ... } from 'vue']: [material.dart] inclui todos os widgets do “Material Design” ([Google]) usados neste documento: botões, campos de texto, barras de aplicação etc. O [Flutter] também oferece um conjunto de widgets [Cupertino] (com o estilo do [iOS]), que não são usados neste curso, para quem prefere esse estilo em dispositivos móveis ([Apple]).
- Linha 3: [void main() {] — o ponto de entrada de um programa [Dart], EXATAMENTE como o de um programa [C]/[Java]; o [Flutter] não tem equivalente ao [HTML] de uma página web, no qual um script [main.ts] seria então embutido: a aplicação é iniciada AQUI diretamente.
- Linha 4: [runApp(...)] — inicia o mecanismo de renderização do [Flutter] e fornece a ele o widget raiz a exibir; o equivalente de [createApp(App).mount('#app')] do lado do [Vue.js] ([src/main.ts]), em uma única chamada em vez de duas.
- Linhas 5 a 9: [MaterialApp(home: Scaffold(body: Center(...)))] — uma ÁRVORE de widgets aninhados, cada um com uma responsabilidade específica: [MaterialApp] configura o tema e a navegação; [Scaffold] fornece a estrutura padrão da tela (área para uma barra de aplicação, área de conteúdo etc.); [Center] centraliza seu filho; [Text] exibe uma string. Nenhum desses quatro widgets é um caso especial da linguagem: são simplesmente CLASSES [Dart], como as que este curso escreverá no próximo capítulo.
4.9. Resumo: Angular -> React -> Vue.js -> Flutter
Veja também o arquivo [README.md] que acompanha o código deste capítulo para a versão completa.
- Componentes [Angular] / arquivos [.vue] / [.tsx] → [Widgets] [Dart] ([StatelessWidget]/[StatefulWidget])
- [signal()]/[ref()]/[useState()] → campos mutáveis + [setState(...)] (estado local), [ChangeNotifier] (estado compartilhado)
- [input()]/[output()], [defineProps]/[defineEmits], propriedades de função → parâmetros de construtor (entradas), funções passadas como parâmetros (saídas)
- serviços injetáveis/composables + [provide]/[inject]/[Context] → classes de serviço + pacote [provider]
- template separado do [Angular], [<template>], [Vue.js], [JSX], [React] → método [build(BuildContext)] (Dart puro)
- [HttpClient]/[fetch] → pacote [http]
- [localStorage] → [shared_preferences]
- Sem roteador (aplicação de tela única, nas 5 variantes deste curso)