À partir du 27 mars 2025, nous vous recommandons d'utiliser android-latest-release au lieu de aosp-main pour créer et contribuer à AOSP. Pour en savoir plus, consultez la section Modifications apportées à AOSP.

Cette page a été traduite par l'API Cloud Translation.

Android Virtual Device en tant que plate-forme de développement

Pour utiliser les appareils virtuels Android (AVD), l'émulateur Android est compatible avec une interface utilisateur graphique (IUG) et une interface de ligne de commande (CLI). Vous sélectionnez le workflow optimal pour votre environnement.

Créer et gérer des appareils virtuels L'IUG est un outil simple fourni à la plupart des développeurs et utilisateurs d'applications.
Démarrer l'émulateur à partir de la ligne de commande offre une méthode flexible pour les utilisateurs expérimentés et l'automatisation. Par exemple, pour utiliser plusieurs AVD ou pour configurer des tests et une intégration continus. Pour commencer, consultez les exemples dans tools.

Créer un AVD AOSP pour une voiture

La procédure de création d'un AVD AOSP Car est semblable à celle de création d'images AVD pour un téléphone (par exemple, aosp_car_x86_64) :

Pour configurer l'environnement de développement et identifier une branche, consultez Outils de contrôle du code source. Ensuite, consultez Télécharger la source :

ANDROID_BRANCH="android12L-release"

REPO_URL="https://android.googlesource.com/platform/manifest"

mkdir $ANDROID_BRANCH && cd $ANDROID_BRANCH && repo init -u $REPO_URL -b
$ANDROID_BRANCH --partial-clone &&  repo sync -c -j8

Créez l'image AVD :

. build/envsetup.sh && lunch sdk_car_x86_64-userdebug && m -j32

Exécutez l'image AVD (ajoutez d'autres options de démarrage de la ligne de commande si nécessaire) :
```
emulator &
```
Exemple :

Figure 1 : Écran Android Virtual Emulator

Remarques concernant cette procédure :
- Comme le processus de compilation est le même que celui requis pour compiler Android pour un appareil physique, prévoyez un certain temps pour télécharger la source, puis la compiler.
- Pour travailler sur d'autres branches, définissez $ANDROID_BRANCH sur une autre branche/balise.
- Les images AVD, telles que system.img, sont créées sur $ANDROID_PRODUCT_OUT. Pour en savoir plus sur les images clés, consultez la section Répertoire système AVD.
- Consultez le fichier README pour découvrir comment les binaires de l'émulateur prédéfinis de votre arborescence Android sont utilisés pour exécuter l'émulateur.

Créer un AVD pour une voiture

L'ajout d'un nouvel AVD de voiture est presque identique à l'ajout d'un nouvel appareil. Par exemple, 1660554 crée un AVD avd_car.

Pour créer un AVD pour une voiture :

Créez une entreprise et un dossier d'appareil si nécessaire. Cet exemple utilise $ANDROID_BUILD_TOP/device/google_car/avd_car.
Créez le fichier makefile du produit, avd_car.mk, qui définit la façon de compiler l'AVD.
Créez un dossier d'appareil, avd_car_device, dans lequel inclure BoardConfig.mk et source.properties.
Ajoutez le nouveau makefile et le nouveau choix lunch à AndroidProducts.mk.

Pour compiler et exécuter le nouvel AVD avd_car :

. build/envsetup.sh && lunch acar-userdebug && m -j32 && emulator &

Vous êtes maintenant prêt à prototyper la plupart des fonctionnalités d'IHM et d'application sur votre nouvel AVD.

Compresser un fichier ZIP d'image AVD

Vous pouvez compresser et partager votre AVD avec d'autres utilisateurs, ou l'utiliser sur un autre ordinateur. Utilisez emu_img_zip.mk pour générer le fichier ZIP de l'image AVD :

Une fois l'AVD créé, définissez emu_img_zip comme cible :
```
m emu_img_zip
```
Le fichier ZIP de l'image AVD, préfixé par sdk-repo-linux-system-images, est créé dans le dossier nommé $ANDROID_PRODUCT_OUT.
Remarque : Bien que emu_img_zip.mk ait été ajouté après Android 11, vous pouvez adapter le fichier make à une version antérieure. Par exemple, 1661582 fonctionne avec Android 11.

Compiler un noyau AVD

Les noyaux AVD sont semblables aux autres noyaux Android, car ils sont tous des images précompilées. En temps normal, vous pouvez utiliser les images précompilées du noyau goldfish standard telles quelles à partir de chaque version d'Android.

Pour tester les modifications du noyau :

Exécutez la série d'instructions suivante :

mkdir goldfish-kernel-54
cd goldfish-kernel-54
repo init -u https://android.googlesource.com/kernel/manifest -b
common-android11-5.4
repo sync
BUILD_CONFIG=common/build.config.gki.x86_64 build/build.sh
BUILD_CONFIG=common-modules/virtual-device/build.config.goldfish.x86_64
build/build.sh
ls -l ./out/android11-5.4/dist/

Remplacez le binaire du noyau dans la base de code en fonction du fichier makefile de l'AVD. Par exemple, device/generic/goldfish/board/emu64x/details.mk inclut device/generic/goldfish/board/kernel/x86_64.mk.

Le code et la configuration du noyau se trouvent comme suit :

Élément	Valeur
Branch	`common-android11-5.4` (utilisé dans Android 11)
Manifest	`kernel/manifest/common-android11-5.4`
common-modules/virtual-device	`kernel/common-modules/virtual-device/android11-5.4`
Noyau	`kernel/common/android11-5.4`

Créer un profil d'appareil

Pour permettre aux utilisateurs de créer un AVD spécifique dans le gestionnaire d'AVD Android Studio, consultez Créer et gérer des appareils virtuels. Les fabricants d'appareils peuvent définir leurs propres spécifications matérielles, comme la taille de l'écran et la densité PPP, à l'aide d'un fichier devices.xml inclus dans l'image de l'AVD.

Par exemple, consultez les profils d'appareils automobiles dans automotive.xml.
Pour le développement ou le prototypage d'IHM, plusieurs appareils peuvent être ajoutés au fichier pour la même image AVD.
Incluez le fichier dans le fichier ZIP de l'image AVD OEM, dans le dossier [ABI]. Par exemple, x86_64.
Les fabricants d'appareils peuvent également créer une apparence d'émulateur. Par exemple, pour définir des boutons matériels supplémentaires pour une UX plus fidèle. Cela est utile non seulement pour les workflows des développeurs, mais aussi pour d'autres tâches telles que la recherche et l'examen de l'expérience utilisateur.

Créer le fichier XML de l'image AVD

Les fabricants d'appareils peuvent créer un fichier XML d'image AVD pour qu'Android Studio le télécharge.

Par exemple, consultez le fichier XML de l'image AVD AAOS, sys-img2-1.xml.
Les fabricants d'appareils peuvent définir leur propre contrat de licence OEM AVD pour leurs utilisateurs cibles (en utilisant le système de confiance), avec la licence pour Android Emulator. Android Studio obtient le consentement de l'utilisateur lorsqu'une telle licence est incluse.

Pour créer l'image :

Préparez un fichier ZIP d'image AVD.
Décompressez ${ANDROID_PRODUCT_OUT}/sdk-repo-linux-system-images-*.zip.
Ajoutez devices.xml au dossier x86_64, puis compressez le fichier dans un fichier ZIP. Par exemple, oem_avd_img_x86_64.zip.
Mettez à jour oem-sys-img2-1.xml.
Mettez à jour le nom, la taille et le shasum du fichier ZIP (des exemples de fichiers XML sont fournis dans tools).

Par exemple, pour héberger l'AVD sur Google Cloud Storage, consultez Créer des buckets de stockage.

Pour importer l'AVD et le rendre accessible publiquement, consultez Rendre des données publiques :

BUCKET_NAME="aaos-avd"
gsutil mb gs://$BUCKET_NAME
gsutil cp oem_avd_img_x86_64.zip gs://$BUCKET_NAME
gsutil cp oem-sys-img2-1.xml gs://$BUCKET_NAME
gsutil iam ch allUsers:objectViewer gs://$BUCKET_NAME

Le format de l'URL du module complémentaire SDK d'image AVD est le suivant : https://storage.googleapis.com/$BUCKET_NAME/oem-sys-img2-1.xml. Par exemple, si BUCKET_NAME est aaos-avd, l'URL est https://storage.googleapis.com/aaos-avd/oem-sys-img2-1.xml.

Pour que vos utilisateurs puissent télécharger des images AVD et utiliser votre AVD avec Android Studio, vous pouvez fournir un fichier XML de module complémentaire SDK. Pour en savoir plus, consultez Mettre à jour l'IDE et SDK Tools.

Pour télécharger l'AVD depuis le réseau :

Hébergez le fichier ZIP d'images et les fichiers XML sur un serveur.
Fournissez l'URL à vos utilisateurs cibles.
(Facultatif) Limitez l'accès par nom d'utilisateur et mot de passe.

Pour accélérer le développement, vous pouvez également télécharger l'AVD dans un répertoire local :

Enregistrez les fichiers XML et tous les artefacts spécifiés dans le fichier XML dans un dossier (par exemple, tous les fichiers ZIP d'image AVD) nommé ADDON_DIR.
Spécifiez l'URL sous la forme file://$ADDON_DIR/oem-sys-img2-1.xml.