Flutter no Raspberry Pi (quase) do zero
Acompanhe um experimento de portar o engine do Flutter para o Raspberry Pi e veja o que é preciso para dar suporte a um novo alvo.
Este documento descreve um experimento de portar a engine do Flutter para uma plataforma que atualmente não é suportada. O fato de eu ter usado um Raspberry Pi é puramente incidental. Deliberadamente não fiz nenhuma suposição sobre o alvo. É totalmente possível que você já tenha uma toolchain pronta para usar com a sua placa específica. Se for o caso, grande parte deste documento pode ser pulada. Este documento também pressupõe que você está familiarizado com a configuração das suas próprias toolchains e ambientes de build.
Levar o Flutter para uma nova plataforma exige portar a engine do Flutter para o alvo, além de implementar um embedder. A engine do Flutter é inerentemente multiplataforma e pode funcionar com diversas APIs de renderização (OpenGL, Vulkan e renderização por software). Ela inclui a VM do runtime Dart.
A engine normalmente é empacotada como uma biblioteca dinâmica e consumida por embedders finos específicos de plataforma. Ela tem uma API C pequena. Os desenvolvedores da engine garantem que essa API é retrocompatível e tem uma ABI estável daqui para frente. A API consiste em um único header C sem dependências específicas de plataforma.
Cabe ao embedder configurar a superfície de renderização, conectar os eventos de entrada e fornecer acesso aos snapshots das aplicações Dart. Como referência, o projeto Flutter Desktop Embedding usa essa abordagem para configurar o Flutter nos ambientes desktop Mac, Linux e Windows.
Então, para portar o Flutter para o Raspberry Pi, você precisará dos seguintes itens:
A engine do Flutter compilada para ARMv7.
-
Um embedder específico para o Raspberry Pi, que configure a superfície de renderização e conecte os eventos de entrada.
-
Um snapshot da aplicação Dart do Flutter. Você vai usar a engine do Flutter com uma VM em modo JIT.
Restrições
Para demonstrar todas as etapas necessárias para portar o Flutter para uma nova plataforma, foram impostas algumas restrições ao processo de porte:
-
O Raspberry Pi é capaz de rodar um ambiente desktop completo com dependências relativamente pesadas como o X11. Mas, em vez de depender de um ambiente desktop pesado (onde o embedder do Flutter Desktop Embedding poderia ser usado), você vai usar as APIs da Broadcom diretamente. Isso permite iniciar diretamente no Flutter em um ambiente leve, sem dependências desnecessárias.
-
Você não vai usar toolchains existentes para compilar nenhum artefato. O Raspberry Pi é uma plataforma bastante popular, com toolchains bem suportadas, mas este processo segue os mesmos passos necessários para portar para uma plataforma mais exótica, sem bom suporte a toolchains.
-
Você deve conseguir fazer todos os builds em uma estação de trabalho potente. Compilar artefatos nativos no próprio Raspberry Pi é possível, mas proibitivamente demorado.
Compilando a engine do Flutter
A toolchain
Para compilar a engine do Flutter para o Raspberry Pi, você precisa de uma toolchain capaz de compilar código da engine para ARMv7. O alvo da toolchain é
arm-linux-gnueabihf. Os desenvolvedores da engine dependem de uma toolchain muito próxima do Tip-of-Tree do
Clang/LLVM para o desenvolvimento deles. Embora usar uma versão moderna do GCC seja perfeitamente possível, é improvável que os desenvolvedores da engine aceitem patches específicos do GCC sem um investimento contínuo na infraestrutura de build e testes para esse compilador. Então, faça como os desenvolvedores da engine fazem nas plataformas suportadas e configure uma toolchain Clang/LLVM no Tip-of-Tree.
Preparar uma toolchain Clang para arm-linux-gnueabihf é bastante direto. Envolve baixar o código-fonte conforme descrito na
página de primeiros passos do Clang/LLVM. É importante não baixar
libcxx e libcxxabi, como descrito nas seções “opcionais” desse documento. Essas bibliotecas não serão compiladas para a plataforma alvo. Em vez disso, elas vão instalar artefatos do host no local especificado pelo prefixo de instalação.
Depois que os códigos-fonte forem baixados, compile a toolchain com as seguintes flags:
cmake ../llvm \
-DCMAKE_BUILD_TYPE=Release \
-DCMAKE_INSTALL_PREFIX=/sdk/toolchain \
-DLLVM_DEFAULT_TARGET_TRIPLE=arm-linux-gnueabihf \
-DLLVM_TARGETS_TO_BUILD=ARM
Depois de ter a toolchain Clang/LLVM, você precisa compilar o Binutils para arm-linux-gnueabihf. Os desenvolvedores da engine usam o Gold como linker no Linux, então faça o mesmo. O código-fonte do Binutils pode ser baixado no
repositório Git mencionado na página inicial do Binutils. Configure o build com as seguintes flags:
./configure --prefix="/sdk/toolchain" \
--enable-gold \
--enable-ld \
--target=arm-linux-gnueabihf
Agora você tem uma toolchain capaz de compilar para (e somente para) arm-linux-gnueabihf. Se você já tiver uma toolchain bem próxima do Clang no Tip-of-Tree que também consiga mirar nessa plataforma, pode usá-la. Mas esta toolchain lhe dá uma chance melhor de evitar problemas específicos do compilador causados por diferenças sutis de versão.
libcxx e libcxxabi
Você pode testar o novo toolchain usando-o para compilar libcxx
e libcxxabi. A imagem Raspberry Pi Raspbian
tem libstdc++, que é bastante antiga e não é totalmente adequada para uso pela engine. Além disso, você quer que a engine seja autocontida e não dependa de uma implementação de biblioteca C++ no alvo. Você vai usar um
libcxx e linká-lo estaticamente à engine. Assim, a engine tem tudo o que precisa para rodar, com dependências mínimas da plataforma subjacente. Como você está compilando
libcxx apenas para uso da engine, pode desativar o suporte a
exceções e RTTI, que a engine não precisa.
Baixe o código-fonte de libcxx e libcxxabi
conforme descrito na página “Building Libcxx” da equipe da LLVM. Considerando os recursos específicos de
libcxx descritos acima, execute os comandos a seguir.
Nota: se você quiser mais ajuda com alguma variável do CMake, os comandos a seguir são extremamente úteis:
cmake --help-variable CMAKE_SYSROOT_COMPILE
cmake --help-variable-list
Compile libcxxabi primeiro, já que libcxx
depende dos artefatos gerados pelo alvo libcxxabi:
cmake ../llvm/projects/libcxxabi \
-DCMAKE_CROSSCOMPILING=True \
-DCMAKE_SYSROOT=/sdk/sysroot \
-DLIBCXX_ENABLE_SHARED=False \
-DCMAKE_INSTALL_PREFIX=/sdk/toolchain \
-DCMAKE_BUILD_TYPE=Release \
-DCMAKE_SYSTEM_NAME=Linux \
-DCMAKE_SYSTEM_PROCESSOR=ARM \
-DCMAKE_C_COMPILER=/sdk/toolchain/bin/clang \
-DCMAKE_CXX_COMPILER=/sdk/toolchain/bin/clang++ \
-DLLVM_TARGETS_TO_BUILD=ARM \
-DLIBCXXABI_ENABLE_EXCEPTIONS=False
Depois, compile libcxx. Observe que ela está configurada para linkagem estática:
cmake ../llvm/projects/libcxx \
-DCMAKE_CROSSCOMPILING=True \
-DCMAKE_SYSROOT=/sdk/sysroot \
-DLIBCXX_ENABLE_SHARED=False \
-DCMAKE_INSTALL_PREFIX=/sdk/toolchain \
-DCMAKE_BUILD_TYPE=Release \
-DCMAKE_SYSTEM_NAME=Linux \
-DCMAKE_SYSTEM_PROCESSOR=ARM \
-DCMAKE_C_COMPILER=/sdk/toolchain/bin/clang \
-DCMAKE_CXX_COMPILER=/sdk/toolchain/bin/clang++ \
-DLLVM_TARGETS_TO_BUILD=ARM \
-DLIBCXX_ENABLE_EXCEPTIONS=False \
-DLIBCXX_ENABLE_RTTI=False \
-DLIBCXX_CXX_ABI=libcxxabi \
-DLIBCXX_CXX_ABI_INCLUDE_PATHS=/sdk/toolchain/include/c++/v1 \
-DLIBCXX_CXX_ABI_LIBRARY_PATH=/sdk/toolchain/lib \
-DLIBCXX_ENABLE_STATIC_ABI_LIBRARY=True
Depois que a etapa de instalação for concluída para as duas bibliotecas, verifique o conteúdo do prefixo de instalação para garantir que nenhuma biblioteca dinâmica de
libcxx ou libcxxabi tenha ido parar ali. Você precisa ter certeza absoluta de que não criou artefatos que dependam dessas bibliotecas dinâmicas (porque elas não estarão presentes no alvo). Se encontrar alguma, remova-a.
Copie os cabeçalhos de cxxabi.h e __cxxabi_config.h
para c++/v1 na pasta do prefixo de instalação. Eles não são colocados ali por padrão.
O Sysroot
A partir de uma instalação nova e headless do Raspbian, rsync os diretórios lib,
opt e usr para um único diretório no seu host. Chamamos esse diretório de
sysroot e o usamos para compilar artefatos no host que linkam com bibliotecas do sistema no alvo (o Raspberry Pi). Sinta-se à vontade para reduzir o conteúdo desses diretórios, excluindo as dependências de que você não vai precisar no próprio embedder.
Para compilar a engine, você só precisa de libdl, libpthread,
librt, libm e libc, além dos respectivos cabeçalhos. A implementação do embedder também provavelmente vai precisar linkar com as bibliotecas da Broadcom (elas estão em
opt).
O Flutter Engine
Configure o ambiente do host para a engine do Flutter seguindo as instruções do guia de contribuição. Certifique-se de estar em um desktop Linux como host, já que você está compilando para um alvo Linux (o Raspberry Pi), mas com um toolchain personalizado (o que você acabou de compilar), e
sysroot (a que você acabou de baixar via rsync).
Depois que o build root estiver preparado, compile usando as seguintes flags do GN:
./flutter/tools/gn \
--target-sysroot /sdk/sysroot \
--target-toolchain /sdk/toolchain \
--target-triple arm-linux-gnueabihf \
--linux-cpu arm \
--runtime-mode debug \
--embedder-for-target \
--no-lto \
--target-os linux \
--arm-float-abi hard \
Você gerou libflutter_engine.so. Pegue icudtl.dat
e o cabeçalho flutter_embedder.h. Você precisa desses artefatos para compilar o embedder na próxima etapa.
Compilando o Embedder
Você pode compilar o embedder com o sistema de build com o qual se sentir mais à vontade. Para acompanhar este documento, um embedder de exemplo foi compilado com o sistema de build GN, com base no Raspberry Pi Cross Compilation SDK (um build root e um toolchain genéricos, capazes de fazer cross-compilation de aplicações C/C++ para o Raspberry Pi). Esse embedder implementa a renderização usando as APIs da Broadcom. Você pode encontrar o embedder em este repositório no GitHub. Ele se parece muito com as implementações de embedder para desktop, mas é bem mais simples. Pode servir como um ponto de partida neutro para as suas próprias implementações.
Envie os artefatos de build para o dispositivo Raspberry Pi.
Compilando o Snapshot da Aplicação Flutter
No host, faça o checkout da aplicação que você quer rodar no Raspberry Pi e compile o bundle da aplicação com as ferramentas do Flutter. Isso pode ser feito com o seguinte comando:
flutter build bundle
Envie esse bundle para o Raspberry Pi.
Rodando a Aplicação no Raspberry Pi
No caso específico do embedder do Raspberry Pi, execute a aplicação com a seguinte invocação:
flutter /path/to/flutter_assets/
Automatize esse processo no fluxo de trabalho que preferir.
Parabéns! Você portou o Flutter para o Raspberry Pi! Agora vem a parte difícil: deixar o port pronto para produção.