Vai al contenuto principale

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 può compilare ed eseguire applicazioni Android direttamente sulla propria macchina, dandogli l’equivalente Android di Computer Use e dell’interazione con il browser. Devin può aprire l’app, osservarne il comportamento, riprodurre i problemi e verificare le modifiche nell’ambiente in cui l’applicazione viene effettivamente eseguita. In combinazione con le registrazioni video, Devin può inviarti una registrazione come prova.
Il supporto per l’emulatore Android è attualmente disponibile solo in misura limitata. Se ti interessa usarlo con Devin, contattaci per saperne di più e ottenere l’accesso.

​
Cosa puoi fare

Con il supporto per l’emulatore Android abilitato, Devin può gestire l’intero ciclo di sviluppo mobile:

Build e smoke test delle PR

Devin compila ed esegue la tua app sull’emulatore, quindi percorre i flussi critici dopo ogni PR. Ricevi una registrazione video che dimostra che la funzionalità funziona: guardala e fai il merge.

Testing mobile end-to-end

Verifica flussi utente completi — accesso, navigazione, invio di moduli, checkout — su uno stack Android reale, non su un mock. Devin segue il flusso passaggio dopo passaggio e segnala tutto ciò che non funziona.

Verifica dell'UI

Verifica layout, temi e adattabilità su diverse dimensioni dello schermo e livelli API. Devin acquisisce screenshot nei punti chiave e segnala problemi visivi come elementi sovrapposti o testo tagliato.

Debug di crash e ANR

Riproduci i problemi sull’emulatore, acquisisci l’output di logcat, ispeziona il comportamento, risali alla causa principale e pubblica una correzione — tutto in un’unica sessione.

Validazione multipiattaforma

Stai sviluppando con React Native, Flutter o Kotlin Multiplatform? Devin può testare il lato Android insieme alle build web o desktop nella stessa sessione.

Esecuzione di test strumentati

Esegui suite di test Espresso o UI Automator sull’emulatore e ottieni i risultati, senza bisogno di una device farm CI dedicata o di dispositivi fisici.

Testing su più configurazioni

Verifica la tua app su diversi livelli API o profili di dispositivo configurando più AVD. Utile per intercettare problemi di compatibilità prima che arrivino agli utenti.

​
Come funziona

Il supporto per l’emulatore Android si basa sullo stesso sistema di configurazione dichiarativa utilizzato per il resto dell’ambiente di Devin. Aggiungi l’SDK Android e l’emulatore al tuo blueprint e lo snapshot di Devin crea una VM con tutto preinstallato. Ogni sessione si avvia da quello snapshot con l’emulatore pronto all’uso. Durante una sessione, Devin interagisce con l’emulatore in due modi:
MetodoCosa faQuando usarlo
adb (riga di comando)Installa APK, esegue test, acquisisce log, cattura screenshotBuild automatizzate, test strumentati, debug con logcat
Computer Use (desktop)Tocca, scorri, digita e naviga visivamente sullo schermo dell’emulatoreTest end-to-end della UI, verifica visiva, registrazioni video
La finestra dell’emulatore viene eseguita sul desktop di Devin, quindi puoi vedere Devin interagire con la tua app in tempo reale tramite la scheda Desktop nella webapp.

​
Configurare l’emulatore

Il modo più semplice per iniziare. Devin analizza il tuo progetto Android, installa i componenti SDK necessari e configura l’emulatore per te.
1

Avvia una sessione Devin

Apri una nuova sessione e chiedi a Devin di configurare l’emulazione Android. Ad esempio: “Configura un emulatore Android per questa repo.”
2

Esamina e approva

Devin propone un blueprint con l’SDK Android, gli strumenti di build e la configurazione dell’emulatore. Esamina le schede di suggerimento nella tua timeline e fai clic su Approve.
3

Verifica

Una volta completata la build, avvia una nuova sessione. Chiedi a Devin di eseguire la build e avviare la tua app nell’emulatore per confermare che tutto funzioni.

​
Cosa viene installato

Un blueprint tipico per il supporto dell’emulatore Android installa:
ComponenteScopo
Android SDK command-line toolsGestione dell’SDK (sdkmanager)
Platform toolsadb, fastboot per la comunicazione con il dispositivo
Build toolsaapt2, d8, zipalign per creare APK
Android platform (ad es. API 34)Livello API di destinazione per la tua app
Emulator + system imageIl dispositivo virtuale stesso
Usa una system image x86_64 per ottenere le migliori prestazioni nell’ambiente di Devin. Le immagini ARM funzionano, ma in emulazione sono notevolmente più lente.

​
Utilizzo dell’emulatore

​
Testing on demand

Chiedi a Devin di compilare ed eseguire la tua app in qualsiasi momento durante una sessione: non serve alcuna sintassi speciale, basta il linguaggio naturale:
  • “Compila ed esegui l’app sull’emulatore Android”
  • “Testa il flusso di accesso sull’emulatore e inviami una registrazione”
  • “Apri la schermata Settings sull’emulatore e verifica che il nuovo toggle sia presente”
  • “Esegui i test Espresso sull’emulatore e mostrami i risultati”
Devin avvierà l’emulatore (se non è già in esecuzione), compilerà ed eseguirà la tua app e interagirà con essa, usando adb per le azioni programmatiche e Computer Use per le interazioni visive.

​
Integrazione con Testing e registrazioni

Il supporto per l’emulatore Android si integra direttamente nel flusso di lavoro Testing & Recordings di Devin. Dopo aver creato una PR:
  1. Devin ti propone di testare l’app: fai clic sul pulsante oppure chiediglielo direttamente
  2. Devin compila ed esegue l’app sull’emulatore ed esegue un piano di test mirato
  3. La schermata dell’emulatore viene acquisita in una registrazione video con annotazioni
  4. La registrazione ti viene inviata, così puoi guardare il test e fare il merge con sicurezza
Funziona allo stesso modo del testing delle app web: l’unica differenza è che Devin interagisce con la finestra dell’emulatore anziché con Chrome.
Crea una Skill che indichi a Devin esattamente come compilare, avviare e testare la tua app Android. In questo modo risparmi tempo di configurazione nelle sessioni successive e garantisci un testing coerente. Per esempio, includi il comando di build di Gradle, quale activity avviare e quali flussi verificare.

​
Suggerimenti per le Skill

Dopo aver testato la tua app Android, Devin annota ciò che ha imparato — come avviare l’emulatore, quali task Gradle eseguire, come raggiungere la funzionalità oggetto del test — e propone di creare o aggiornare una Skill tramite una pull request (PR). Puoi integrare la PR così com’è oppure modificarla per perfezionare le istruzioni. Nel tempo, questo permette a Devin di migliorare nei test del tuo progetto Android. Le informazioni apprese in ogni sessione si sommano a quelle precedenti — quindi, la seconda volta che Devin testa la tua app, sa già come compilarla, quale activity avviare e quali flussi contano di più. Puoi anche chiedere a Devin di farlo in qualsiasi momento con un prompt (ad es. “crea una Skill che spieghi come compilare e testare questa app Android”). Consulta la guida alle Skills per tutti i dettagli.

​
Interazione tramite desktop

L’emulatore Android viene eseguito in una finestra sul desktop Linux di Devin. Questo significa:
  • Devin può interagire con l’emulatore tramite Computer Use — toccando pulsanti, scorrendo, digitando testo e navigando tra le schermate
  • Puoi seguirlo in tempo reale tramite la scheda Desktop nella webapp di Devin
  • Le registrazioni catturano lo schermo dell’emulatore insieme a qualsiasi altra cosa visibile sul desktop di Devin
Per maggiori dettagli su come funziona l’interazione tramite desktop, vedi Computer Use.

​
Uso di adb

Devin può anche interagire con l’emulatore in modo programmatico tramite adb, utile per:
  • Installare APK — adb install app-debug.apk
  • Eseguire test strumentati — adb shell am instrument -w com.example.test/androidx.test.runner.AndroidJUnitRunner
  • Acquisire log — adb logcat per eseguire il debug di crash o comportamenti imprevisti
  • Catturare screenshot — adb exec-out screencap -p > screenshot.png
  • Simulare l’input dell’utente — adb shell input tap 500 800 per interazioni via script
Devin sceglie tra adb e Computer Use in base all’attività: adb per velocità e automazione, Computer Use per la verifica visiva e i flussi UI complessi.

​
Esempi di blueprint

Blueprint da copiare e incollare per le configurazioni Android più comuni. Ogni modello è completo e autonomo: incollalo nell’editor di blueprint e salva. 
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

​
Risoluzione dei problemi

​
L’emulatore non si avvia

Cause comuni: KVM non è disponibile nella VM, memoria insufficiente o immagine di sistema mancante. Soluzione: Devin può tentare di configurare automaticamente KVM quando rileva che l’emulatore richiede l’accelerazione hardware — nella maggior parte dei casi, questo risolve il problema senza interventi manuali. Se KVM continua a non essere disponibile dopo il tentativo di Devin, l’emulatore può passare alla modalità di rendering software — aggiungi -no-accel al comando di avvio dell’emulatore, anche se le prestazioni saranno inferiori. Verifica anche che il blueprint installi l’emulatore e un’immagine di sistema x86_64 compatibile.

​
La build non riesce a completarsi a causa di errori dell’SDK

Cause comuni: componenti dell’SDK mancanti, percorso ANDROID_HOME errato oppure Gradle non riesce a trovare la versione corretta dei build tools. Soluzione: verifica che ANDROID_HOME sia impostato correttamente nel blueprint e che sdkmanager installi la versione della piattaforma e dei build tools richiesta dal progetto. Controlla i valori di compileSdk, targetSdk e buildToolsVersion nel file build.gradle del progetto e assicurati che corrispondano a quelli nel blueprint.

​
L’emulatore è lento

L’emulatore Android viene eseguito all’interno della VM di Devin, quindi le prestazioni dipendono dall’immagine di sistema e dalla modalità di rendering. Suggerimenti:
  • Usa immagini di sistema x86_64 (non ARM) per l’emulazione con accelerazione hardware
  • Usa -gpu swiftshader_indirect per il rendering software che non richiede il passthrough della GPU
  • Usa -no-window -no-audio quando Devin non ha bisogno dell’interfaccia visiva (ad es. per eseguire test strumentati tramite adb)
  • Valuta un profilo dispositivo a risoluzione inferiore se la fedeltà visiva non è fondamentale

​
Devin non riesce a interagire con lo schermo dell’emulatore

Cause comuni: Desktop mode non è abilitata, la finestra dell’emulatore non è visibile oppure l’emulatore è in esecuzione in modalità headless. Soluzione: assicurati che Desktop mode sia abilitata nelle Settings della tua organizzazione. Se hai bisogno che Devin interagisca visivamente con l’emulatore, avvialo senza il flag -no-window, in modo che la GUI dell’emulatore venga visualizzata sul desktop di Devin. Verifica che l’emulatore abbia completato l’avvio (adb shell getprop sys.boot_completed dovrebbe restituire 1) prima di chiedere a Devin di interagire con esso.