> ## Documentation Index > Fetch the complete documentation index at: https://docs.devinenterprise.com/llms.txt > Use this file to discover all available pages before exploring further. # Suporte ao emulador Android > Faça build e execute aplicativos Android em um emulador completo em execução na própria máquina do Devin O Devin pode fazer build e executar aplicativos Android diretamente na própria máquina — o que dá a ele o equivalente, no Android, ao [Computer Use](/pt-BR/work-with-devin/computer-use) e à interação com o navegador. O Devin pode abrir o app, inspecionar o comportamento, reproduzir problemas e verificar alterações no ambiente em que o aplicativo realmente é executado. Combinado com [gravações de vídeo](/pt-BR/work-with-devin/testing-and-recordings), o Devin pode enviar uma gravação como prova.
## O que você pode fazer
Com o suporte ao emulador Android ativado, Devin pode cobrir todo o ciclo de desenvolvimento mobile: Devin faz a build e executa seu app no emulador, depois percorre os fluxos críticos após cada PR. Você recebe uma gravação em vídeo que comprova que a funcionalidade funciona — assista e faça o merge. Teste fluxos completos do usuário — login, navegação, envio de formulário, checkout — em uma stack Android real, não em um mock. Devin segue o fluxo etapa por etapa e sinaliza qualquer falha. Verifique layouts, temas e responsividade em diferentes tamanhos de tela e níveis de API. Devin tira capturas de tela em pontos-chave e sinaliza problemas visuais, como elementos sobrepostos ou texto cortado. Reproduza problemas no emulador, capture a saída do `logcat`, inspecione o comportamento, identifique a causa raiz e envie uma correção — tudo em uma única sessão. Está desenvolvendo com React Native, Flutter ou Kotlin Multiplatform? Devin pode testar a parte Android junto com suas builds web ou desktop na mesma sessão. Execute suítes de teste do Espresso ou UI Automator no emulador e receba os resultados, sem precisar de uma device farm de CI separada ou de dispositivos físicos. Verifique seu app em diferentes níveis de API ou perfis de dispositivo configurando vários AVDs. Útil para detectar problemas de compatibilidade antes de chegarem aos usuários.
## Como funciona
O suporte ao emulador Android é baseado no mesmo sistema de [configuração declarativa](/pt-BR/onboard-devin/environment/blueprints) usado no restante do ambiente do Devin. Você adiciona o Android SDK e o emulador ao seu blueprint, e o snapshot do Devin cria uma VM com tudo pré-instalado. Cada sessão é iniciada a partir desse snapshot, com o emulador pronto para uso. Durante uma sessão, o Devin interage com o emulador de duas formas: | Método | O que faz | Quando usar | | ---------------------------- | ------------------------------------------------------------------ | --------------------------------------------------------------------- | | **`adb`** (linha de comando) | Instala APKs, executa testes, captura logs e tira capturas de tela | builds automatizadas, testes instrumentados, depuração com logcat | | **Computer Use** (desktop) | Toca, desliza, digita e navega visualmente pela tela do emulador | testes de UI de ponta a ponta, verificação visual, gravações de vídeo | A janela do emulador é executada no desktop do Devin, então você pode acompanhar o Devin interagindo com seu app em tempo real pela aba **Desktop** no webapp.
## Configurando o emulador
A maneira mais fácil de começar. O Devin analisa seu projeto Android, instala os componentes corretos do SDK e configura o emulador para você. Abra uma nova sessão e peça ao Devin para configurar a emulação do Android. Por exemplo: *"Configure um emulador Android para este repositório."* O Devin propõe um blueprint com o Android SDK, as ferramentas de build e a configuração do emulador. Revise os cards de sugestão na sua linha do tempo e clique em **Approve**. Quando o build for concluído, inicie uma nova sessão. Peça ao Devin para fazer o build e executar seu app no emulador para confirmar que tudo está funcionando. Se você souber exatamente de quais componentes do SDK e de qual configuração de emulador precisa, poderá escrever o blueprint por conta própria. Vá para **Configurações > Ambiente > Blueprints** e selecione seu repositório Android. Adicione o Android SDK, as ferramentas de plataforma, o emulador e uma imagem do sistema a `initialize`. Adicione a instalação das dependências a `maintenance`. Veja os [exemplos de blueprints](#blueprint-examples) abaixo para usar templates prontos para copiar e colar. Clique em **Save**. Um build é iniciado automaticamente (normalmente leva de 5 a 15 minutos no Android devido aos downloads do SDK). Acompanhe o progresso em **Configurações > Ambiente > Snapshots**. Quando o build mostrar **Success**, inicie uma nova sessão. Peça ao Devin para iniciar o emulador e fazer o build do seu app para verificar.
### O que é instalado
Um blueprint típico para suporte ao emulador Android instala: | Componente | Finalidade | | ---------------------------------------------- | ---------------------------------------------------- | | Ferramentas de linha de comando do Android SDK | Gerenciamento básico do SDK (`sdkmanager`) | | Ferramentas de plataforma | `adb`, `fastboot` para comunicação com o dispositivo | | Ferramentas de build | `aapt2`, `d8`, `zipalign` para gerar APKs | | Plataforma Android (por exemplo, API 34) | Nível de API de destino do seu app | | Emulador + imagem do sistema | O próprio dispositivo virtual | Use uma imagem de sistema `x86_64` para obter o melhor desempenho no ambiente do Devin. Imagens ARM funcionam, mas são significativamente mais lentas na emulação.
## Como usar o Emulador
### Testes sob demanda
Peça ao Devin para fazer o build e executar seu app a qualquer momento durante uma sessão — não é necessária nenhuma sintaxe especial, apenas linguagem natural: * *"Faça o build e execute o app no emulador Android"* * *"Teste o fluxo de login no emulador e me envie uma gravação"* * *"Abra a tela de Configurações no emulador e verifique se o novo controle de alternância aparece"* * *"Execute os testes do Espresso no emulador e me mostre os resultados"* O Devin iniciará o emulador (se ele ainda não estiver em execução), fará o build e executará seu app, além de interagir com ele — usando `adb` para ações programáticas e Computer Use para interações visuais.
### Integração com Testes e Gravações
O suporte ao emulador Android se integra diretamente ao fluxo de trabalho de [Testes e Gravações](/pt-BR/work-with-devin/testing-and-recordings) do Devin. Depois de criar uma PR: 1. O Devin oferece a opção de **testar o app** — clique no botão ou peça diretamente 2. O Devin faz a build e executa o app no emulador, além de executar um plano de teste focado 3. A tela do emulador é capturada em uma **gravação de vídeo** com anotações 4. A gravação é enviada para você, para que possa assistir ao teste e fazer o merge com confiança Isso funciona da mesma forma que os testes de apps web — a única diferença é que o Devin interage com a janela do emulador em vez do Chrome. Crie uma [Skill](/pt-BR/product-guides/skills) que diga ao Devin exatamente como fazer a build, iniciar e testar seu app Android. Isso economiza tempo de configuração em sessões repetidas e garante testes consistentes. Por exemplo, inclua o comando de build do Gradle, qual activity iniciar e quais fluxos verificar.
### Sugestões de skill
Depois de testar seu app Android, Devin registra o que aprendeu — como iniciar o emulador, quais tarefas do Gradle executar, como navegar até a funcionalidade em teste — e propõe criar ou atualizar uma [Skill](/pt-BR/product-guides/skills) via PR. Você pode mesclar a PR como está ou ajustá-la para refinar as instruções. Com o tempo, isso significa que Devin fica cada vez melhor em testar seu projeto Android. Os aprendizados de cada sessão se somam aos da anterior — então, na segunda vez que Devin testar seu app, ele já saberá como fazer o build, qual activity iniciar e quais fluxos importam mais. Você também pode pedir ao Devin para fazer isso a qualquer momento (por exemplo, *"crie uma skill sobre como fazer o build e testar este app Android"*). Consulte o [guia de Skills](/pt-BR/product-guides/skills) para mais detalhes.
### Interagindo pelo desktop
O emulador Android é executado em uma janela no desktop Linux do Devin. Isso significa: * **O Devin pode interagir com ele via Computer Use** — tocando em botões, deslizando, digitando texto e navegando entre telas * **Você pode acompanhar ao vivo** pela aba **Desktop** no Devin webapp * **As gravações capturam a tela do emulador** junto com qualquer outra coisa visível no desktop do Devin Para mais detalhes sobre como funciona a interação pelo desktop, consulte [Computer Use](/pt-BR/work-with-devin/computer-use).
### Como usar `adb`
Devin também pode interagir com o emulador de forma programática via `adb`, o que é útil para: * **Instalar APKs** — `adb install app-debug.apk` * **Executar testes instrumentados** — `adb shell am instrument -w com.example.test/androidx.test.runner.AndroidJUnitRunner` * **Capturar logs** — `adb logcat` para depurar falhas ou comportamentos inesperados * **Tirar capturas de tela** — `adb exec-out screencap -p > screenshot.png` * **Simular entrada do usuário** — `adb shell input tap 500 800` para interações automatizadas por script Devin escolhe entre `adb` e Computer Use conforme a tarefa — `adb` para velocidade e automação, e Computer Use para verificação visual e fluxos complexos na UI.
## Exemplos de blueprints
Blueprints para copiar e colar em configurações comuns de Android. Cada template é independente — cole-o no editor de blueprint e salve. ```yaml theme={null} initialize: - name: "Install Android SDK" run: | export ANDROID_HOME="$HOME/android-sdk" mkdir -p "$ANDROID_HOME/cmdline-tools" cd "$ANDROID_HOME/cmdline-tools" curl -fsSL https://dl.google.com/android/repository/commandlinetools-linux-11076708_latest.zip -o tools.zip unzip -q tools.zip -d latest-tmp mv latest-tmp/cmdline-tools "$ANDROID_HOME/cmdline-tools/latest" rm -rf tools.zip latest-tmp echo "export ANDROID_HOME=$ANDROID_HOME" >> ~/.bashrc echo 'export PATH=$ANDROID_HOME/cmdline-tools/latest/bin:$ANDROID_HOME/platform-tools:$ANDROID_HOME/emulator:$PATH' >> ~/.bashrc export PATH="$ANDROID_HOME/cmdline-tools/latest/bin:$ANDROID_HOME/platform-tools:$ANDROID_HOME/emulator:$PATH" yes | sdkmanager --licenses > /dev/null 2>&1 sdkmanager "platform-tools" "build-tools;34.0.0" "platforms;android-34" "emulator" "system-images;android-34;google_apis;x86_64" echo "no" | avdmanager create avd -n devin -k "system-images;android-34;google_apis;x86_64" --device "pixel_6" maintenance: | ./gradlew assembleDebug knowledge: - name: build contents: ./gradlew assembleDebug - name: test contents: ./gradlew test - name: lint contents: ./gradlew lint - name: emulator contents: | Start the emulator: emulator -avd devin -no-window -no-audio -gpu swiftshader_indirect & Wait for boot: adb wait-for-device && adb shell getprop sys.boot_completed Install APK: adb install app/build/outputs/apk/debug/app-debug.apk ``` ```yaml theme={null} initialize: - name: "Install Node.js" run: | nvm install 20 nvm use 20 - name: "Install Android SDK" run: | export ANDROID_HOME="$HOME/android-sdk" mkdir -p "$ANDROID_HOME/cmdline-tools" cd "$ANDROID_HOME/cmdline-tools" curl -fsSL https://dl.google.com/android/repository/commandlinetools-linux-11076708_latest.zip -o tools.zip unzip -q tools.zip -d latest-tmp mv latest-tmp/cmdline-tools "$ANDROID_HOME/cmdline-tools/latest" rm -rf tools.zip latest-tmp echo "export ANDROID_HOME=$ANDROID_HOME" >> ~/.bashrc echo 'export PATH=$ANDROID_HOME/cmdline-tools/latest/bin:$ANDROID_HOME/platform-tools:$ANDROID_HOME/emulator:$PATH' >> ~/.bashrc export PATH="$ANDROID_HOME/cmdline-tools/latest/bin:$ANDROID_HOME/platform-tools:$ANDROID_HOME/emulator:$PATH" yes | sdkmanager --licenses > /dev/null 2>&1 sdkmanager "platform-tools" "build-tools;34.0.0" "platforms;android-34" "emulator" "system-images;android-34;google_apis;x86_64" echo "no" | avdmanager create avd -n devin -k "system-images;android-34;google_apis;x86_64" --device "pixel_6" maintenance: | npm install cd android && ./gradlew assembleDebug knowledge: - name: build contents: cd android && ./gradlew assembleDebug - name: test contents: npm test - name: lint contents: npm run lint - name: emulator contents: | Start the emulator: emulator -avd devin -no-window -no-audio -gpu swiftshader_indirect & Wait for boot: adb wait-for-device && adb shell getprop sys.boot_completed Run on device: npx react-native run-android ``` ```yaml theme={null} initialize: - name: "Install Flutter" run: | cd "$HOME" git clone https://github.com/flutter/flutter.git -b stable --depth 1 echo 'export PATH=$HOME/flutter/bin:$PATH' >> ~/.bashrc export PATH="$HOME/flutter/bin:$PATH" flutter precache --android yes | flutter doctor --android-licenses > /dev/null 2>&1 - name: "Install Android SDK" run: | export ANDROID_HOME="$HOME/android-sdk" mkdir -p "$ANDROID_HOME/cmdline-tools" cd "$ANDROID_HOME/cmdline-tools" curl -fsSL https://dl.google.com/android/repository/commandlinetools-linux-11076708_latest.zip -o tools.zip unzip -q tools.zip -d latest-tmp mv latest-tmp/cmdline-tools "$ANDROID_HOME/cmdline-tools/latest" rm -rf tools.zip latest-tmp echo "export ANDROID_HOME=$ANDROID_HOME" >> ~/.bashrc echo 'export PATH=$ANDROID_HOME/cmdline-tools/latest/bin:$ANDROID_HOME/platform-tools:$ANDROID_HOME/emulator:$PATH' >> ~/.bashrc export PATH="$ANDROID_HOME/cmdline-tools/latest/bin:$ANDROID_HOME/platform-tools:$ANDROID_HOME/emulator:$PATH" yes | sdkmanager --licenses > /dev/null 2>&1 sdkmanager "platform-tools" "build-tools;34.0.0" "platforms;android-34" "emulator" "system-images;android-34;google_apis;x86_64" echo "no" | avdmanager create avd -n devin -k "system-images;android-34;google_apis;x86_64" --device "pixel_6" maintenance: | flutter pub get knowledge: - name: build contents: flutter build apk --debug - name: test contents: flutter test - name: lint contents: flutter analyze - name: emulator contents: | Start the emulator: emulator -avd devin -no-window -no-audio -gpu swiftshader_indirect & Wait for boot: adb wait-for-device && adb shell getprop sys.boot_completed Run on device: flutter run -d emulator-5554 ``` ```yaml theme={null} initialize: - name: "Install Android SDK" run: | export ANDROID_HOME="$HOME/android-sdk" mkdir -p "$ANDROID_HOME/cmdline-tools" cd "$ANDROID_HOME/cmdline-tools" curl -fsSL https://dl.google.com/android/repository/commandlinetools-linux-11076708_latest.zip -o tools.zip unzip -q tools.zip -d latest-tmp mv latest-tmp/cmdline-tools "$ANDROID_HOME/cmdline-tools/latest" rm -rf tools.zip latest-tmp echo "export ANDROID_HOME=$ANDROID_HOME" >> ~/.bashrc echo 'export PATH=$ANDROID_HOME/cmdline-tools/latest/bin:$ANDROID_HOME/platform-tools:$ANDROID_HOME/emulator:$PATH' >> ~/.bashrc export PATH="$ANDROID_HOME/cmdline-tools/latest/bin:$ANDROID_HOME/platform-tools:$ANDROID_HOME/emulator:$PATH" yes | sdkmanager --licenses > /dev/null 2>&1 sdkmanager "platform-tools" "build-tools;34.0.0" "platforms;android-34" "emulator" "system-images;android-34;google_apis;x86_64" echo "no" | avdmanager create avd -n devin -k "system-images;android-34;google_apis;x86_64" --device "pixel_6" maintenance: | ./gradlew :androidApp:assembleDebug knowledge: - name: build contents: ./gradlew :androidApp:assembleDebug - name: test contents: ./gradlew allTests - name: lint contents: ./gradlew detekt - name: emulator contents: | Start the emulator: emulator -avd devin -no-window -no-audio -gpu swiftshader_indirect & Wait for boot: adb wait-for-device && adb shell getprop sys.boot_completed Install APK: adb install androidApp/build/outputs/apk/debug/androidApp-debug.apk ```
## Solução de problemas
### O emulador não inicia
**Causas comuns:** KVM indisponível na VM, memória insuficiente ou falta de uma imagem do sistema. **Correção:** Devin pode tentar configurar o KVM automaticamente quando detecta que o emulador precisa de aceleração por hardware — na maioria dos casos, isso resolve o problema sem intervenção manual. Se o KVM ainda não estiver disponível após a tentativa do Devin, o emulador pode usar o modo de renderização por software — adicione `-no-accel` ao comando de inicialização do emulador, embora o desempenho seja reduzido. Verifique também se o seu blueprint instala o emulador e uma imagem de sistema `x86_64` compatível.
### Falha na build com erros de SDK
**Causas comuns:** componentes do SDK ausentes, caminho `ANDROID_HOME` incorreto ou o Gradle não consegue encontrar a versão correta das ferramentas de build. **Correção:** Verifique se `ANDROID_HOME` está configurado corretamente no blueprint e se o `sdkmanager` instala a versão da plataforma e a versão das ferramentas de build exigidas pelo seu projeto. Confira no `build.gradle` do projeto os valores de `compileSdk`, `targetSdk` e `buildToolsVersion` e garanta que correspondam aos definidos no blueprint.
### O emulador está lento
O emulador do Android é executado dentro da VM do Devin, então o desempenho depende da imagem do sistema e do modo de renderização. **Dicas:** * Use imagens de sistema `x86_64` (não ARM) para emulação com aceleração por hardware * Use `-gpu swiftshader_indirect` para renderização por software que não exige pass-through de GPU * Use `-no-window -no-audio` quando o Devin não precisar da exibição visual (por exemplo, ao executar testes instrumentados via `adb`) * Considere usar um perfil de dispositivo com resolução mais baixa se a fidelidade visual não for crítica
### Devin não consegue interagir com a tela do emulador
**Causas comuns:** o modo Desktop não está ativado, a janela do emulador não está visível ou o emulador está sendo executado em modo headless. **Correção:** Certifique-se de que o [modo Desktop](/pt-BR/work-with-devin/computer-use#how-to-enable-it) esteja ativado nas configurações da sua organização. Se você precisar que o Devin interaja visualmente com o emulador, inicie-o *sem* a flag `-no-window`, para que a GUI do emulador apareça na área de trabalho do Devin. Verifique se o emulador foi totalmente inicializado (`adb shell getprop sys.boot_completed` deve retornar `1`) antes de pedir ao Devin para interagir com ele.