O bundle de aplicação iOS do Flutter

Veja como o sistema de build do Flutter empacota código da aplicação, assets, frameworks e plugins em um bundle de app iOS.

Este documento descreve como o sistema de build do Flutter converte o seu projeto Flutter (junto com seus assets) em um bundle do app iOS. Espero desmistificar algumas etapas do build e explicar a finalidade dos artefatos gerados, para que você possa integrar esses mesmos processos ao seu ambiente de build personalizado.

Uma nota sobre o fluxo de trabalho: ao gerar o build do seu app para release, você pode usar as ferramentas do Flutter, o que torna o processo fácil. No entanto, alguns desenvolvedores podem achar que esse processo não é tão configurável ou que não se encaixa bem no seu build personalizado ou nas suas configurações de integração contínua (CI).

Se você tiver um build personalizado no Xcode ou uma configuração própria do Gradle, toda a “mágica” adicionada pelas ferramentas do Flutter é opcional, e você pode configurar o build para se adequar ao seu próprio fluxo de trabalho.

Todas as informações deste documento se aplicam a bundles de app iOS preparados para publicação na App Store, ou seja, projetos compilados no modo release do Flutter. Compilar nos modos debug ou profile usa um runtime e um modelo de empacotamento diferentes, para oferecer suporte a ferramentas como hot reload e observatory.

Um app Flutter renderiza a interface do usuário em uma única view na hierarquia de views nativa.

A hierarquia de views do Flutter visualizada no Xcode. Não há muito o que ver.
A hierarquia de views do Flutter visualizada no Xcode. Não há muito o que ver.

O bundle do app

O bundle do app criado com o comando flutter build ios --release (ou usando sua IDE) é muito parecido com um bundle de app iOS típico, que contém o executável do app junto com os frameworks e recursos referenciados.

Bundle gerado pelo Flutter para o app Runner:

Runner.app
├── AppFrameworkInfo.plist
├── Assets.car
├── Base.lproj
│   ├── LaunchScreen.storyboardc
│   └── Main.storyboardc
├── Debug.xcconfig
├── Frameworks
│   ├── App.framework            # See "App framework bundle"
│   │   ├── App
│   │   ├── Info.plist
│   └── Flutter.framework        # See "Flutter framework bundle"
│       ├── Flutter
│       ├── Info.plist
│       └── icudtl.dat
├── Info.plist
├── Runner
└── flutter_assets
├── AssetManifest.json
├── FontManifest.json
├── LICENSE
├── fonts
└── packages
└── cupertino_icons
└── assets
└── CupertinoIcons.ttf

Compilando o app

Ao compilar uma versão em modo release do app (diferente dos modos profile ou debug), são necessários artefatos tanto dos buildbots quanto da sua máquina host. (Para mais informações sobre os buildbots, parte do build da engine que usa GN e Ninja, consulte Contribuindo para a engine do Flutter.)

Quando você instala o SDK, as ferramentas do Flutter ficam armazenadas em cache na sua máquina. Você pode vê-las dentro do diretório bin/cache na sua cópia do SDK do Flutter. Se você decidir integrar qualquer etapa deste processo ao seu próprio sistema de build, esse diretório contém todas as ferramentas versionadas de que você precisa para trabalhar com o Flutter.

As seções a seguir descrevem alguns dos arquivos exclusivos dos bundles de app iOS do Flutter.

Bundle do framework da engine do Flutter

O diretório Flutter.framework, empacotado como um bundle de framework iOS, inclui:

  • Engine do Flutter: contém as bibliotecas principais (por exemplo, gráficos, E/S de arquivos e rede, suporte a acessibilidade, arquitetura de plugins), a DartVM e o renderizador Skia.

  • Assets referenciados pela engine do Flutter: atualmente, são apenas os dados do ICU.

Os buildbots geram o bundle do framework da engine do Flutter, e as ferramentas do Flutter o baixam e armazenam em cache na sua máquina.

Bundle do framework AOT

O bundle App.framework contém um snapshot AOT de todo o código Dart escrito pelo usuário, assim como o código Dart do framework Flutter e dos plugins, nos formatos armv7s e aarch64.

Durante o build de release, o compilador faz tree-shaking no código Dart, de modo que apenas o código realmente usado acaba no bundle. A ferramenta gen_snapshot armazenada em cache na sua máquina gera os artefatos necessários para criar o bundle App.framework.

Snapshot AOT

A biblioteca do snapshot AOT contém o código compilado antecipadamente (ahead-of-time), de Dart para bits de código de máquina nativo.

A biblioteca de snapshot, gerada por gen_snapshot, contém quatro símbolos principais. Esses símbolos podem ser exibidos pelo nm. Por exemplo:

$ nm -gU Runner.app/Frameworks/App.framework/App
Runner.app/Frameworks/App.framework/App (for architecture armv7):
003c6f60 S _kDartIsolateSnapshotData
00007000 T _kDartIsolateSnapshotInstructions
003c16a0 S _kDartVmSnapshotData
00004000 T _kDartVmSnapshotInstructions

Runner.app/Frameworks/App.framework/App (for architecture arm64):
00000000004041a0 S _kDartIsolateSnapshotData
0000000000009000 T _kDartIsolateSnapshotInstructions
00000000003fc740 S _kDartVmSnapshotData
0000000000005000 T _kDartVmSnapshotInstructions

A finalidade deles é a seguinte:

  • Snapshot da VM Dart (kDartVmSnapshotData): Representa o estado inicial do heap do Dart compartilhado entre isolates. Isso ajuda a iniciar isolates do Dart mais rapidamente, mas não contém nenhuma informação específica de isolate.

  • Instruções da VM Dart (kDartVmSnapshotInstructions): Contém instruções AOT para rotinas comuns compartilhadas entre todos os isolates Dart na VM. Esse snapshot geralmente é extremamente pequeno e contém principalmente stubs.

  • Snapshot de isolate (kDartIsolateSnapshotData): Representa o estado inicial do heap do Dart e inclui informações específicas do isolate.

  • Instruções do isolate (kDartIsolateSnapshotInstructions): Contém o código AOT que é executado pelo isolate do Dart.

Invocar o gen_snapshot é simples. Você aponta para o código-fonte Dart, e ele gera um blob para cada um desses quatro símbolos. Em seguida, o Xcode empacota os símbolos em um bundle de framework iOS, exatamente como faria com um framework escrito em C, C++, Objective-C ou Swift.

Saiba mais sobre como configurar o snapshot e a engine na wiki da engine do Flutter.

Além da manipulação do código, as ferramentas do Flutter também garantem que os assets referenciados pelo app (e por seus plugins) acabem no bundle do app. Para isso, elas leem os assets listados no arquivo do projeto pubspec.yaml.

Uma observação sobre o Android

O processo de build de um bundle APK do Android (usando flutter build apk --release, ou sua IDE) resulta na seguinte estrutura de arquivos:

$ Runner.apk.unzipped
├── AndroidManifest.xml
├── assets
│   ├── flutter_assets
│   │   ├── fonts
│   │   │   └── MaterialIcons-Regular.ttf
│   │   └── packages
│   │       └── cupertino_icons
│   │           └── assets
│   │               └── CupertinoIcons.ttf
│   ├── icudtl.dat
│   ├── isolate_snapshot_data
│   ├── isolate_snapshot_instr
│   ├── vm_snapshot_data
│   └── vm_snapshot_instr
├── classes.dex
├── lib
│   └── armeabi-v7a
│       └── libflutter.so
├── output.json
├── res
└── resources.arsc

É praticamente igual a um bundle de release do iOS, exceto por:

  • A engine do Flutter é empacotada como uma biblioteca ELF (libflutter.so).

  • Os 4 símbolos detalhados na seção anterior agora são apenas blobs binários no diretório de assets.

O segundo ponto pode parecer um pouco inesperado e merece uma explicação: você não precisou baixar o NDK para gerar o APK de release. Isso porque, na ausência do NDK na sua máquina, as ferramentas do Flutter adicionam os blobs como assets. No Android, a engine do Flutter pode marcar páginas como executáveis. Assim, quando ela detecta que os assets AOT estão empacotados como blobs binários, ela mapeia esses blobs na memória e marca as páginas correspondentes como executáveis. Se você tiver acesso ao NDK na sua máquina, pode especificar o local dele, e gerar uma biblioteca dinâmica com esses símbolos. Nesse caso, a engine do Flutter usa os 4 símbolos da biblioteca dinâmica.

Resumo

Os pontos principais sobre o build de um bundle de app iOS são:

  • Você pode posicionar uma view do Flutter em qualquer lugar da hierarquia de views nativa. Todo o conteúdo renderizado pelo Flutter será compositado nessa view.

  • O código Dart é compilado para código de máquina nativo e empacotado como uma biblioteca ou framework, assim como qualquer outra biblioteca C++/Objective-C/Swift. Isso significa que todas as ferramentas de relatório de crashes e de simbolicação funcionam da mesma forma para o código AOT do Dart.

  • Você pode integrar o Flutter ao seu próprio sistema de build personalizado sem depender das ferramentas do Flutter na sua máquina de desenvolvimento (embora usá-las facilite a sua vida). Todas as ferramentas estão disponíveis no diretório bin/cache do SDK do Flutter.

Mais do Flutter