> ## 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. # Supporto per l'emulatore Android > Compila ed esegui applicazioni Android su un emulatore completo eseguito sulla macchina di Devin Devin può compilare ed eseguire applicazioni Android direttamente sulla propria macchina, dandogli l'equivalente Android di [Computer Use](/it/work-with-devin/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](/it/work-with-devin/testing-and-recordings), Devin può inviarti una registrazione come prova.
## Cosa puoi fare
Con il supporto per l'emulatore Android abilitato, Devin può gestire l'intero ciclo di sviluppo mobile: 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. 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 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. 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. Stai sviluppando con React Native, Flutter o Kotlin Multiplatform? Devin può testare il lato Android insieme alle build web o desktop nella stessa sessione. 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. 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](/it/onboard-devin/environment/blueprints) 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: | Metodo | Cosa fa | Quando usarlo | | --------------------------- | ----------------------------------------------------------------------- | -------------------------------------------------------------- | | **`adb`** (riga di comando) | Installa APK, esegue test, acquisisce log, cattura screenshot | Build automatizzate, test strumentati, debug con logcat | | **Computer Use** (desktop) | Tocca, scorri, digita e naviga visivamente sullo schermo dell'emulatore | Test 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. Apri una nuova sessione e chiedi a Devin di configurare l'emulazione Android. Ad esempio: *"Configura un emulatore Android per questa repo."* 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**. 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. Se sai esattamente di quali componenti SDK e di quale configurazione dell'emulatore hai bisogno, puoi scrivere direttamente il blueprint. Vai a **Settings > Environment > Blueprints** e seleziona il tuo repository Android. Aggiungi l'SDK Android, i platform tools, l'emulatore e un'immagine di sistema a `initialize`. Aggiungi l'installazione delle dipendenze a `maintenance`. Consulta gli [esempi di blueprint](#blueprint-examples) qui sotto per template da copiare e incollare. Fai clic su **Save**. Una build si avvia automaticamente (in genere 5–15 minuti per Android a causa dei download dell'SDK). Monitora l'avanzamento da **Settings > Environment > Snapshots**. Quando la build mostra **Success**, avvia una nuova sessione. Chiedi a Devin di avviare l'emulatore ed eseguire la build della tua app per verificare.
### Cosa viene installato
Un blueprint tipico per il supporto dell'emulatore Android installa: | Componente | Scopo | | -------------------------------- | --------------------------------------------------------- | | Android SDK command-line tools | Gestione dell'SDK (`sdkmanager`) | | Platform tools | `adb`, `fastboot` per la comunicazione con il dispositivo | | Build tools | `aapt2`, `d8`, `zipalign` per creare APK | | Android platform (ad es. API 34) | Livello API di destinazione per la tua app | | Emulator + system image | Il 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](/it/work-with-devin/testing-and-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](/it/product-guides/skills) 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](/it/product-guides/skills) 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](/it/product-guides/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](/it/work-with-devin/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. ```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 ```
## 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](/it/work-with-devin/computer-use#how-to-enable-it) 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.