À partir de 2026, pour nous aligner sur notre modèle de développement stable et garantir la stabilité de la plate-forme pour l'écosystème, nous publierons le code source sur AOSP au deuxième et au quatrième trimestre. Pour créer et contribuer dans AOSP, utilisez android-latest-release. La branche de fichier manifeste android-latest-release fera toujours référence à la version la plus récente envoyée à AOSP. Pour en savoir plus, consultez Modifications apportées à AOSP.

Google uses AI technology to translate content into your preferred language. AI translations can contain errors.

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'interface utilisateur graphique est un outil simple fourni à la plupart des développeurs et utilisateurs d'applications.
Lancer l'émulateur à partir de la ligne de commande offre un moyen 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 outils).

Créer un AVD AOSP pour voiture

Le processus de création d'un AVD AOSP pour voiture est semblable à celui de la 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 des sources, puis lisez Télécharger la source Android :

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 des options de démarrage de la ligne de commande supplémentaires si nécessaire) :
```
emulator &
```
Exemple :

Figure 1. Écran de l'émulateur virtuel Android

Remarques concernant ce processus :
- Étant donné que 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 dans $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 d'émulateur précompilés de votre arborescence Android sont utilisés pour exécuter l'émulateur.

Créer un AVD pour voiture

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

Pour créer un AVD pour 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 comment créer l'AVD.
Créez un dossier d'appareil, avd_car_device, dans lequel placer BoardConfig.mk et source.properties.
Ajoutez le nouveau makefile et le nouveau lunch choix à AndroidProducts.mk.

Pour créer 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.

Empaqueter un fichier ZIP d'image AVD

Vous pouvez empaqueter 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 d'image AVD :

Une fois l'AVD créé, définissez emu_img_zip comme cible :
```
m emu_img_zip
```
Le fichier ZIP d'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 makefile à une version précédente. Par exemple, 1661582 fonctionne avec Android 11.

Créer un noyau AVD

Les noyaux AVD sont semblables aux autres noyaux Android, car ils sont tous des images précompilées. Normalement, 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 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
Branche	`common-android11-5.4` (utilisé dans Android 11)
Fichier manifeste	`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 AVD Manager d'Android Studio, consultez Créer et gérer des appareils virtuels. Les fabricants d'appareils peuvent définir leurs propres spécifications matérielles, par exemple pour la taille de l'écran et le DPI, à l'aide d'un fichier devices.xml inclus dans l'image 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 d'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 meilleure expérience utilisateur. Cela est utile non seulement pour les workflows de développement, mais aussi pour d'autres tâches telles que la recherche et l'examen de l'expérience utilisateur.

Créer le fichier XML d'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 d'image AVD AAOS, sys-img2-1.xml.
Les fabricants d'appareils peuvent définir leur propre contrat de licence AVD OEM pour leurs utilisateurs cibles (en utilisant le système d'honneur), avec la licence pour l'émulateur Android. 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 et rendre l'AVD 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 d'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 la suivante : 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 à partir du réseau :

Hébergez le fichier ZIP d'image 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 comme suit : file://$ADDON_DIR/oem-sys-img2-1.xml.