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

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

Pour utiliser des appareils virtuels Android, Android Emulator prend en charge une interface utilisateur graphique (GUI) 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 des utilisateurs d'applications.
Démarrer l'émulateur depuis 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 continues. Pour commencer, consultez les exemples de outils).

Lancer un AVD de voiture AOSP à l'aide d'un AVD prédéfini

Pour lancer et tester rapidement à l'aide d'un AVD de voiture AOSP prédéfini, utilisez un script Open Source pour télécharger et lancer un build d'émulateur ci.android.com Le script a été testé sur macOS et Linux.

Vous aurez besoin de Curl pour utiliser ce script.

Pour exécuter le script:

Copiez l'élément launch_emu.sh contenus de script à votre fichier local, en supposant que vous utilisez launch_emu.sh comme le nom du fichier local.
Rendez votre script local exécutable. Par exemple, exécutez chmod +x ./launch_emu.sh.
Vérifiez les options disponibles en exécutant le script avec ./launch_emu.sh -h.
Sur ci.android.com, accédez à aosp-main-throttled et sélectionnez une compilation récente dans laquelle sdk_car_x86_64 est vert. Exemple : 11370359. Si vous ne voyez pas Déconnectez-vous de votre compte Google, puis réessayez.
Téléchargez et installez les fichiers binaires adaptés à l'émulateur avec l'ID de compilation. Par exemple : ./launch_emu.sh -i -a 11370359
Vous pouvez ensuite utiliser ./launch_emu.sh pour lancer l'application téléchargée et installée (n'utilisez pas les options -i ou -a).
Pour télécharger et installer un autre ID de build, exécutez ./launch_emu.sh -c afin de nettoyer votre puis répétez les étapes 4 et 5 ci-dessus.

Pour spécifier Android Emulator Options de démarrage de la ligne de commande lors du lancement de l'émulateur, utilisez l'option -v. Par exemple:

  ./launch_emu.sh -v “-cores 4 -memory 6144 -no-snapshot"

Créer un AVD de voiture AOSP

Le processus de création d'un AVD de voiture AOSP est semblable à celui-ci : Créer des 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 : Vérifiez ensuite 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 ce processus:
- Parce 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 branche/tag.
- Les images AVD, telles que system.img, sont créées dans $ANDROID_PRODUCT_OUT. Pour en savoir plus sur les images clés, consultez DMV répertoire système.
- Consultez le <ph type="x-smartling-placeholder"></ph> README pour découvrir comment les binaires de l'émulateur prédéfinis dans votre arborescence Android sont utilisés pour : exécutez l'émulateur.

Créer un AVD pour une voiture

L'ajout d'un nouvel AVD dans une voiture est presque identique à Ajouter un appareil. Par exemple : 1660554 crée un AVD avd_car.

Pour créer un AVD pour une voiture, procédez comme suit:

Si nécessaire, créez une entreprise et un dossier sur l'appareil. 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 de l'appareil, avd_car_device, dans lequel stocker BoardConfig.mk et source.properties.
Ajoutez les nouvelles propriétés makefile et lunch à AndroidProducts.mk
Pour créer et exécuter le nouvel AVD avd_car, procédez comme suit:
```
. build/envsetup.sh && lunch acar-userdebug && m -j32 && emulator &
```

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

Empaqueter un fichier ZIP contenant une image AVD

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

Après avoir créé l'AVD, définissez emu_img_zip comme cible:
```
m emu_img_zip
```
Le fichier ZIP de l'image AVD, précédé de sdk-repo-linux-system-images, est créé dans le dossier nommé $ANDROID_PRODUCT_OUT. <ph type="x-smartling-placeholder">
</ph> 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, dans la mesure où ils sont tous des images prédéfinies. Normalement, vous pouvez utiliser les images préconstruites du noyau de poisson rouge standard 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 le codebase en fonction du fichier makefile de l'AVD. Par exemple : x86_64-vendor.mk inclut x86_64-kernel.mk.

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

Article	Valeur
Branch	`common-android11-5.4` (utilisée dans Android 11)
Manifest	`kernel/manifest/common-android11-5.4`
commun-modules/virtual-device	`kernel/common-modules/virtual-device/android11-5.4`
Noyau	`kernel/common/android11-5.4`

Créer un profil sur l'appareil

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

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

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 puisse le télécharger.

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 OEM AVD pour leurs utilisateurs cibles. (utilisant le système d'honneur), avec la licence pour Android Emulator. Android Studio obtient le consensus des utilisateurs 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, procédez comme suit : consultez la page Créer Cloud Storage.

Pour importer l'appareil virtuel Android et le rendre accessible au public, 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 du SDK d'image AVD est le suivant: https://storage.googleapis.com/$BUCKET_NAME/oem-sys-img2-1.xml. Par exemple, si NOM_DU_BUCKET 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 d'Android Studio, vous pouvez un fichier XML du module complémentaire du SDK. Pour en savoir plus, consultez Mettez à jour l'IDE et SDK Tools.

Pour télécharger l'AVD à partir du réseau:

Hébergez le fichier image zip 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 de l'image AVD) nommés ADDON_DIR.
Indiquez file://$ADDON_DIR/oem-sys-img2-1.xml comme URL.