Uma nova geração de ferramentas de terminal para Android está mudando o cotidiano de desenvolvimento com velocidade, leveza e automação. A proposta reúne uma CLI do Android moderna, um catálogo de habilidades (skills) oficiais e uma Base de conhecimento especializada, permitindo criar, configurar e validar apps com menos passos manuais e com padronização desde o início. O resultado direto é um ambiente mais enxuto, previsível e prático para tarefas que antes exigiam navegação por janelas, múltiplas telas e ajustes finos repetitivos. A consolidação desses fluxos aumenta a produtividade e reduz erros, tornando a experiência adequada tanto para quem está começando quanto para rotinas avançadas de automação e CI.
Essa abordagem prioriza um fluxo orientado a agentes, isto é, softwares que executam instruções com base em contexto, regras e objetivos definidos. Em vez de depender de etapas manuais ou de uma IDE específica, o desenvolvimento gira em torno de comandos claros que criam projetos, manipulam dispositivos virtuais, instalam componentes do SDK e implantam APKs. O terminal torna-se o ponto de entrada único para tarefas críticas e padronizadas, eliminando dúvidas sobre versões, caminhos e modelos de projeto. A integração com instruções oficiais e atualizadas favorece decisões consistentes e mais qualidade de código desde o primeiro commit.
O que é a Android CLI e por que acelera o desenvolvimento
A CLI do Android é uma interface de linha de comando que padroniza tarefas essenciais de criação, execução e manutenção de apps. Essa padronização diminui a ambiguidade comum a ferramentas diversas e reduz o esforço cognitivo em configurar tudo corretamente. Como ponto central, a CLI conversa com o SDK, gerencia dispositivos virtuais e aplica modelos oficiais de projeto. Em fluxos com agentes, a execução fica mais direta e previsível, pois cada comando expressa a intenção com precisão técnica. Essa precisão encurta ciclos, reduz erros e melhora a reprodutibilidade em qualquer ambiente.
O ganho de tempo ocorre porque operações frequentes deixam de exigir navegação por menus ou scripts artesanais pouco padronizados. A criação de projetos usa modelos alinhados às práticas recomendadas, evitando retrabalho estrutural. O gerenciamento de pacotes do SDK foca apenas no necessário, mantendo o ambiente enxuto e rápido de atualizar. Em paralelo, a integração com habilidades e a Base de conhecimento garante instruções atuais e executáveis. Assim, tarefas que antes eram dispersas passam a seguir um único trilho, com menos retrabalho e maior consistência.
Como era antes e como fica com a CLI
Sem uma CLI unificada, a jornada comum envolvia abrir a IDE, escolher assistentes de criação de projeto, ajustar versões e instalar componentes manualmente. Dispositivos virtuais eram configurados por janelas específicas, e a execução dependia de navegação entre múltiplas telas. A documentação costumava ser consumida fora do fluxo, exigindo interpretação e adaptação antes de aplicar comandos práticos. Esse contexto criava variações no setup e replicabilidade imperfeita entre máquinas e times. Erros de configuração apareciam com frequência, impactando prazos e estabilidade.
Com a CLI, o ciclo muda para comandos declarativos e versionáveis, que descrevem o que criar, instalar e executar. O projeto nasce de um modelo oficial, o SDK instala apenas o necessário e o emulador é criado e iniciado pelo terminal. A documentação é consultada com buscas que retornam trechos prontos para uso contextualizado. A implantação no dispositivo ocorre com um comando explícito, incluindo seleção de atividade e modo de depuração quando necessário. A previsibilidade aumenta e o tempo de ida e volta entre tentativas diminui sensivelmente.
Instalação, atualização e verificação
A instalação começa pelo download da ferramenta em sua distribuição disponibilizada oficialmente, seguindo a convenção do sistema operacional. Após instalar, a atualização mantém o conjunto de recursos no estado mais recente, reduzindo incompatibilidades de versões. A verificação local confirma se o comando principal está no PATH e apto ao uso imediato. O processo inteiro leva poucos minutos e cria uma base sólida para qualquer tipo de automação. Em seguida, o ambiente já está preparado para criação de projetos ou gerenciamento do SDK.
Para atualizar a CLI instalada, o comando de atualização verifica, baixa e aplica incrementos automaticamente. A checagem de existência no sistema pode ser feita com utilitários do shell, retornando o caminho quando disponível. Em contextos corporativos, essa verificação ajuda a padronizar versões em máquinas diferentes. A execução periódica da atualização mantém a ferramenta alinhada às melhores práticas recentes. Eventuais mudanças de comportamento são acompanhadas por melhorias de estabilidade e compatibilidade.
android update
which android
command -v android
Há um problema conhecido: o comando de emulador no Windows está temporariamente desativado. Em ambientes Windows, a criação e o controle do dispositivo virtual podem exigir alternativas temporárias até a reativação. Em plataformas macOS e Linux, as rotinas de emulação estão disponíveis normalmente. O restante dos recursos da CLI funciona independentemente desse detalhe. Esse tipo de informação evita diagnósticos longos de falhas que não dependem do projeto.
Opções globais e convenções de uso
Os comandos seguem um padrão legível, com flags que modulam comportamentos e exibem ajuda quando necessário. A opção de ajuda exibe guias tanto gerais quanto específicos de cada subcomando. Já a opção de seleção de SDK permite alternar temporariamente o caminho usado para rodar um comando, sem alterar variáveis de ambiente globais. Isso facilita testes com múltiplas instalações do SDK em paralelo. Para checar qual SDK está ativo por padrão, um comando informativo está disponível.
android -h
android create -h
android --sdk=/caminho/para/sdk sdk list
android info
Criação e descrição de projetos
A criação de um projeto novo parte de um template oficial, garantindo arquitetura, dependências e estrutura recomendadas. É possível simular a criação com dry-run para avaliar arquivos gerados sem escrever no disco. O modo verbose revela detalhes úteis para auditoria e integração com logs de CI. O nome e o destino podem ser informados para controlar exatamente onde o projeto será criado. Caso nenhum modelo seja indicado, um template padrão é aplicado.
android create --dry-run --verbose empty-activity-agp-9
A listagem de modelos disponíveis evita dúvidas sobre opções e compatibilidade. Quando um projeto já existe, a descrição automatizada gera metadados e caminhos de artefatos (como APKs) em JSON. Esses dados facilitam que scripts localizem saídas de build sem heurísticas frágeis. O diretório analisado pode ser passado explicitamente ou assumido como o atual. Essa etapa economiza tempo de investigação manual e padroniza a descoberta de resultados.
android create list
android describe --project_dir=/caminho/para/projeto
Documentação e Base de conhecimento no terminal
A integração com a Base de conhecimento permite pesquisar e obter conteúdo técnico atualizado diretamente no terminal. A busca retorna resultados com identificadores especiais, que servem para trazer instruções detalhadas ao contexto da execução. Esse fluxo elimina o vai e vem entre navegador e console, aproximando conteúdo e ação. As instruções são desenhadas para serem imediatamente aplicáveis por agentes e pessoas. Dessa forma, conceitos e comandos tornam-se consumíveis sem esforço adicional de interpretação.
android docs search 'How do I improve my app performance?'
android docs fetch kb://android/topic/performance/overview
Dispositivos virtuais: criar, listar, iniciar e parar
O gerenciamento de emuladores ocorre por comandos que criam, listam, iniciam e param dispositivos virtuais. Perfis pré-definidos simplificam a escolha de configurações de hardware e tela. A listagem de perfis guia a decisão antes da criação efetiva. Uma vez criado, o dispositivo aparece na listagem de disponíveis e pode ser iniciado pelo nome. Ao finalizar testes, a interrupção libera recursos e encerra processos associados.
android emulator create --list-profiles
android emulator create --profile=medium_phone
android emulator list
android emulator start medium_phone
android emulator stop emulator-5554
Informações do ambiente e inicialização para agentes
O comando de informações mostra o caminho do SDK padrão em uso, útil para auditoria e depuração de ambiente. Já a inicialização para agentes instala a habilidade central que ensina a operar a CLI. Esse preparo reduz a fricção de agentes que precisam entender padrões e estruturas do ecossistema Android. O processo acontece uma vez por ambiente de trabalho ou sempre que um agente novo for integrado. Com isso, fluxos assistidos tornam-se mais assertivos e consistentes.
android info
android init
Inspeção de layout e automação de interface
A coleta da árvore de layout do app em execução gera uma visão precisa da interface para análise e automação. O formato JSON pode ser impresso diretamente no terminal ou salvo em arquivo, com opção de formatação legível. Há ainda um modo de diff que retorna somente os elementos alterados desde a última captura interna. Isso permite inspeções rápidas em cenários de testes e regressões. A abordagem reduz a dependência de inspeções manuais e fornece dados comparáveis entre execuções.
android layout --output=./hierarchy.json
A captura de tela retorna a imagem do dispositivo, e a anotação desenha caixas sobre elementos detectados. Essa anotação permite resolver rótulos para coordenadas reais de toque, útil em automações que simulam cliques. O fluxo associa um número visual ao elemento e substitui o marcador por coordenadas na string de saída. Dessa forma, deixam de ser necessárias medições manuais de posição em pixels. A precisão aumenta e os scripts tornam-se mais robustos.
android screen capture --output=ui.png
android screen capture --output=ui.png --annotate
android screen resolve --screenshot=ui.png --string="input tap #5"
Habilidades do Android: instalar, encontrar, listar e remover
As habilidades são conjuntos de instruções modulares, em linguagem clara, que ensinam padrões recomendados a agentes. Essas instruções reduzem o risco de uso de bibliotecas ou práticas obsoletas. A instalação pode ocorrer para todos os agentes detectados ou para uma lista específica, e há a opção de instalar todas as habilidades disponíveis de uma vez. A busca de habilidades por descrição ajuda a localizar rapidamente o que resolverá um determinado problema. A listagem exibe as disponíveis e detalhes quando solicitados, enquanto a remoção limpa o que não é mais necessário.
android skills add --agent='gemini' edge-to-edge
android skills add --all
android skills find 'performance'
android skills list --long
android skills remove --agent='gemini' --skill=edge-to-edge
Gerenciamento do SDK: instalar, listar, remover e atualizar
O gerenciamento do SDK instala apenas o que o projeto de fato precisa, mantendo o ambiente leve. É possível escolher canais Beta ou Canary quando se deseja testar novidades, e também forçar downgrade quando a compatibilidade exige. A listagem aceita filtro por padrão e permite exibir todas as versões disponíveis. A remoção retira pacotes não utilizados, abrindo espaço e simplificando atualizações futuras. A atualização busca a versão mais recente por canal, com a possibilidade de apontar um pacote específico.
android sdk install platforms/android-34 build-tools/34.0.0
android sdk install platforms/android-34@2
android sdk install --canary system-images/android-35/google_apis/x86_6
android sdk install --force platforms/android-33@1
android sdk list --all --all-versions
android sdk remove build-tools/36.1.0
android sdk update
android sdk update build-tools/34.0.0
android sdk update --canary platforms/android-35
Implantação e execução de apps
A execução instala APKs no dispositivo conectado ou em emulador sem executar build, o que favorece ciclos rápidos de teste. É possível iniciar uma atividade específica, ativar depuração e escolher o dispositivo por número de série quando há vários conectados. Para componentes que não são atividades, há suporte a tipos como WATCH_FACE, TILE e COMPLICATION. O caminho dos APKs pode ser múltiplo e separado por vírgulas, cobrindo cenários com APKs divididos. Essa abordagem acelera a validação de artefatos já compilados por pipelines de CI ou por builds locais.
android run --apks=app/build/outputs/apk/debug/app-debug.apk
android run --apks=base.apk,density-hdpi.apk,lang-en.apk
android run --apks=app-debug.apk --type=SERVICE --activity=.sync.DataSyncService
android run --apks=app-debug.apk --device=emulator-5554
Atualização da ferramenta e consulta de versão
A atualização regular da CLI garante acesso às capacidades mais recentes sem reinstalação completa. Esse fluxo reduz incompatibilidades com novos modelos de projeto e com evoluções do SDK. A consulta de versão mostra o estado atual instalado, útil para suporte interno e auditorias de infraestrutura. Em ambientes com múltiplas máquinas, a padronização de versão minimiza surpresas entre estágios de desenvolvimento. Com isso, a manutenção fica previsível e centralizada.
android update
android -V
Automação e CI com a Android CLI
Fluxos de CI e scripts locais ganham estabilidade ao consolidar comandos determinísticos em um único arquivo. A instalação de pacotes do SDK, a criação de emulador e a implantação de APKs podem ser orquestradas com verificações e timeouts. Logs detalhados comparam estados, auxiliando diagnósticos sem intervenção manual. Abaixo, um exemplo de script de automação demonstra um pipeline mínimo e robusto. O objetivo é padronizar etapas e reduzir variações entre ambientes.
#!/usr/bin/env bash
set -euo pipefail
# Configurações
SDK_CAMINHO_PADRAO="${HOME}/Android/Sdk"
PERFIL_EMULADOR="medium_phone"
SERIAL_ESPERADO="emulator-5554"
APK_DEBUG="app/build/outputs/apk/debug/app-debug.apk"
TIMEOUT_BOOT=120 # segundos
# Função utilitária de log
log() { echo "[INFO] $*" ; }
# Verifica se a CLI está disponível
if ! command -v android >/dev/null 2>&1; then
echo "[ERRO] CLI do Android não encontrada no PATH." >&2
exit 1
fi
# Atualiza a CLI para garantir recursos recentes
log "Atualizando CLI do Android..."
android update
# Mostra SDK padrão e lista componentes disponíveis (para depuração)
log "SDK padrão:"
android info
# Instala componentes essenciais do SDK
log "Instalando plataformas e ferramentas do SDK..."
android sdk install platforms/android-34 build-tools/34.0.0
# Cria emulador se necessário
log "Criando emulador (idempotente, ignora se já existir)..."
if ! android emulator list | grep -q "^${PERFIL_EMULADOR}$"; then
android emulator create --profile="${PERFIL_EMULADOR}"
fi
# Inicia o emulador
log "Iniciando emulador..."
android emulator start "${PERFIL_EMULADOR}" || {
echo "[ERRO] Falha ao iniciar o emulador." >&2
exit 1
}
# Aguarda boot do emulador via ADB
log "Aguardando boot completo (${TIMEOUT_BOOT}s)..."
SECONDS=0
until adb -s "${SERIAL_ESPERADO}" shell getprop sys.boot_completed 2>/dev/null | grep -q "1"; do
if (( SECONDS > TIMEOUT_BOOT )); then
echo "[ERRO] Timeout aguardando boot do emulador." >&2
exit 1
fi
sleep 3
done
log "Emulador pronto."
# Implanta APK já construído (build externo ao script)
if [[ -f "${APK_DEBUG}" ]]; then
log "Instalando APK no emulador..."
android run --apks="${APK_DEBUG}" --device="${SERIAL_ESPERADO}" --debug
else
echo "[AVISO] APK não encontrado em ${APK_DEBUG}. Pule a instalação ou gere o build antes." >&2
fi
# Captura layout e screenshot para auditoria
log "Coletando layout e screenshot..."
android layout --output="./hierarchy.json" || true
android screen capture --output="./tela.png" || true
log "Pipeline de automação concluído com sucesso."Boas práticas e resolução de problemas
Ambientes variam, portanto a capacidade de especificar o SDK por caminho ajuda a isolar cenários complexos. Em logs de CI, o uso de --verbose e --dry-run na criação de projetos facilita auditoria sem efeitos colaterais. Em casos com múltiplos dispositivos conectados, a seleção por número de série evita ambiguidades de destino. Quando pacotes do SDK entram em conflito, a flag --force resolve compatibilidades com versões anteriores. Em sistemas Windows, a limitação conhecida do emulador deve ser considerada no planejamento do pipeline.
Para layouts e inspeções de UI, a estratégia de capturar e comparar deltas com --diff acelera validações regressivas. O recurso de anotação de captura de tela mais a resolução por rótulo reduzem o atrito de scripts baseados em coordenadas. Na gestão de habilidades, instalar somente o necessário mantém os agentes focados e o ambiente mais limpo. Ao consultar a Base de conhecimento, o retorno contextual encurta o caminho entre teoria e prática. No conjunto, essas práticas reforçam previsibilidade e qualidade contínua.
Encerramento: um fluxo enxuto, padronizado e preparado para agentes
A CLI do Android concentra etapas críticas de desenvolvimento em comandos claros, conferindo velocidade, reprodutibilidade e estabilidade. A união com habilidades oficiais e a Base de conhecimento oferece instruções precisas e atualizadas, fortalecendo decisões técnicas. Projetos nascem de modelos consistentes, dispositivos virtuais são criados e controlados sem janelas extras, e a implantação de APKs fica direta. Em ambientes colaborativos e de CI, o ganho é ainda maior graças à padronização e à facilidade de automação. O resultado prático é um ciclo de desenvolvimento mais curto, com menos erros e mais foco no que importa: a qualidade do app.