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 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, 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:

Build e teste de fumaça de PRs

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.

Testes mobile de ponta a ponta

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.

Verificação de UI

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.

Depuração de crashes e ANRs

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.

Validação multiplataforma

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.

Execução de testes instrumentados

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.

Testes com várias configurações

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 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

Deixe o Devin fazer isso (recomendado)

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ê.

1. Inicie uma sessão do Devin

   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.”

2. Revise e aprove

   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.

3. Verifique

   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.

Configuração manual do blueprint

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.

1. Acesse a configuração do ambiente

   Vá para Configurações > Ambiente > Blueprints e selecione seu repositório Android.

2. Escreva seu blueprint

   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 abaixo para usar templates prontos para copiar e colar.

3. Salve e faça o build

   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.

4. Verifique

   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 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 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 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 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.

​

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.

Android nativo (Kotlin/Java + Gradle)

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

React Native

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

Flutter

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

Kotlin Multiplatform

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 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.