Nas últimas semanas comecei a trabalhar em um projeto em meu time é responsável por um microfrontend dentro de uma aplicação mobile. A aplicação que meu time cuida é uma aplicação bastante simples e não exige acesso a muito recursos dos SOs. Dado este cenário tomou-se por decisão o uso de React Native para a construção de aplicações desta natureza.
Com isto resolvi compartilhar em passo-a-passo simples como gerar um Android Archive (AAR) do código ReactNative para ser importado em uma aplicação Android já existente. Tenha em mente que diferentes versões de alguma das bibliotecas podem acarretar no não funcionamento correto, caso isso ocorra StackOverflow está cheio de pequenas dicas, além disso recomendo verificar as issues reportadas no repositório do React Native. Ao final vou listar algumas issues e perguntas que me ajudaram a chegar no resultado.
Dependências:
- Java entre 1.8 e 11
- Android Studio com um SDK e Simulador instalados
- Yarn
- Node
Não entrarei nos por menores da instalação das dependências. Se precisares de mais detalhes pode consultar a página de instalação de ambiente do ReactNative.
Para esse exemplo iremos construir um contador simples. A biblioteca vai expor uma interface onde o usuário poderá incrementar um contador.
Para criar a aplicação ReactNative iremos executar o seguinte comando no terminal:
npx react-native init SimpleReactNativeComponent --version=0.61.5É possível executar a aplicação gerada no simulador usando o seguinte comando:
yarn androidCom código gerado agora podemos construir nossa biblioteca. Para esse projeto iremos assumir que nossa aplicação será executada em uma Activity completa.
Para que nossa aplicação possua ao menos uma funciondalidade que vá além de um "Olá mundo!" criaremos um contador simples. Guardamos no estado o valor do contador e incrementamos ele com um botão na tela.
Para isso será necessário alterar o arquivo App.js e adicionar o conteúdo que está no arquivo correspondente deste gist.
Após realizar as alterações necessárias tu poderá executar a aplicação com o mesmo comando citado anteriormente, yarn android.
Com estas moficações vamos ao que realmente nos interessa.
Quando criamos uma nova aplicação a partir da CLI do ReactNative ele irá configurar a aplicação recém criada para ser construída como uma aplicação Android regular, gerando um APK ao final do processo de build. Como queremos gerar um AAR ao invés um APK.
Para fazer isso precisamos alterar a forma o código que é responsável por construir e empacotar a biblioteca. E também precisamos criar o código responsável para por comunicar como a nossa biblioteca será executada a partir do código na app nativa.
Primeiro, precisamos criar o diretório assets dentro do diretório android/app/main/src. Excutando o comando abaixo você irá realizar isso:
mkdir android/app/src/main/assetsCom este diretório criado, poderemos gerar o bundle da nossa biblioteca ReactNative.
Também é preciso editar o arquivo ./android/app/build.gradle.
Na primeira linha do arquivo build.gradle:
apply plugin: "com.android.application"Por:
apply plugin: "com.android.library"Remover
apply from: "../../node_modules/react-native/react.gradle" // Está próximo a linha 84 do arquivoE por fim remover o applicationId de dentro do bloco defaultConfig.
TODO: colocar as infos do build.gradle
Com tudo isto configurado podemos gerar AAR da nossa biblioteca.
Para facilicar a execução desta etapa adicionei ao final do Gist um arquivo package.json com um script para gerar o arquivo AAR. Ele irá criar o bundle do código javascript com o script android-generate-bundle e empacotar em um AAR com o script android-bundle-lib. Para facilitar a execução, podemos executar somente android-build-lib.
Estemos comandos irão gerar o bundle JavaScript da aplicação, gerar o arquivo AAR com base nas configurações do build.gradle que foram feitas e copiar o aquivo AAR para a raiz do projeto.
Precisamos também construir o código que será responsável por criar camada que permitirá que nosso código JavaScript seja executado a partir da aplicação nativa. Para isso iremos extender a classe ReactContextBaseJavaModule e implementar a classe ReactPackage. Implementando a classe ReactContextBaseJavaModule iremos informar qual o nome do nosso módulo. E a interface ReactPackage para que o nosso módulo seja registrado.
O código que faz isto está ao final do Gist, copie as classes para o seu projeto e pronto.
Precisamos de uma app Android para que nosso AAR seja utilizado, para isso vamos usar o Android Studio e criaremos um projeto do tipo Empty Activity. A única coisa que alterei foi o SDK min para 24 ou Nougat.
Depois de criado um projeto precisamos ir até o diretório do projeto e criar uma novo diretório chamado android e mover todo o conteúdo que existia anteriormente para dentro dele. Depois de concluir isto, precisamos abrir o projeto novamente no Android Studio, agora abrindo o projeto a partir do diretório android. Podemos inclusive executar o projeto criado no emulador.
Ao final você deve ter uma estrutura similar a esta:
UsingRNLibrary/
└── androidPara poder usar nossa biblioteca precisamos fazer executar algumas etapas:
- Instalar o React Native como depedência da aplicação Android
- Instalar a nossa biblioteca como dependência
- Criar uma Activity onde iremos "executar" nossa biblioteca
Agora com a estrutura de diretórios criada podemos realizar as configurações necessárias para instalar a nossa biblioteca no projeto. Primeiro iremos iniciar um projeto, para fazer isso, no diretório UsingRNLibrary iremos executar o comando yarn init. Siga as instruções do CLI e pronto.
Precisamos ainda instalar o React Native, precisamos dele para executar a nossa biblioteca no app de Android. Podemos fazer isso executando yarn install react-native@<versão-da-lib>, é imprescindível que a versão do React Native seja a mesma que a nossa biblioteca foi construída, se não teremos problemas depois.
Certo, com o ReactNative instalado precisamos dizer para o nosso projeto Android que ele é uma dependência. Para fazer isto iremos alterar dois arquivos do nosso projeto:
a. android/build.gradle: aqui iremos dizer onde o React Native está;
b. android/app/build.gradlw: aqui iremos declara-lo como dependência;
Para isso precisamos adicionar ao android/build.gradle o seguinte código dentro do bloco allprojects/repositoties:
maven {
url "$rootDir/../node_modules/react-native/android"
}
maven {
url "$rootDir/../node_modules/jsc-android/dist"
}
flatDir {
dirs "$rootDir/app/aars"
}Dentro do diretório UsingRNLibrary/android/app criaremos um diretório chamado aars que usaremos para armazenar a biblioteca que criamos. Podemos fazer isso com o seguinte comando
mkdir android/app/aarsCom o diretório criado precisamos também informar que esta é um diretório
Agora precisamos indicar ao nosso arquivo de build que ele precisa olhar para esta pasta na hora de fazer o download das dependências. Para isso iremos alterar o arquivo
E no arquivo android/app/build.gradle iremos adicionar o seguinte código dentro do bloco dependencies:
implementation 'com.facebook.react:react-native:0.62.2'
implementation(name: 'simplereactnativecomponent', ext: 'aar')E também no mesmo arquivo precisamos adicionar após a última linha que contém apply plugin: //... o seguinte código:
// Este código diz como ReactNative será
project.ext.react = [
enableHermes: false
]
apply from: "${rootDir}/../node_modules/react-native/react.gradle"Também precisamos dizer quais as dependências preciam ser instaladas
- Melhorar o suporte para executar a biblioteca
- Publicar a biblioteca criada em um repositório de artefatos como Artifactory ou Nexus