O caminho do Flutter rumo à interoperabilidade perfeita
Saiba sobre o programa de acesso antecipado do Flutter para interoperabilidade nativa direta com FFIgen e JNIgen.
Hoje, estamos animados para anunciar um programa de acesso antecipado para autores de plugins Flutter que estão prontos para criar ou recriar um plugin usando as soluções de codegen. Esta é a próxima fase do nosso trabalho para facilitar o acesso dos desenvolvedores Flutter às APIs nativas da plataforma usando FFIgen e JNIgen. Há um número limitado de vagas, concedidas por inscrição, para quem está pronto para se engajar diretamente conosco em uma primeira onda de plugins de produção que usam FFIgen e JNIgen.
Este post aborda mais sobre o que esperamos alcançar com a interoperabilidade nativa direta, como pretendemos chegar lá, além de mais detalhes sobre o programa de acesso antecipado e como você pode nos acompanhar nessa jornada.
O desafio fundamental
Os desenvolvedores frequentemente precisam chamar APIs nativas da plataforma host em que o app está sendo executado, como iOS ou Android. Atualmente, os desenvolvedores Flutter podem fazer isso usando method channels. Os method channels dependem da troca de mensagens entre o código Dart e o código nativo (como Kotlin ou Swift) para chamar as APIs nativas. Ou seja, o código Dart envia uma mensagem ao código nativo, que faz algo e depois responde enviando o resultado em outra mensagem.
O grande desafio dos method channels é que eles podem ser demorados de implementar e manter. Exigem muito código escrito manualmente. A manutenção exige atualizar manualmente a implementação para chamar a versão mais recente da API. Eles também podem ser propensos a erros, pois dependem de codificar e decodificar mensagens em strings, o que pode levar a erros em tempo de execução se as APIs mudarem. Por fim, os method channels só oferecem suporte a chamadas assíncronas, que mantêm a UI responsiva, mas podem adicionar complexidade ao código ao gerenciar resultados assíncronos, tratar erros e lidar com a possível latência ao aguardar resultados.
Resolvemos alguns dos pontos problemáticos de usar method channels com o Pigeon, uma ferramenta que gera código de esqueleto para APIs Dart e nativas para lidar com as mensagens que você, de outra forma, escreveria manualmente com method channels. Embora o Pigeon reduza o tempo gasto em encapsular métodos e escrever handlers de mensagens entre o código Dart e o nativo, APIs com grande superfície ainda exigem código tedioso. Por exemplo, o plugin de compras no app do iOS interage com muitos
StoreKit objetos e, como eles estão aninhados dentro de outros objetos nativos, é preciso muito código manual para convertê-los em classes serializáveis do Pigeon no lado Objective-C e converter essas classes do Pigeon de volta para classes wrapper no lado Dart.
Além disso, a interoperabilidade entre dois plugins é um desafio, e não há como passar um objeto não serializável, como um
Image do Android, pelo Dart para outro plugin sem que cada um deles dependa do outro.
A visão do Flutter para a interoperabilidade
Como disse Michael Thomsen durante o #FlutterInProduction, “Estamos investindo muito em uma nova abordagem para isso, que chamamos de interop nativa direta.”
Nossa visão para a interoperabilidade é, em última instância, tornar o acesso às APIs da plataforma mais simples para os desenvolvedores, com uma experiência de desenvolvimento direta e sem atritos. O objetivo é permitir que os desenvolvedores Flutter dediquem mais tempo à experiência que estão tentando criar e menos tempo tentando aproveitar o poder da plataforma subjacente.
A solução
Planejamos resolver o desafio fundamental de interop com soluções de codegen chamadas FFIgen e JNIgen, que cuidam da ponte entre Dart e código nativo diretamente para cada plataforma. O FFIgen vai gerar bindings para encapsular APIs Objective-C e Swift, enquanto o JNIgen fará o mesmo para APIs Java e Kotlin.
Diferentemente dos method channels, FFIgen e JNIgen permitirão que as APIs sejam chamadas de forma síncrona, oferecerão suporte a tree-shaking (remoção de código não utilizado durante a compilação) e permitirão que mais dados fiquem na camada da plataforma.
O usuário ideal
Nesta fase inicial, os usuários ideais da nova interop direta são desenvolvedores Flutter com profundo conhecimento de plataformas nativas (iOS, Android ou ambas), com forte desejo de acessar diretamente qualquer API da plataforma de que precisem e com menos trabalho repetitivo. Com FFIgen e JNIgen, eles podem gastar muito menos tempo fazendo a ponte entre Dart e o código nativo, facilitando a criação e a manutenção de plugins para o ecossistema.
À medida que as ferramentas ficarem mais robustas, imaginamos que qualquer desenvolvedor Flutter com boa experiência em plataformas nativas poderá acessar qualquer API da plataforma (como uma que ainda não esteja disponível para Flutter em produção ou por meio de um pacote no pub.dev) para gerar o código de que precisa e chamar essa API diretamente com Dart dentro do seu app Flutter.
Nossa expectativa é entregar uma solução bem melhor do que a atual, por meio de uma experiência de desenvolvimento simplificada: uma que seja mágica nos lugares certos, sem obrigar o desenvolvedor a abrir mão do controle.
Participe do Programa de Acesso Antecipado do Interop
Estamos procurando candidatos com boa experiência em criar plugins Flutter e em usar as ferramentas do Flutter para participar de um programa de acesso antecipado, no qual você reescreveria plugins existentes para usar interop direto e forneceria feedback detalhado e issues para orientar o desenvolvimento futuro. Como em qualquer programa de prévia, haverá inevitavelmente algumas arestas pelo caminho, mas estamos prontos para dar suporte e acesso antecipado para superar quaisquer obstáculos que você encontrar.
Manifeste seu interesse preenchendo este formulário. Provavelmente não conseguiremos incluir todos os que se inscreverem neste programa antecipado. Os candidatos selecionados receberão notícias nossas após 20 de junho de 2025.
Estamos ansiosos para ouvir você!