Hummingbird: criando o Flutter para a web
No Flutter Live de hoje, anunciamos que estamos experimentando rodar o Flutter na web.
Hoje, no Flutter Live, anunciamos que estamos experimentando executar o Flutter na Web. Neste post, descrevemos como estamos abordando o desafio e o estado atual da tecnologia. No final do post, você encontrará respostas para perguntas sobre interop e embedding.

Vamos começar com uma rápida revisão da arquitetura do Flutter. O Flutter é um sistema em múltiplas camadas: as camadas mais altas são mais fáceis de usar e permitem expressar muito com pouco código, enquanto as camadas mais baixas oferecem mais controle, ao custo de lidar com alguma complexidade. Quando uma camada superior não faz o que o desenvolvedor quer, ele pode descer para uma camada inferior. Os desenvolvedores têm acesso a todas as camadas acima da Flutter Engine.
A Flutter Engine é exposta como a biblioteca de nível mais baixo do Flutter, dart:ui. Ela não sabe nada sobre widgets, física, animação ou layout (exceto o layout de texto). Tudo o que ela sabe é como compor pictures na tela e transformá-las em pixels. Seria difícil escrever aplicações diretamente sobre o dart:ui. É por isso que as camadas superiores foram criadas.
Tudo acima do dart:ui é o que chamamos de “o framework”. Tudo abaixo dele é “a engine”. O framework é escrito inteiramente na linguagem de programação Dart. A maior parte da engine é escrita em C++, com as partes específicas do Android em Java e as partes específicas do iOS em Objective-C. Algumas classes e funções básicas do dart:ui são escritas em Dart e servem principalmente como pontes entre Dart e C++.
O Flutter também oferece um sistema de plugins. Plugins são códigos escritos em uma linguagem com acesso direto às bibliotecas OEM e às bibliotecas de terceiros que os ecossistemas mobile acumularam ao longo do tempo. Para criar um plugin para Android, você escreveria em Java ou Kotlin. Um plugin para iOS é escrito em Objective-C ou Swift.
Olá, Web
A plataforma Web vem evoluindo há décadas e inclui inúmeras tecnologias e especificações. Há alguns termos guarda-chuva usados para descrever grandes coleções de recursos relacionados: HTML, CSS, SVG, JavaScript, WebGL. Para executar o Flutter na Web, precisamos:
-
Compilar código Dart: o Flutter é escrito em Dart, e precisamos executar Dart na Web.
-
Escolher um subconjunto do Flutter para executar na Web: não é prático nem útil executar todo o código do Flutter na Web. Parte dele é específica de plataforma, como os trechos de Android e iOS.
-
Escolher um subconjunto suficiente dos recursos da Web: com o tempo, a plataforma Web acumulou recursos que se sobrepõem em funcionalidade. Por exemplo, você pode desenhar gráficos usando HTML+CSS, SVG, Canvas e WebGL.
Dart compila para JavaScript desde que a linguagem existe. Muitas aplicações importantes são compiladas de Dart para JavaScript e rodam em produção hoje. A estratégia de compilação do Flutter depende da mesma infraestrutura.
Quando começamos nossa exploração, nos deparamos com várias escolhas para a renderização da UI. Percebemos rapidamente que as camadas específicas do Flutter que queremos oferecer determinam as tecnologias Web que usaríamos na implementação. Construímos três protótipos:
-
Apenas widgets: este protótipo implementou o framework de widgets do Flutter e ofereceu um conjunto de widgets básicos de layout como base para criar widgets personalizados. Para layout e posicionamento, ele dependia dos recursos integrados da Web, como flexbox, grid layout, rolagem do navegador via
overflow:scroll, etc. -
Widgets + layout personalizado: este protótipo incluía o sistema de layout do Flutter (fornecido por
RenderObject), mas mapeava os render objects diretamente para elementos HTML. -
Flutter Web Engine: este protótipo manteve todas as camadas acima do dart:ui e forneceu uma implementação do dart:ui que roda no navegador.
Um dos recursos mais valiosos do Flutter é que ele é portável entre plataformas. Embora você possa (e às vezes seja incentivado a) escrever código específico de cada plataforma, o código que não precisa ser diferente entre plataformas pode ser compartilhado. Isso permite escrever aplicações para várias plataformas com uma única base de código.
Depois de tentar portar várias aplicações de exemplo para a Web, percebemos que os protótipos nº 1 e nº 2 não proporcionariam o nível de portabilidade que os desenvolvedores Flutter já estavam acostumados a ter. Por isso, decidimos seguir com o protótipo nº 3, o design do Flutter Web Engine, pois ele permitiria o maior reaproveitamento de código no nível do framework entre plataformas:
Agora que sabemos que queremos implementar toda a API do dart:ui, precisamos escolher um conjunto de tecnologias Web sobre as quais construir. O Flutter renderiza a UI um frame por vez. Dentro de cada frame, o Flutter constrói widgets, executa o layout e, por fim, pinta os elementos na tela.
Construindo widgets
O mecanismo de construção de widgets não depende do ambiente em que o app está rodando. O processo simplesmente instancia objetos na memória, acompanha o estado deles e, quando o estado muda, calcula as atualizações mínimas necessárias para as camadas inferiores do sistema, layout e pintura. Portar essa parte para a Web foi direto. Depois que a equipe do Dart implementou suporte a super-mixin no dart2js, o compilador transformou todos os widgets e o framework de widgets em JavaScript quase sem problemas.
Layout
O sistema de layout é um pouco mais complicado. O maior desafio foi o layout de texto. Todo o restante — Center, Row, Column, Stack, Scrollable, Padding, Wrap e assim por diante — é calculado pelo framework e, portanto, compila para a Web sem modificações.
No Flutter, você faz o layout de um parágrafo de texto criando um objeto Paragraph e chamando seu método layout() . Infelizmente, a Web não tem uma API direta de layout de texto. O truque que usamos para medir as propriedades de layout do texto foi fazer o navegador calculá-lo e, depois, ler as propriedades relevantes dos elementos do DOM.
Ao fazer o layout de um parágrafo de texto, o Flutter mede a altura, a largura, a largura intrínseca máxima, a largura intrínseca mínima e as linhas de base alfabética e ideográfica do parágrafo. Essas propriedades são ilustradas abaixo.
Você pode encontrar mais detalhes na documentação de Paragraph do Flutter.
Para medir essas propriedades, primeiro colocamos um parágrafo em um elemento HTML do DOM e depois lemos as dimensões do elemento. Isso faz o navegador calcular o layout. Por exemplo, para obter a largura e a altura do elemento, chamamos offsetWidth e seu irmão, offsetHeight. Para medir a linha de base, colocamos o parágrafo em um elemento configurado para se organizar com flex row. Ao lado do parágrafo, colocamos outro elemento chamado “probe”. Como o probe está alinhado com a linha de base do texto, chamar getBoundingClientRect nele nos dá a linha de base. Usamos truques semelhantes para medir as larguras intrínsecas mínima e máxima.
Pintura
Por último, mas não menos importante, precisamos pintar os widgets. Esta área teve a maior rotatividade durante nossa exploração e ainda é uma das áreas de pesquisa mais ativas para nós. Até o fim do frame, todos os nossos widgets precisam virar pixels na tela. No navegador, isso significa que eles precisam ser reduzidos a alguma combinação de HTML/CSS, Canvas, SVG e WebGL.
Ainda não analisamos o WebGL, principalmente porque ele é de baixo nível e exige que reimplementemos coisas que os navegadores já fazem, como layout de texto e rasterização de gráficos 2D, mas também porque ainda não descobrimos como acessibilidade, seleção de texto e composição com componentes não Flutter podem funcionar com WebGL.
Um dos nossos primeiros protótipos produziu um elemento HTML para cada RenderObject. Obtivemos resultados promissores, mas isso se mostrou uma mudança de API quebrada demais. Teríamos que manter uma diferença enorme de código em relação ao Flutter, então abandonamos a ideia.
Atualmente, estamos explorando simultaneamente duas abordagens:
HTML+CSS+Canvas
CSS Paint API
HTML+CSS+Canvas
Com essa abordagem, classificamos as imagens produzidas pelo framework em aquelas que podem ser expressas com HTML+CSS e aquelas que podem ser expressas com Canvas 2D. Depois, geramos um DOM HTML que combina HTML, CSS e canvas 2D.
Preferimos HTML+CSS porque ele é sustentado pela display list do navegador. Isso significa que podemos deixar a otimização da rasterização das imagens para o mecanismo de renderização do navegador. Também significa que podemos aplicar transformações arbitrárias, principalmente rotações e escalas, sem nos preocupar com pixelização. Chamamos essa implementação de canvas de DomCanvas.
Se não conseguirmos expressar uma imagem com HTML+CSS, recorremos ao canvas. O Canvas 2D nos permite pintar quase todos os comandos de desenho do Flutter. Se você comparar o Canvas do Flutter com o CanvasRenderingContext2D da Web, verá muitas semelhanças. Pintar no canvas é eficiente porque não cria uma árvore mutável de nós que precisa ser mantida ao longo do tempo, como acontece com o DOM HTML ou com SVG.
Um desafio do canvas 2D é que os navegadores o representam como um bitmap, um buffer de memória que armazena largura x altura pixels. Como resultado, escalar um canvas causa pixelização. Se a escala resultar em redimensionar a imagem, precisamos redimensionar o canvas. Descobrimos que alocar canvases é bastante caro, e redimensioná-los também. Além disso, ao compor vários canvases na mesma página, o navegador precisa fazer composição de rasters, o que também aparece nos nossos perfis. A composição de rasters funciona de forma diferente das display lists. Você pode pintar várias display lists no mesmo buffer de memória. Chamamos a implementação de canvas com base em Canvas 2D de BitmapCanvas. Estamos pesquisando formas de tornar os bitmap canvases mais eficientes.
Para expressar a opacidade, a transformação, o deslocamento, o recorte retangular e outras camadas
do Flutter, usamos elementos HTML simples. Por exemplo, uma camada de opacidade se torna um elemento <flt-opacity>
com o atributo CSS opacity, uma camada de transformação se torna um elemento <flt-transform>
com o atributo CSS transform, e um recorte retangular se torna um <flt-clip-rect>
com overflow: hidden.
No fim das contas, um frame é renderizado na página como uma árvore de elementos HTML, com DomCanvas e BitmapCanvas como nós folha. Por exemplo:
Uma árvore de layers equivalente do Flutter (chamada flow layer) na Flutter Engine ficaria assim:
Estruturalmente, eles são muito parecidos. A maior diferença é que, na Web, precisamos escolher implementações diferentes para as imagens com base no conteúdo delas.
HTML+CSS+Canvas funciona em todos os navegadores modernos. No entanto, já estamos olhando para o futuro:
CSS Paint API
CSS Paint é uma nova API da Web e parte de um esforço maior, o Houdini. O Houdini é uma colaboração entre vários fabricantes de navegadores para expor certas partes do mecanismo de CSS aos desenvolvedores. Em especial, a CSS Paint API permite que desenvolvedores pintem gráficos personalizados em elementos HTML quando esses elementos solicitam pintura. Por exemplo, você pode atribuir a pintura do elemento
background a um pintor CSS personalizado. É muito parecido com o canvas, mas com as seguintes diferenças importantes:
-
A pintura não é feita pelo isolate JavaScript principal, mas por algo chamado paint worklet. É um pouco como um web worker, pois tem seu próprio espaço de memória. Um paint worklet é executado durante a fase de pintura do navegador, depois que as mudanças do DOM são confirmadas.
-
O CSS paint é sustentado por uma display list, não por um bitmap. Isso nos dá o melhor dos dois mundos: a eficiência de pintura semelhante ao canvas 2D e nenhuma pixelização.
Atualmente, o CSS paint não oferece suporte à pintura de texto.
Até a escrita deste texto, Chrome e Opera são os únicos navegadores que oferecem suporte ao CSS Paint em produção. No entanto, outros navegadores estão em diferentes estágios de lançamento de suas implementações.
Temos suporte experimental para a CSS Paint API no Flutter for Web, e ele já mostra bons resultados, especialmente em desempenho. Nossa implementação simplesmente serializa os comandos de pintura em uma propriedade CSS personalizada. O paint worklet lê esses comandos e os executa. Renderizamos o texto usando os elementos HTML normais
<p> e <span>.
Nosso mecanismo de serialização atual não é particularmente eficiente — é uma árvore de listas aninhadas convertida em JSON —, mas parte do projeto Houdini é adicionar suporte a typed array. Quando estiver disponível, vamos codificar os comandos de pintura como typed arrays em vez de strings JSON. Typed arrays são transferíveis, o que significa que podem ser passados da isolate principal para o paint worklet por referência. Não há cópia de memória envolvida.
Interop e embedding
Chamando bibliotecas Dart a partir do Flutter
Apps web Flutter têm acesso total a todas as bibliotecas Dart existentes que rodam na Web hoje.
Chamando bibliotecas JavaScript a partir do Flutter
Apps web Flutter oferecem suporte completo aos pacotes de JS-interop do Dart: package:js e dart:js.
Usando CSS em apps web Flutter
Atualmente, o Flutter assume controle total da página web para garantir correção e desempenho. Por exemplo, usamos apenas um pequeno subconjunto de CSS que segue certas diretrizes de desempenho, como https://csstriggers.com/. Colocar CSS arbitrário na página pode fazer o Flutter se comportar de maneira imprevisível.
Outro motivo para evitar CSS em um app Flutter for Web é que, por design, o Flutter precisa conhecer todas as propriedades de layout ao renderizar o frame. O CSS funciona como uma caixa-preta. Por exemplo, se você quiser exibir uma lista rolável de widgets, precisa instanciar e gerar HTML para todos eles e aplicar as propriedades CSS necessárias (por exemplo, flex-direction row e overflow: scroll). Depois, o navegador faz o layout de tudo e renderiza na tela. O código da aplicação não participa do processo de layout.
Por fim, em respeito ao objetivo de manter o código Flutter portável entre plataformas, evitamos CSS para poder executar o mesmo código nativamente no Android e no iOS.
Incorporando Flutter em web apps existentes
Ainda não adicionamos suporte adequado a isso, mas pretendemos explorar no futuro. Algumas abordagens que estamos considerando são
<iframe> e shadow DOM.
Incorporando componentes não Flutter no Flutter
Ainda não adicionamos suporte para incorporar componentes não Flutter — Custom Elements, componentes React, componentes Angular — em um app web Flutter, mas pretendemos explorar isso no futuro. Um caminho possível é usar a platform view para inserir conteúdo externo em um app web Flutter. Um aspecto importante a considerar é que tipo de efeito o conteúdo externo pode ter no desempenho e na correção dos apps. Como componentes não Flutter provavelmente contêm CSS arbitrário, como mencionado acima, isso pode ser problemático. Ainda é necessária mais pesquisa.
Portabilidade
Nosso objetivo é tornar a maior parte possível do framework portável para a Web. No entanto, isso não significa que um app Flutter arbitrário vai rodar na Web sem alterações no código. Um app web Flutter continua sendo um app web; ele é isolado no navegador e só pode fazer o que o navegador permite. Por exemplo, se o seu app Flutter usa um plugin nativo que não tem implementação Web, como o ARCore, você não conseguirá executar o app na Web. Da mesma forma, não há acesso direto ao sistema de arquivos nem à rede em baixo nível.
Status atual
Construímos o suficiente da Web Engine para renderizar a maior parte do Flutter Gallery. Não portamos os widgets Cupertino, mas todos os widgets Material, o Material Theming, bem como os apps de demonstração Shrine e Contact Profile, rodam na Web.
Onde está o código-fonte?
Planejamos abrir o código deste projeto em breve e estamos animados para compartilhá-lo com a comunidade de código aberto. Este projeto começou como uma exploração dentro da árvore de código interna do Google. Pretendemos mover o desenvolvimento para o GitHub assim que nosso código estabilizar e tivermos a chance de separá-lo da nossa infraestrutura interna. Enquanto isso, não se surpreenda se vir pull requests relacionados à Web na organização github.com/flutter!
Conclusão
Espero que este post dê uma ideia dos desafios que estamos resolvendo para fazer o Flutter funcionar bem na Web. Queremos saber suas opiniões e ideias.
Fique de olho no Google I/O 2019!