> ## 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. # Prise en charge de l'émulateur Android > Build et exécuter des applications Android sur un émulateur complet exécuté sur la machine de Devin Devin peut build et exécuter des applications Android directement sur sa propre machine, ce qui lui donne l'équivalent Android de [Computer Use](/fr/work-with-devin/computer-use) et des interactions avec le navigateur. Devin peut ouvrir l'application, inspecter son comportement, reproduire les problèmes et vérifier les modifications dans l'environnement où l'application s'exécute réellement. Combiné aux [enregistrements vidéo](/fr/work-with-devin/testing-and-recordings), Devin peut vous envoyer un enregistrement comme preuve.
## Ce que vous pouvez faire
Avec la prise en charge de l'émulateur Android activée, Devin peut gérer l'ensemble du cycle de développement mobile : Devin build et exécute votre application sur l'émulateur, puis parcourt les flux critiques après chaque PR. Vous obtenez un enregistrement vidéo qui prouve que la fonctionnalité fonctionne — il ne vous reste plus qu'à le regarder et à fusionner. Testez des parcours utilisateur complets — connexion, navigation, envoi de formulaire, paiement — sur une véritable stack Android, pas un mock. Devin suit le flux étape par étape et signale tout ce qui casse. Vérifiez les mises en page, les thèmes et le comportement responsive sur différentes tailles d'écran et différents niveaux d'API. Devin prend des captures d'écran à des moments clés et signale les problèmes visuels, comme des éléments qui se chevauchent ou du texte tronqué. Reproduisez les problèmes sur l'émulateur, capturez la sortie `logcat`, inspectez le comportement, identifiez la cause racine et poussez un correctif — le tout dans une seule session. Vous développez avec React Native, Flutter ou Kotlin Multiplatform ? Devin peut tester la partie Android en parallèle de vos builds web ou desktop dans la même session. Exécutez des suites de tests Espresso ou UI Automator sur l'émulateur et récupérez les résultats, sans avoir besoin d'une ferme d'appareils CI dédiée ni d'appareils physiques. Vérifiez votre application sur différents niveaux d'API ou profils d'appareil en configurant plusieurs AVD. Utile pour détecter les problèmes de compatibilité avant qu'ils n'affectent les utilisateurs.
## Comment ça fonctionne
La prise en charge de l'émulateur Android repose sur le même système de [configuration déclarative](/fr/onboard-devin/environment/blueprints) que le reste de l'environnement de Devin. Vous ajoutez le SDK Android et l'émulateur à votre blueprint, et le build du snapshot de Devin crée une VM avec tout préinstallé. Chaque session démarre à partir de ce snapshot, avec l'émulateur prêt à l'emploi. Pendant une session, Devin interagit avec l'émulateur de deux façons : | Méthode | Ce qu'elle permet de faire | Quand l'utiliser | | ----------------------------- | -------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------- | | **`adb`** (ligne de commande) | Installer des APK, exécuter des tests, capturer des logs, prendre des captures d'écran | Builds automatisés, tests instrumentés, débogage avec logcat | | **Computer Use** (bureau) | Appuyer, balayer, saisir du texte et naviguer visuellement dans l'émulateur | Tests d'interface de bout en bout, vérification visuelle, enregistrements vidéo | La fenêtre de l'émulateur s'exécute sur le bureau de Devin, ce qui vous permet de voir Devin interagir avec votre application en temps réel via l'onglet **Desktop** de l'application web.
## Configuration de l'émulateur
La façon la plus simple de commencer. Devin analyse votre projet Android, installe les bons composants du SDK et configure l'émulateur pour vous. Ouvrez une nouvelle session et demandez à Devin de configurer l'émulation Android. Par exemple : *"Configure un émulateur Android pour ce dépôt."* Devin propose un blueprint avec le SDK Android, les outils de build et la configuration de l'émulateur. Consultez les cartes de suggestion dans votre timeline, puis cliquez sur **Approve**. Une fois le build terminé, démarrez une nouvelle session. Demandez à Devin de build et d'exécuter votre application sur l'émulateur pour confirmer que tout fonctionne. Si vous savez exactement de quels composants du SDK et de quelle configuration d'émulateur vous avez besoin, vous pouvez rédiger le blueprint vous-même. Accédez à **Settings > Environment > Blueprints** et sélectionnez votre dépôt Android. Ajoutez le SDK Android, les outils de plateforme, l'émulateur et une image système à `initialize`. Ajoutez l'installation de vos dépendances à `maintenance`. Consultez les [exemples de blueprint](#blueprint-examples) ci-dessous pour obtenir des modèles à copier-coller. Cliquez sur **Save**. Un build démarre automatiquement (comptez généralement 5 à 15 minutes pour Android en raison des téléchargements du SDK). Suivez la progression depuis **Settings > Environment > Snapshots**. Une fois que le build affiche **Success**, démarrez une nouvelle session. Demandez à Devin de lancer l'émulateur et de build votre application pour vérifier que tout fonctionne.
### Ce qui est installé
Un blueprint type pour la prise en charge de l'émulateur Android installe : | Composant | Objectif | | ------------------------------------------ | ----------------------------------------------------- | | Outils en ligne de commande du SDK Android | Gestion de base du SDK (`sdkmanager`) | | Outils de plateforme | `adb`, `fastboot` pour communiquer avec les appareils | | Outils de build | `aapt2`, `d8`, `zipalign` pour créer des APK | | Plateforme Android (p. ex., API 34) | Niveau d'API cible de votre application | | Émulateur + image système | L'appareil virtuel lui-même | Utilisez une image système `x86_64` pour obtenir les meilleures performances dans l'environnement de Devin. Les images ARM fonctionnent, mais sont nettement plus lentes en émulation.
## Utiliser l’émulateur
### Tests à la demande
Demandez à Devin de build et d’exécuter votre application à tout moment au cours d’une session — aucune syntaxe particulière n’est nécessaire, utilisez simplement le langage naturel : * *"Build et exécute l’application sur l’émulateur Android"* * *"Teste le parcours de connexion sur l’émulateur et envoie-moi un enregistrement"* * *"Ouvre l’écran des paramètres sur l’émulateur et vérifie que le nouveau bouton bascule apparaît"* * *"Exécute les tests Espresso sur l’émulateur et montre-moi les résultats"* Devin lancera l’émulateur (s’il n’est pas déjà en cours d’exécution), fera le build et exécutera votre application, puis interagira avec elle — en utilisant `adb` pour les actions automatisées et Computer Use pour les interactions visuelles.
### Intégration avec les tests et les enregistrements
La prise en charge de l’émulateur Android s’intègre directement au workflow [Tests et enregistrements](/fr/work-with-devin/testing-and-recordings) de Devin. Après avoir créé une PR : 1. Devin propose de **tester l’application** — cliquez sur le bouton ou demandez-le directement à Devin 2. Devin build et exécute l’application sur l’émulateur, puis exécute un plan de test ciblé 3. L’écran de l’émulateur fait l’objet d’un **enregistrement vidéo** annoté 4. L’enregistrement vous est envoyé pour que vous puissiez visionner le test et fusionner la PR en toute confiance Cela fonctionne de la même manière que pour le test d’une application web — la seule différence est que Devin interagit avec la fenêtre de l’émulateur au lieu de Chrome. Créez un [Skill](/fr/product-guides/skills) qui indique à Devin exactement comment build, lancer et tester votre application Android. Cela réduit le temps de configuration lors des sessions suivantes et garantit des tests cohérents. Par exemple, incluez la commande de build Gradle, l’activité à lancer et les parcours à vérifier.
### Suggestions de skills
Après avoir testé votre application Android, Devin consigne ce qu'il a appris — comment démarrer l'émulateur, quelles tâches Gradle exécuter, comment accéder à la fonctionnalité testée — et propose de créer ou de mettre à jour une [Skill](/fr/product-guides/skills) via une PR. Vous pouvez fusionner la PR telle quelle ou la modifier pour affiner les instructions. Au fil du temps, cela signifie que Devin devient plus efficace pour tester votre projet Android. Les apprentissages de chaque session s'appuient sur les précédents — ainsi, la deuxième fois que Devin teste votre application, il sait déjà comment lancer le build, quelle activité ouvrir et quels parcours sont les plus importants. Vous pouvez également demander à Devin de le faire à tout moment (p. ex., *"create a skill for how to build and test this Android app"*). Consultez le [guide des Skills](/fr/product-guides/skills) pour plus de détails.
### Interagir via le bureau
L'émulateur Android s'exécute dans une fenêtre sur le bureau Linux de Devin. Cela signifie : * **Devin peut interagir avec lui via Computer Use** — appuyer sur des boutons, balayer l'écran, saisir du texte, naviguer entre les écrans * **Vous pouvez le suivre en direct** via l'onglet **Desktop** de l'application web Devin * **Les enregistrements incluent l'écran de l'émulateur** ainsi que tout le reste visible sur le bureau de Devin Pour en savoir plus sur le fonctionnement de l'interaction via le bureau, consultez [Computer Use](/fr/work-with-devin/computer-use).
### Utilisation de `adb`
Devin peut aussi interagir avec l’émulateur de manière programmatique via `adb`, ce qui est utile pour : * **Installer des APK** — `adb install app-debug.apk` * **Exécuter des tests instrumentés** — `adb shell am instrument -w com.example.test/androidx.test.runner.AndroidJUnitRunner` * **Capturer des logs** — `adb logcat` pour déboguer des plantages ou des comportements inattendus * **Prendre des captures d’écran** — `adb exec-out screencap -p > screenshot.png` * **Simuler des actions utilisateur** — `adb shell input tap 500 800` pour des interactions scriptées Devin choisit entre `adb` et Computer Use selon la tâche : `adb` pour la rapidité et l’automatisation, Computer Use pour la vérification visuelle et les flux d’interface utilisateur complexes.
## Exemples de blueprints
Blueprints prêts à copier-coller pour les configurations Android courantes. Chaque blueprint est autonome — collez-le dans votre éditeur de blueprint et enregistrez. ```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 ```
## Dépannage
### L'émulateur ne démarre pas
**Causes courantes :** KVM n'est pas disponible dans la VM, la mémoire est insuffisante ou il manque une image système. **Correctif :** Devin peut tenter de configurer KVM automatiquement lorsqu'il détecte que l'émulateur a besoin d'une accélération matérielle. Dans la plupart des cas, cela résout le problème sans intervention manuelle. Si KVM n'est toujours pas disponible après la tentative de Devin, l'émulateur peut basculer en mode de rendu logiciel ; ajoutez `-no-accel` à la commande de lancement de l'émulateur, même si les performances seront réduites. Vérifiez également que votre blueprint installe l'émulateur ainsi qu'une image système `x86_64` compatible.
### Le build échoue avec des erreurs liées au SDK
**Causes courantes :** composants du SDK manquants, chemin `ANDROID_HOME` incorrect, ou Gradle ne parvient pas à trouver la bonne version des outils de build. **Correctif :** vérifiez que `ANDROID_HOME` est correctement défini dans votre blueprint et que `sdkmanager` installe la version de plateforme et la version des outils de build requises par votre projet. Vérifiez les valeurs `compileSdk`, `targetSdk` et `buildToolsVersion` dans le `build.gradle` de votre projet, puis faites-les correspondre dans le blueprint.
### L'émulateur est lent
L'émulateur Android s'exécute dans la VM de Devin ; les performances dépendent donc de l'image système et du mode de rendu. **Conseils :** * Utilisez des images système `x86_64` (et non ARM) pour une émulation accélérée par le matériel * Utilisez `-gpu swiftshader_indirect` pour un rendu logiciel ne nécessitant pas de passthrough GPU * Utilisez `-no-window -no-audio` lorsque Devin n'a pas besoin d'un affichage visuel (p. ex., pour exécuter des tests instrumentés via `adb`) * Envisagez un profil d'appareil à plus faible résolution si la fidélité visuelle n'est pas essentielle
### Devin ne peut pas interagir avec l'écran de l'émulateur
**Causes fréquentes :** Desktop mode n'est pas activé, la fenêtre de l'émulateur n'est pas visible ou l'émulateur s'exécute sans interface graphique. **Correctif :** Assurez-vous que [Desktop mode](/fr/work-with-devin/computer-use#how-to-enable-it) est activé dans les paramètres de votre organisation. Si vous avez besoin que Devin interagisse visuellement avec l'émulateur, lancez-le *sans* l'indicateur `-no-window` afin que l'interface graphique de l'émulateur apparaisse sur le bureau de Devin. Vérifiez que l'émulateur a fini de démarrer (`adb shell getprop sys.boot_completed` doit renvoyer `1`) avant de demander à Devin d'interagir avec lui.