Como lidar com dependências específicas da plataforma no Kotlin Multiplatform

Kotlin Multiplatform (KMP) permite que os desenvolvedores adotem gradualmente recursos compartilhados para projetos multiplataforma, sem precisar revisar completamente a base de código existente. A flexibilidade e versatilidade desta tecnologia fazem do KMP uma estrutura excepcional e cuidadosamente projetada.

Se você é novo na estrutura Kotlin Multiplatform, Get Started with Kotlin Multiplatform é um recurso inestimável.

Em cenários específicos, especialmente ao construir recursos compartilhados em projetos KMP, surge a necessidade de implementar dependências específicas em alvos KMP. Considere, por exemplo, um cenário em que um aplicativo KMP ou Compose Multiplataforma tem como alvo as plataformas Android e iOS. Existem algumas opções se você precisar de uma dependência específica para ambas as plataformas. No Android, você pode adicionar a dependência do Android, como faria em um aplicativo Android típico, mas no iOS você tem várias opções:

• Verifique se a dependência do iOS faz parte das bibliotecas de plataforma pré-construídas em projetos Kotlin Multiplatform nas bibliotecas Kotlin Native (por exemplo, Core Foundation, Core Data, Cloud Kit). Neste caso, nenhuma configuração adicional é necessária; leia Adicionando dependências do iOS para obter mais informações.
• Integre-se ao gerenciador de dependências CocoaPods do Kotlin e, em seguida, importe e chame as dependências do pod diretamente do seu código Kotlin – isso é recomendado de acordo com os documentos do Kotlin. Ao usar este método, observe que Kotlin oferece suporte à interoperabilidade com dependências Objective-C e dependências Swift somente se suas APIs são exportadas para Objective-C com o @objc atributos. Dependências Pure Swift ou pods Swift ainda não são compatíveis. Embora você possa baixar a biblioteca diretamente e adicioná-la ao seu conjunto de origem, não recomendo essa opção. Dito isso, usar CocoaPods é uma excelente opção, e há muitos artigos e postagens sobre isso que você pode encontrar com uma simples pesquisa na Internet. Usar CocoaPods junto com a verificação de dependências nas bibliotecas Kotlin permite que você aproveite implementações esperadas/reais ou a estrutura de injeção de dependência (DI) para utilizar dependências do iOS.
• O uso de APIs específicas da plataforma por meio de uma interface compartilhada implementada em Kotlin e Swift costuma ser relevante para bibliotecas existentes de terceiros. Essas APIs são passadas dos módulos da plataforma de destino para o módulo compartilhado. A documentação oficial do Kotlin aconselha a verificação de uma alternativa de biblioteca multiplataforma antes de usar APIs específicas da plataforma. Este é um bom conselho, e eu recomendo fortemente explorar o incrível repositório kmp para procurar bibliotecas multiplataforma adequadas. No entanto, dado que o Kotlin Multiplatform ainda está evoluindo, muitas bibliotecas carecem de uma versão KMP oficial ou recomendada ou de uma alternativa confiável com suporte garantido de longo prazo. Esses cenários geram a necessidade de discutir a implementação de componentes de plataforma compartilhados em um projeto KMP e o provisionamento e implementação de APIs específicas da plataforma, como explorarei nesta série de artigos.

Esta série de artigos também cobre:

• Como criar um ApplicationComponent para usar como uma ponte para passar componentes entre os módulos de destino (plataforma) e o módulo compartilhado.
• Como usar Koin como biblioteca DI para injetar esses componentes.
• Como implementar um ouvinte de rede simples no Android e iOS para um projeto KMP.

Para ajudar a orientá-lo, criei um vídeo para mostrar o resultado do seu trabalho.

Primeiros passos: apresentando o ApplicationComponent

O termo ApplicationComponent refere-se a uma classe projetada com propriedades que podem ser implementadas ou utilizadas pela plataforma Android ou iOS. A nomenclatura e o conceito foram inspirados na estrutura usada no repositório de aplicativos Tivi de Chris Banes no GitHub.

Para começar, inicie um novo projeto com o Kotlin Multiplatform Wizard. Se você não estiver familiarizado com a estrutura de pastas ou layout do projeto do Kotlin Multiplatform, leia primeiro Os princípios básicos da estrutura do projeto multiplataforma Kotlin para aprender como um aplicativo KMP é organizado e a finalidade de cada componente.

Este exemplo configura um projeto Compose Multiplatform. Cada plataforma terá seu componente personalizado: AndroidApplicationComponent para Android e iOSApplicationComponent para iOS.

Após a criação, a arquitetura do seu projeto ficará organizada da seguinte forma:

/
...
- composeApp
- src
- androidMain
- commonMain
- iosMain
- iosApp
…

Comece com o composeApp módulo. Dentro do androidMain e iosMain conjuntos de origem, crie um novo diretório ou pacote chamado platform. Neste local defina seu ApplicationComponent Aulas. No mesmo arquivo, implemente uma função chamada application que aceitará o respectivo ApplicationComponent como seu argumento.

Você lançou as bases; agora é hora de configurar o ponto de entrada em cada fonte para inicializar cada componente. Comece com o androidMain conjunto fonte. Aqui, crie um Application classe nomeada ExampleApp. Certifique-se de declarar esta classe na sua AndroidManifest.xml. Em seguida, emulando as convenções da documentação do JetBrains (JB), invoque o application função que você definiu anteriormente.

Veja como isso é feito:

O ponto de entrada para o aplicativo iOS pode ser acessado através do iOSApp diretório. Basta procurar o IOSApp.swift arquivo e faça estas alterações:

E aí está: uma ponte de plataforma que pode transferir componentes de várias plataformas para o seu módulo compartilhado. Normalmente, esses componentes podem ser interfaces compartilhadas com implementações específicas da plataforma ou dependências específicas da plataforma, como UserDefaults no iOS ou no Android Application aula. É importante notar que essa arquitetura mudará ligeiramente quando você incorporar o DI.

Para finalizar, aqui está um instantâneo de como a estrutura do projeto aparece após a implementação dessas modificações:

/
...
- composeApp
- src
- androidMain
- kotlin
- org.example.project
- platform
AndroidApplicationComponent.kt
ExampleApp.kt
MainActivity.kt
- commonMain
- kotlin
- org.example.project
App.kt
- iosMain
- kotlin
- org.example.project
- platform
IosApplicationComponent.kt
MainViewController.kt
- iosApp
- iosApp
IOSApp.swift
…

OBSERVAÇÃO: como a IU do Compose é compartilhada entre as duas plataformas, o androidApp módulo não está incluído, permitindo que você estabeleça todas as dependências específicas do Android diretamente no androidMain fonte definida via DI. Como resultado, para o escopo deste artigo, não utilizarei o AndroidApplicationComponent. No entanto, este componente ainda pode ser relevante em diferentes contextos, como na integração incremental do KMP em projetos com interfaces de usuário (UIs) distintas para cada plataforma.

Injeção de dependência: usando Koin para auxiliar na injeção de componentes

À medida que você aumenta a escala e a contagem de componentes aumenta, a simplificação do fornecimento de dependências torna-se essencial, e é aqui que a estrutura Koin DI entra em cena. Se você não está familiarizado com o Koin ou está migrando do Dagger, Hilt ou outra estrutura de DI, sugiro fortemente que você leia a documentação oficial do Koin para obter tutoriais e guias abrangentes.

Koin DI centraliza a inicialização de seus componentes dentro do platformModule. A configuração é simples – basta seguir as etapas fornecidas pela equipe JB. Irei me aprofundar nesse processo no segundo artigo desta série, quando explicarei como integrar sua primeira dependência.

Para iniciar o Koin em seu projeto, comece no commonMain fonte definida criando um novo pacote chamado di. Em seguida, prossiga com a seguinte configuração:

Com a base agora definida, você pode usar Koin em diferentes plataformas.

Em primeiro lugar, é crucial garantir que o ApplicationComponents para ambas as plataformas são injetados corretamente em seus respectivos gráficos de dependência. Essa abordagem garante que você possa acessar de forma consistente quaisquer componentes adicionais vinculados a eles. Por uma questão de organização, prefiro separar o processo de inicialização; assim, vou criar KoinInit.android.kte KoinInit.ios.kt arquivos. Esta etapa, embora não seja obrigatória – especialmente no androidMain conjunto de origem – é mais sobre estilo e preferência de codificação pessoal.

Em seguida, retorne ao seu ExampleApp.kt arquivo no projeto Android e inicie o Koin. A configuração deve ser semelhante a esta:

E voilà, isso é tudo! Com estes passos, o AndroidApplicationComponent agora está integrado ao gráfico DI. O processo para iOS segue um padrão semelhante. No lado do iOS, você empregará outro método para fornecer módulos adicionais do iosApp módulo através do IosApplicationComponent. Este método, initKoinIosirá essencialmente adicionar o IosApplicationComponent como um módulo extra exclusivamente para o conjunto de fontes compartilhadas do iOS.

Utilize-o em seu código Swift assim:

Agora você lançou as bases para o Kotlin Multiplatform. Na segunda parte desta série, explicarei como utilizar esses componentes, principalmente o IosApplicationComponentpara implementar um ouvinte de rede simples no Android e iOS.

A mudança para a contratação remota e sem fronteiras permite que as empresas olhem para além das restrições geográficas para aceder a talentos globais. Explore estratégias para construir equipes distribuídas globalmente e de alto desempenho baixando The Future of Hiring Is Borderless.

A postagem Como lidar com dependências específicas da plataforma no Kotlin Multiplatform apareceu pela primeira vez em The New Stack.