Saltar al contenido principal

Documentation Index

Fetch the complete documentation index at: https://docs.devin.ai/llms.txt

Use this file to discover all available pages before exploring further.

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.
La compatibilidad con emulador de Android está disponible actualmente de forma limitada. Si te interesa usarlo con Devin, contáctanos para obtener más información y solicitar acceso.

​
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étodoQué haceCuándo usarlo
adb (línea de comandos)Instalar APKs, ejecutar pruebas, capturar logs, tomar capturas de pantallaCompilaciones automatizadas, pruebas instrumentadas, depuración con logcat
Computer Use (escritorio)Tocar, deslizar, escribir y navegar visualmente por la pantalla del emuladorPruebas 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

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

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

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

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.

​
Qué se instala

Un blueprint típico de compatibilidad con el emulador de Android instala:
ComponenteObjetivo
Herramientas de línea de comandos del SDK de AndroidGestión básica del SDK (sdkmanager)
Herramientas de plataformaadb, fastboot para la comunicación con dispositivos
Herramientas de compilaciónaapt2, d8, zipalign para compilar APKs
Plataforma de Android (p. ej., API 34)Nivel de API de destino para tu app
Emulador + imagen del sistemaEl 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:
  1. Devin te ofrece Probar la app — haz clic en el botón o pídeselo directamente
  2. Devin compila y ejecuta la app en el emulador, y lleva a cabo un plan de pruebas específico
  3. La pantalla del emulador se captura en una grabación de vídeo con anotaciones
  4. 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. 
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

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

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

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.