Ao iniciar o desenvolvimento mobile focado em dispositivos Android é muito comum que nós desenvolvedores optemos pela utilização do Android Studio – ferramenta de desenvolvimento oficial do Google para a plataforma; isso se deve principalmente ao fato de a ferramenta oferecer um ambiente centralizado para gerenciamento de versões do SDK, emuladores e outras configurações associadas ao processo de configuração do ambiente de desenvolvimento.

Quando o aplicativo desenvolvido é nativo – seja ele em Kotlin ou Java – optar pelo Android Studio gera um diferencial relacionado à velocidade de configuração do ambiente de desenvolvimento. Entretanto, ao trabalhar com frameworks de desenvolvimento híbrido – por exemplo: React Native, Flutter, Ionic etc – as facilidades geradas por essa opção tornam-se questionáveis, principalmente no que tange ao custo computacional associado a instalação do Android Studio.

Na data da produção deste artigo, para a versão Android Studio Bumblebee | 2021.1.1 Patch 3 para MacOSX, temos os seguintes requisitos de hardware:

• Arquitetura de CPU x86_64; segunda geração Intel Core (ou mais recente), ou CPU AMD;
• 8 GB de RAM (ou mais);
• 8 GB de espaço de disco (para armazenar IDE + Android SDK + Android Emulator);
• Resolução de tela mínima de 1280 x 800.
  

Apesar de ser uma configuração que, para os dias atuais, é tranquilamente atendida pelos hardwares dos desenvolvedores, quando falamos em desenvolvimento multiplataforma, parece não fazer muito sentido instalar o Android Studio apenas para configuração do ambiente de desenvolvimento - dificilmente um desenvolvedor multiplataforma utiliza o Android Studio para trabalhar com Flutter, ReactNative ou Ionic, por exemplo.

Ademais, optar pela configuração manual torna-se  justificável também pelo princípio da otimização de recursos - pelo fato de a ferramenta permanecer instalada (ocupando cerca de 8GB), e não ser utilizada a configuração manual, gera prontamente uma economia de armazenamento.

Instalação do SDK Android no MacOS

Dividirei essa sessão em duas partes – a primeira opcional, relacionada a instalação do gerenciador de pacotes homebrew + Java SDK 1.8 e uma subsequente obrigatória – relacionada a instalação do Android SDK, configuração do Android Virtual Device e utilização do Android Emulador.

Parte 1 - Instalação do gerenciador de pacotes Homebrew + Java SDK 1.8

Antes de iniciar o processo de instalação do Android SDK, não podemos esquecer que é estritamente necessário possuir o Java instalado. Não é o tópico principal deste artigo – caso o Homebrew e ou Java já estejam instalados, essa parte pode ser (parcialmente ou totalmente) ignorada, conforme necessário.

Instalação do Homebrew

Inicie o terminal de sua preferência e execute:

/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"

Após isso, o Homebrew estará instalado. O próximo passo é instalar o Java SDK 1.8.

Instalação do Java SDK 1.8

Eu costumo configurar meu ambiente de desenvolvimento híbrido utilizando o Java 1.8; recordo-me de, num passado recente, ter alguns problemas na execução do emulador quando, por exemplo, tentei utilizar o Java 1.9. Então, por garantia – e conhecimento de causa – farei uso dessa versão. Como pode ser observado. Utilizarei o OpenJDK no processo aqui descrito. Para tanto, no terminal, execute:

brew tap AdoptOpenJDK/openjdk

E depois:

brew install --cask homebrew/cask-versions/adoptopenjdk8

Uma mensagem sobre a descontinuação do pacote adoptopenjdk8 será exibida; para tanto, no final da instalação, execute

brew install --cask temurin8

para continuar com uma versão suportada pela comunidade.

Curiosidade: O temurin8 é parte do movimento de migração do AdoptOpenJDK para o Adoptium. Mais informações podem ser encontradas aqui. Seguindo em frente, quando o processo de instalação terminar, para conferir se o Java está corretamente instalado, basta executar:

java -version

A saída da instalação do Java Runtime Environment deve ser:

openjdk version "1.8.0_322"
OpenJDK Runtime Environment (Temurin)(build 1.8.0_322-b06)

E

javac -version

A saída do Java Compiler deve ser:

javac 1.8.0_322

Parte 2 - Instalação do Android SDK Manager

Para instalação do Android SDK manager, é necessário realizar o download da versão mais atual da ferramenta (encontrada em Android Developers) através do comando

curl https://dl.google.com/android/repository/commandlinetools-mac-8092744_latest.zip 
--output ~/Downloads/commandlinetools-mac-8092744_latest.zip

Além do command-line-tools, é necessário fazer o download do platform-tools:

curl https://dl.google.com/android/repository/platform-tools_r33.0.1-darwin.zip --output 
~/Downloads/platform-tools_r33.0.1-darwin.zip

Após a conclusão do download, deve ser realizada a criação do diretório que irá receber a extração da ferramenta. Existem três comandos concatenados, o primeiro para criação do diretório do SDK, o segundo contendo a criação do subdiretório platforms e o terceiro contendo a criação do subdiretório avd.

Sem a criação do subdiretório platforms e do subdiretório avd, o Android Emulator irá quebrar no momento da execução, então é necessário criá-los, mesmo que fiquem vazios ”por enquanto”.

mkdir -p ~/Development/Android/sdk && mkdir -p ~/Development/Android/sdk/platforms && 
mkdir -p ~/Development/Android/sdk/avd

Com os downloads concluídos e os diretórios criados, chegou a hora de extrair as ferramentas; primeiro para o command-line-tools:

unzip ~/Downloads/commandlinetools-mac-8092744_latest.zip -d ~/development/Android/sdk/cmdline-tools-tmp

e depois o mesmo para para o platform tools:

unzip ~/Downloads/platform-tools_r33.0.1-darwin.zip -d ~/development/Android/sdk/

Por questões de organização de diretórios, é necessário realizar um ajuste na estrutura criada, para satisfazer a execução das ferramentas via linha de comando. O ajuste deve ser feito com a execução do seguinte comando:

mkdir -p ~/development/Android/sdk/cmdline-tools/latest && mv ~/development/Android/sdk/cmdline-tools-tmp/cmdline-tools/* ~/development/Android/sdk/cmdline-tools/latest && rm -rf ~/development/Android/sdk/cmdline-tools-tmp

Isto feito, devemos adicionar as variáveis de ambiente para que o sistema operacional reconheça os comandos executados via terminal. Adicione as seguintes variáveis ao arquivo que gerencia suas variáveis de ambiente (~/.bash_profile, por exemplo – no meu caso, como utilizo o zsh, utilizo o zshrc):

export ANDROID_SDK_ROOT="/Users/kckoerich/development/Android/sdk"
export ANDROID_CMD_LINE_TOOLS="$ANDROID_SDK_ROOT/cmdline-tools/latest"
export ANDROID_PLATFORM_TOOLS="$ANDROID_SDK_ROOT/platform-tools"
export ANDROID_AVD_HOME="$ANDROID_SDK_ROOT/avd"

após a criação das variáveis, devemos a adicioná-las ao PATH

export PATH="$PATH:$ANDROID_CMD_LINE_TOOLS/bin:$ANDROID_SDK_ROOT:$ANDROID_PLATFORM_TOOLS"

Importante lembrar que é necessário recarregar o arquivo de configurações do utilizando o comando

source ~/.zshrc ou source ~/. bash_profile

Tudo instalado, hora de utilizar as ferramentas instaladas.

Utilizando o Android SDK Manager

Primeiramente, vamos instalar as ferramentas de linha de comando utilizadas pelo SDK do Android (nesse ponto, os diretórios criados sem conteúdo serão populados):

sdkmanager "platform-tools" "platforms;android-32" "build-tools;32.0.0"

Com tudo instalado e configurado, chegou a hora de selecionar uma versão do SDK do Android, realizar o download através do SDK manager para utilizarmos no desenvolvimento dos aplicativos.

Para aceitar os termos de uso do SDK manager, utilizamos o seguinte comando:

sdkmanager --licenses

Para listagem das versões disponíveis do SDK, utilize o seguinte comando:

sdkmanager –list

Após escolher a versão desejada, ela deve ser instalada com o seguinte comando:

sdkmanager "system-images;android-32;google_apis_playstore;x86_64"

para mais informações sobre o uso do sdkmanager, utilize:

sdkmanager –help

Criando e Executando um Android Virtual Device

Após a instalação do SDK, devemos criar um device android baseado na versão escolhida, através do avdmanager (Android Virtual Device manager); comumente crio meus emuladores da seguinte maneira:

avdmanager create avd --name android32 --abi google_apis_playstore/x86_64 --package 'system-images;android-32;google_apis_playstore;x86_64'

Explicando um pouco mais de cada parte do comando:

create – para a criação
name – nome do emulador
package – a imagem utilizada, com base no download executado pelo SDK manager
abi – (Aplication Binary Interface, ou interface do aplicativo binária) é a plataforma de execução no qual o emulador será criado

Para mais informações sobre o uso do avdmanager, utilize:

avdmanager –help

Dê permissão de execução ao binário do emulator

chmod +x ~/Development/Android/sdk/emulator/emulator

Crie um link simbólico para o emulator

ln -sf ~/Development/Android/sdk/emulator/emulator /usr/local/bin/emulator

Após realizar as configurações acima, para executar o emulador devemos utilizar o seguinte comando:

emulator @android32

Onde o conteúdo após o @ é o nome do AVD que se deseja executar. O parâmetro skin é opcional, mas é interessante utilizá-lo para definir a resolução aplicada no emulador que irá ser executado.

Bônus - Melhoria de configurações no emulador criado:

Edite o arquivo config.ini do emulador criado (o caminho do arquivo é $ANDROID_AVD_HOME/android32.avd/config.ini), substituindo os valores das variáveis apresentadas para os seguintes:

hw.keyboard = yes
hw.ramSize = 1024M
hw.lcd.height = 1280
hw.lcd.width = 720
hw.gpu.enabled = yes

Com isso feito, caso eu fosse iniciar o desenvolvimento de um projeto com Flutter, meu ambiente Android estaria todo configurado, sem nenhuma dependência com o Android Studio:

Prós x Contras

Separei alguns prós e contras acerca da abordagem proposta:

Considerações finais

É evidente que o processo como um todo não é (nada) trivial. São alguns downloads, extrações, configurações de diretório, definições de variáveis de ambiente, mais downloads, mais configurações... que podem facilmente serem substituídas pelo download do Android Studio + uma série de cliques – o básico avançar, avançar e concluir.

Entretanto, devemos levar em consideração que a utilização do Android Studio não faz sentido em todos os cenários – principalmente àquele que tange o desenvolvimento híbrido (utilizando Flutter, ReactNative, Ionic etc). O Android Studio figura apenas para a configuração dos tópicos abordados no decorrer desse artigo, principalmente pelo fato de muitos dos desenvolvedores utilizarem outras IDEs e ou conjunto de ferramentas durante o processo de codificação – como por exemplo VSCode, Sublime, Intellij etc.

Apesar de não ser um processo tão prático, a aplicação dos conceitos abordados neste artigo nos permite um melhor entendimento de cada uma das etapas ocultas por trás dos cliques no Android Studio. Desde o download do SDK à criação do emulador, é possível visualizar e controlar parâmetros em diversos aspectos, com intuito de otimizar a utilização dos recursos disponíveis no ambiente de desenvolvimento; não que isso não seja possível utilizando o Android Studio, mas configurando as coisas manualmente, tornamo-nos livres de uma ferramenta a mais, que em muitos cenários é utilizada meramente para configuração.