KOTLIN MULTIPLATFORM - HÍBRIDO E NATIVO EM ANDROID E IOS
Fone: 8h - 17PM

Dextra

KOTLIN MULTIPLATFORM – HÍBRIDO E NATIVO EM ANDROID E IOS

Por: 28/01/2019

Construir um app mobile levanta, logo de início, a necessidade de atender às duas plataformas, Android e iOS. Para o processo de desenvolvimento, isso implica esforço dobrado: ter que repetir códigos e layouts, para cada plataforma, o que é custoso para o projeto e para os programadores.

Os códigos híbridos, que atendem às duas plataformas ao mesmo tempo, vêm para combater isso. Eles centralizam a lógica em um lugar só, e basta compartilhar entre os dois projetos para funcionar.

Entre as soluções híbridas, a Kotlin Multiplatform se destaca.

512px-Kotlin-logo.svg

A Kotlin Multiplataform usa Kotlin, uma linguagem de programação poderosa e fácil de ler e escrever, que foi eleita em 2018 como a 2ª linguagem de programação preferida entre os usuários do site Stack Overflow.

Entre as principais vantagens da Kotlin Multiplatform, estão:

  • Compartilhamento de código entre Android e iOS.
  • Linguagem de programação robusta e de compreensão fácil por desenvolvedores Android, acostumados com Java e Kotlin, e desenvolvedores iOS, acostumados com Swift.
  • Retrocompatibilidade com projetos já existentes. A Kotlin Multiplatform pode ser inserida em um projeto sem ser necessário recriar o aplicativo atual.

COMO FUNCIONA

A idéia da Kotlin Multiplatform é simples:

  • Para projetos Android, o código Kotlin é compilado para bytecodes Java, e o projeto o importa como um módulo.
  • Para projetos iOS, o código Kotlin é compilado para um binário nativo de iOS, que é importado pelo projeto como framework.

Há 3 tipos de código dentro do Kotlin Multiplatform: common (comum), Android e iOS.

O common é usado por ambas as plataformas. Já o código Android e o código iOS são exclusivos para cada uma, respectivamente.

CRIANDO SEU PRIMEIRO PROJETO

Para criar seu primeiro projeto usando Kotlin Multiplatform, recomenda-se usar a versão Canary mais recente do Android Studio. No tutorial, usou-se o Android Studio Canary. Links de download:

Windows
Linux
Mac

Para o desenvolvimento iOS, foi usado o XCode 10.

O tutorial é baseado no exemplo do site oficial do Kotlin e é livre, seguindo a licença de uso.

CRIANDO O MÓDULO COMPARTILHADO

O primeiro passo é criar uma pasta onde ficará o módulo compartilhado. Deve-se também criar as subpastas e o arquivo build.gradle do módulo.

A explicação completa de como estruturar o módulo compartilhado está abaixo. Também foram criados scripts para Shell (Linux e Mac) e Batch (Windows) para automatizar a criação:

Script Shell para criar módulo Kotlin Multiplataform

Script Batch para criar módulo Kotlin Multiplataform

Como exemplo, cria-se uma pasta do projeto e uma com o nome KotlinSharedLibrary. Dentro dela, deverão ser criadas as pastas com a estrutura:



BUILD.GRADLE DO MÓDULO COMPARTILHADO

Na pasta /KotlinSharedLibrary/, deve ser criado o arquivo build.gradle do módulo compartilhado, que coordena a compilação do código para Android e a exportação do framework iOS para o XCode.

O exemplo a seguir mostra o conteúdo básico desse build.gradle:

As variáveis $kotlin_version, $rootProject.mockitoVersion e $rootProject.jUnitVersion são importadas do projeto raíz do Android, e serão definidas a seguir. Porém, se optar por definir aqui, a versão do Kotlin deve ser igual para todas as dependências e igual ou superior à 1.3.x, por exemplo, 1.3.10. Para o JUnit, foi usada a versão 4.12, e para o Mockito, foi usada a versão 2.19.0.

O bloco targets configura como o módulo será usado: importado como módulo, no caso do Android, ou exportando um framework, no caso do iOS.

Os blocos commonMain, commonTest de sourceSets permitem importar dependências Kotlin Native que podem ser usadas no código common.

Os blocos androidMain e androidTest de sourceSets permitem importar dependências em Java. No exemplo, importam-se o JUnit e o Mockito.

Por fim, a task packForXCode, quando executada, cria o arquivo .framework usado pelo XCode.

GRADLE DO PROJETO RAÍZ

O módulo compartilhado fará parte de um projeto raíz, no caso, um projeto Android. Por isso, é necessário configurar o Gradle do projeto Android também.

Neste exemplo, a pasta do módulo compartilhado e a pasta do projeto raíz Android estão em uma mesma pasta.

O projeto Android está na pasta /KotlinSharedAndroid/.

Para configurar o Gradle do projeto raíz Android:

  • 1) Usar uma versão do Gradle igual ou superior à 4.7

No arquivo gradle-wrapper.properties do projeto Android, deve-se configurar a versão do Gradle para igual ou superior à 4.7. No exemplo, foi usada a versão 5.1.1. Para isso, basta editar a URL de distribuição do Gradle:

distributionUrl=https\://services.gradle.org/distributions/gradle-5.1.1-all.zip

  • 2) Especificar os repositórios Maven e a versão do Kotlin, e o Android Studio Gradle Plugin

No arquivo build.gradle do projeto raíz do Android (KotlinSharedAndroid), os repositórios Maven do Kotlin e a versão do Kotlin precisam ser adicionados. Também altera-se a versão do Android Studio Gradle Plugin para igual ou superior à 3.3. Aqui, foi usada a versão 3.4.0-alpha10.

  • 3) Referenciar o módulo compartilhado no settings.gradle

Para importar o módulo compartilhado, deve-se referenciar o caminho da pasta no settings.gradle.

O arquivo settings.gradle do KotlinSharedAndroid deve importar assim:

  • 4) Importar a dependência do módulo no build.gradle do app

No build.gradle do módulo app do projeto Android, importa-se o módulo KotlinSharedLibrary como dependência.

dependencies {
implementation fileTree(dir: 'libs', include: ['*.jar'])
implementation project(':KotlinSharedLibrary')

Por fim, é necessário realizar o Sync Project with Gradle Files (File -> Sync Project with Gradle Files) no Android Studio.

CÓDIGO KOTLIN

No Android Studio, é mais fácil de visualizar os arquivos do módulo compartilhado se a opção Project estiver selecionada (na barra lateral esquerda, escolher 1: Project e na caixa à direita, Project novamente).

Aqui, cria-se 3 arquivos Kotlin:

  • Na pasta /KotlinSharedLibrary/src/commonMain/kotlin/ , cria-se o arquivo Person.kt:
  • Na pasta /KotlinSharedLibrary/src/androidMain/kotlin/, cria-se o arquivo AndroidPerson.kt:
  • Na pasta /KotlinSharedLibrary/src/iOSMain/kotlin/, cria-se o arquivo IosPerson.kt:

A classe abstrata Person tem duas variáveis, name e age, também abstratas. Há também uma função abstrata platformName().

A classe AndroidPerson herda da classe Person e implementa uma interface Serializable, o que é possível porque a classe AndroidPerson será compilada para Java. A função platformName() é sobrecarregada e retorna a string “Android”.

A classe IosPerson também herda da classe Person. A função platformName() é sobrecarregada e retorna o nome da versão do iOS que está sendo usada, através do UIKit.

USANDO O MÓDULO COMPARTILHADO NO ANDROID

Para usar as classes Kotlin do módulo compartilhado, basta importá-las em seu código do projeto Android, normalmente.

No exemplo, uma Activity mostra uma TextView com um texto formatado por um objeto da classe AndroidPerson.

activity_main.xml

MainActivity.java

Ao executar o app no emulador, a tela mostra:

KMP_MainActivity_App_Android

USANDO O MÓDULO COMPARTILHADO NO iOS

Agora, cria-se o projeto do app iOS. Aqui, o projeto será criado na pasta /KotlinMultiplatformProject/KotlinSharedIOS.

Para usar o módulo compartilhado em um projeto iOS, é preciso gerar o framework que será importado no XCode.

Para isso, requer-se um computador Mac OS, no qual será executada a task packForXCode do Gradle.

No Android Studio no Mac, no lado direito da tela, ir em Gradle -> :KotlinSharedLibrary -> Tasks -> Other -> :KotlinSharedLibrary:packForXCode, e clicar duas vezes para executar.

KMP_iOS_PackForXCode

Ao fim da task, o framework gerado estará na pasta /KotlinSharedLibrary/build/xcode-frameworks. Então, copiar o framework para a pasta /KotlinSharedIOS/:

KMP_iOS_FrameworkLocation

KMP_iOS_CopyFramework

Voltando para o XCode, o framework será incorporado ao projeto.

Primeiro, deve-se desabilitar a opção Enable BitCode:

KMP_iOS_DisableBitcode

Em seguida, para importar o framework:

KMP_iOS_ImportFramework

Pronto. O código da KotlinSharedLibrary já está disponível para ser usado.

Em uma tela de exemplo, uma UILabel mostra um texto a partir de um objeto IosPerson. No exemplo, a label foi criada via storyboard.

ViewController.swift

Ao abrir o app no simulador, vê-se:

KMP_iOS_AppScreen

O framework precisa ser importado sempre que há uma alteração no módulo compartilhado, porém, isso pode ser automatizado no XCode. Na aba Build Phases, é possível adicionar um New Run Script Phase que gera e copia o framework:


cd "$SRCROOT/../KotlinSharedAndroid"
./gradlew :KotlinSharedLibrary:packForXCode -PXCODE_CONFIGURATION=${CONFIGURATION}
cp -R "$SRCROOT/../KotlinSharedLibrary/build/xcode-frameworks/KotlinSharedLibrary.framework" "$SRCROOT"

CONCLUSÃO

Com a Kotlin Multiplatform, compartilhar código entre Android e iOS ficou fácil.

Em um projeto, o código compartilhado pode ser usado para definir constantes, modelos (models), classes utilitárias e até mais: em arquiteturas como MVP e MVVM, um único Presenter ou ViewModel pode ser usado tanto pelo Android como pelo iOS.

A tecnologia é recente e novas melhorias e funcionalidades estão por vir nos próximos meses.

Algum comentário ou dúvida? Mande um email para cerberus@dextra-sw.com.

Entre em Contato

Mensagem enviada com sucesso!

Tags

Comentários