Compatibilidad con el emulador de Android

Devin puede compilar y ejecutar aplicaciones de Android directamente en su propia máquina, lo que le da el equivalente en Android de Computer Use y de la interacción con el navegador. Devin puede abrir la app, inspeccionar su comportamiento, reproducir incidencias y verificar cambios en el entorno en el que la aplicación realmente se ejecuta. En combinación con grabaciones de vídeo, Devin puede enviarte una grabación como prueba.

Lo que puedes hacer

Con la compatibilidad con el emulador de Android habilitada, Devin puede encargarse de todo el ciclo de desarrollo móvil:

Compilar y hacer pruebas rápidas

Devin compila y ejecuta tu app en el emulador, y luego recorre los flujos críticos después de cada cambio. Obtienes una grabación de video que demuestra que la funcionalidad funciona: mírala y fusiona.

Pruebas móviles de extremo a extremo

Prueba flujos de usuario completos — inicio de sesión, navegación, envío de formularios, pago — sobre una pila real de Android, no una simulación. Devin sigue el flujo paso a paso y marca cualquier fallo.

Verificación de la UI

Verifica diseños, temas y capacidad de respuesta en distintos tamaños de pantalla y niveles de API. Devin toma capturas de pantalla en puntos clave y marca problemas visuales, como elementos superpuestos o texto recortado.

Depurar cierres inesperados y ANR

Reproduce problemas en el emulador, captura la salida de logcat, inspecciona el comportamiento, rastrea la causa raíz y sube una corrección, todo en una sola sesión.

Validación multiplataforma

¿Compilas con React Native, Flutter o Kotlin Multiplatform? Devin puede probar la parte de Android junto con tus compilaciones web o de escritorio en la misma sesión.

Ejecución de pruebas instrumentadas

Ejecuta conjuntos de prueba de Espresso o UI Automator en el emulador y recibe los resultados, sin necesidad de una granja de dispositivos de CI independiente ni de dispositivos físicos.

Pruebas con múltiples configuraciones

Verifica tu app en distintos niveles de API o perfiles de dispositivo configurando múltiples AVD. Es útil para detectar problemas de compatibilidad antes de que lleguen a los usuarios.

Cómo funciona

La compatibilidad con el emulador de Android se basa en el mismo sistema de configuración declarativa que el resto del Environment de Devin. Agregas el SDK de Android y el emulador a tu blueprint, y la instantánea de Devin crea una VM con todo preinstalado. Cada sesión se inicia desde esa instantánea con el emulador listo para usarse. Durante una sesión, Devin interactúa con el emulador de dos maneras:

Método	Qué hace	Cuándo usarlo
`adb` (línea de comandos)	Instalar APKs, ejecutar pruebas, capturar logs, tomar capturas de pantalla	Compilaciones automatizadas, pruebas instrumentadas, depuración con logcat
Computer Use (escritorio)	Tocar, deslizar, escribir y navegar visualmente por la pantalla del emulador	Pruebas de UI de extremo a extremo, verificación visual, grabaciones de video

La ventana del emulador se ejecuta en el escritorio de Devin, por lo que puedes ver a Devin interactuar con tu app en tiempo real desde la pestaña Desktop de la webapp.

Configuración del emulador

Deja que Devin lo haga (recomendado)
Configuración manual del blueprint

La forma más sencilla de empezar. Devin analiza tu proyecto de Android, instala los componentes adecuados del SDK y configura el emulador por ti.

Inicia una sesión de Devin

Abre una sesión nueva y pídele a Devin que configure la emulación de Android. Por ejemplo: “Configura un emulador de Android para este repo.”

Revisa y aprueba

Devin propone un blueprint con el SDK de Android, las herramientas de compilación y la configuración del emulador. Revisa las tarjetas de sugerencias en tu timeline y haz clic en Approve.

Verifica

Cuando termine la compilación, inicia una sesión nueva. Pídele a Devin que compile y ejecute tu app en el emulador para confirmar que todo funciona.

Si sabes exactamente qué componentes del SDK y qué configuración del emulador necesitas, puedes escribir el blueprint tú mismo.

Ve a la configuración del entorno

Ve a Settings > Environment > Blueprints y selecciona tu repositorio de Android.

Escribe tu blueprint

Agrega el SDK de Android, las herramientas de plataforma, el emulador y una imagen del sistema a initialize. Agrega la instalación de dependencias a maintenance. Consulta los ejemplos de blueprint a continuación para ver plantillas listas para copiar y pegar.

Guarda y compila

Haz clic en Save. Se iniciará una compilación automáticamente (normalmente tarda entre 5 y 15 minutos en Android debido a las descargas del SDK). Supervisa el progreso desde Settings > Environment > Snapshots.

Verifica

Cuando la compilación muestre Success, inicia una sesión nueva. Pídele a Devin que inicie el emulador y compile tu app para comprobarlo.

Qué se instala

Un blueprint típico de compatibilidad con el emulador de Android instala:

Componente	Objetivo
Herramientas de línea de comandos del SDK de Android	Gestión básica del SDK (`sdkmanager`)
Herramientas de plataforma	`adb`, `fastboot` para la comunicación con dispositivos
Herramientas de compilación	`aapt2`, `d8`, `zipalign` para compilar APKs
Plataforma de Android (p. ej., API 34)	Nivel de API de destino para tu app
Emulador + imagen del sistema	El propio dispositivo virtual

Usa una imagen del sistema x86_64 para obtener el mejor rendimiento en el Environment de Devin. Las imágenes ARM funcionan, pero son significativamente más lentas cuando se emulan.

Cómo usar el emulador

Pruebas bajo demanda

Pídele a Devin que compile y ejecute tu app en cualquier momento durante una sesión, sin necesidad de ninguna sintaxis especial: solo lenguaje natural.

“Compila y ejecuta la app en el emulador de Android”
“Prueba el flujo de inicio de sesión en el emulador y envíame una grabación”
“Abre la pantalla de Settings en el emulador y verifica que aparezca el nuevo interruptor”
“Ejecuta las pruebas de Espresso en el emulador y muéstrame los resultados”

Devin iniciará el emulador (si aún no está en ejecución), compilará y ejecutará tu app, e interactuará con ella, usando adb para acciones programáticas y Computer Use para interacciones visuales.

Integración con pruebas y grabaciones

La compatibilidad con el emulador de Android se integra directamente en el flujo de trabajo de Pruebas y grabaciones de Devin. Después de crear una pull request:

Devin te ofrece Probar la app — haz clic en el botón o pídeselo directamente
Devin compila y ejecuta la app en el emulador, y lleva a cabo un plan de pruebas específico
La pantalla del emulador se captura en una grabación de vídeo con anotaciones
La grabación se te envía para que puedas ver la prueba y fusionar los cambios con confianza

Esto funciona igual que las pruebas de apps web: la única diferencia es que Devin interactúa con la ventana del emulador en lugar de hacerlo con Chrome.

Crea una Skill que le indique a Devin exactamente cómo compilar, iniciar y probar tu app de Android. Esto ahorra tiempo de configuración en sesiones posteriores y garantiza pruebas consistentes. Por ejemplo, incluye el comando de compilación de Gradle, qué actividad iniciar y qué flujos verificar.

Sugerencias de skills

Después de probar tu app de Android, Devin anota lo que aprendió — cómo iniciar el emulador, qué tareas de Gradle ejecutar, cómo navegar hasta la función que se está probando — y propone crear o actualizar una Skill mediante una solicitud de extracción. Puedes fusionarla tal como está o ajustarla para perfeccionar las instrucciones. Con el tiempo, esto significa que Devin mejora para probar tu proyecto de Android. Los aprendizajes de cada sesión se suman a los de la anterior — así que, la segunda vez que Devin pruebe tu app, ya sabrá cómo compilarla, qué actividad iniciar y qué flujos son los más importantes. También puedes pedirle a Devin que haga esto en cualquier momento (p. ej., “crear una skill para compilar y probar esta app de Android”). Consulta la guía de Skills para obtener todos los detalles.

Interacción desde el escritorio

El emulador de Android se ejecuta como una ventana en el escritorio Linux de Devin. Esto significa:

Devin puede interactuar con él mediante Computer Use: tocar botones, deslizar, escribir texto y navegar entre pantallas
Puedes verlo en tiempo real desde la pestaña Desktop de la webapp de Devin
Las grabaciones capturan la pantalla del emulador junto con cualquier otro elemento visible en el escritorio de Devin

Para obtener más información sobre cómo funciona la interacción desde el escritorio, consulta Computer Use.

Cómo usar `adb`

Devin también puede interactuar con el emulador de forma programática mediante adb, lo que resulta útil para:

Instalar APKs — adb install app-debug.apk
Ejecutar pruebas instrumentadas — adb shell am instrument -w com.example.test/androidx.test.runner.AndroidJUnitRunner
Capturar logs — adb logcat para depurar fallos o comportamientos inesperados
Tomar capturas de pantalla — adb exec-out screencap -p > screenshot.png
Simular entradas del usuario — adb shell input tap 500 800 para interacciones automatizadas mediante scripts

Devin elige entre adb y Computer Use según la tarea: adb por su velocidad y capacidad de automatización, y Computer Use para la verificación visual y flujos complejos de la UI.

Ejemplos de blueprints

Blueprints listas para copiar y pegar para configuraciones comunes de Android. Cada plantilla es independiente: pégala en tu editor de blueprint y guárdala.

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

Solución de problemas

El emulador no arranca

Causas comunes: KVM no está disponible en la VM, no hay suficiente memoria o falta una imagen del sistema. Solución: Devin puede intentar configurar KVM automáticamente cuando detecta que el emulador necesita aceleración por hardware; en la mayoría de los casos, esto resuelve el problema sin intervención manual. Si KVM sigue sin estar disponible después de que Devin lo intente, el emulador puede recurrir al modo de renderizado por software; agrega -no-accel al comando de arranque del emulador, aunque el rendimiento será menor. Comprueba también que tu blueprint instale el emulador y una imagen del sistema x86_64 compatible.

La compilación falla con errores del SDK

Causas comunes: Faltan componentes del SDK, la ruta de ANDROID_HOME es incorrecta o Gradle no encuentra la versión adecuada de las herramientas de compilación. Solución: Verifica que ANDROID_HOME esté configurado correctamente en tu blueprint y que sdkmanager instale la versión de la plataforma y la versión de las herramientas de compilación que requiere tu proyecto. Revisa el archivo build.gradle de tu proyecto para verificar compileSdk, targetSdk y buildToolsVersion, y asegúrate de que coincidan en el blueprint.

El emulador es lento

El emulador de Android se ejecuta dentro de la VM de Devin, por lo que el rendimiento depende de la imagen del sistema y del modo de renderizado. Consejos:

Usa imágenes del sistema x86_64 (no ARM) para la emulación acelerada por hardware
Usa -gpu swiftshader_indirect para el renderizado por software que no requiere passthrough de la GPU
Usa -no-window -no-audio cuando Devin no necesite la pantalla (por ejemplo, al ejecutar pruebas instrumentadas mediante adb)
Considera usar un perfil de dispositivo de menor resolución si la fidelidad visual no es crítica

Devin no puede interactuar con la pantalla del emulador

Causas comunes: Desktop mode no está habilitado, la ventana del emulador no está visible o el emulador se está ejecutando en modo headless. Solución: Asegúrate de que Desktop mode esté habilitado en Settings de tu organización. Si necesitas que Devin interactúe visualmente con el emulador, inícialo sin la opción -no-window para que la interfaz gráfica del emulador aparezca en el escritorio de Devin. Comprueba que el emulador haya arrancado por completo (adb shell getprop sys.boot_completed debe devolver 1) antes de pedirle a Devin que interactúe con él.

Primeros pasos

Conceptos clave

Incorporación de Devin

Trabajar con Devin

Guías de producto

Integraciones

Admin

Notas de la versión

Compatibilidad con el emulador de Android

Lo que puedes hacer

Compilar y hacer pruebas rápidas

Pruebas móviles de extremo a extremo

Verificación de la UI

Depurar cierres inesperados y ANR

Validación multiplataforma

Ejecución de pruebas instrumentadas

Pruebas con múltiples configuraciones

Cómo funciona

Configuración del emulador

Qué se instala

Cómo usar el emulador

Pruebas bajo demanda

Integración con pruebas y grabaciones

Sugerencias de skills

Interacción desde el escritorio

Cómo usar `adb`

Ejemplos de blueprints

Solución de problemas

El emulador no arranca

La compilación falla con errores del SDK

El emulador es lento

Devin no puede interactuar con la pantalla del emulador

​Lo que puedes hacer

Compilar y hacer pruebas rápidas

Pruebas móviles de extremo a extremo

Verificación de la UI

Depurar cierres inesperados y ANR

Validación multiplataforma

Ejecución de pruebas instrumentadas

Pruebas con múltiples configuraciones

​Cómo funciona

​Configuración del emulador

​Qué se instala

​Cómo usar el emulador

​Pruebas bajo demanda

​Integración con pruebas y grabaciones

​Sugerencias de skills

​Interacción desde el escritorio

​Cómo usar adb

​Ejemplos de blueprints

​Solución de problemas

​El emulador no arranca

​La compilación falla con errores del SDK

​El emulador es lento

​Devin no puede interactuar con la pantalla del emulador

Lo que puedes hacer

Cómo funciona

Configuración del emulador

Qué se instala

Cómo usar el emulador

Pruebas bajo demanda

Integración con pruebas y grabaciones

Sugerencias de skills

Interacción desde el escritorio

Cómo usar `adb`

Ejemplos de blueprints

Solución de problemas

El emulador no arranca

La compilación falla con errores del SDK

El emulador es lento

Devin no puede interactuar con la pantalla del emulador