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

Appareil virtuel Android comme plateforme de développement

Pour utiliser des appareils virtuels Android (AVD), l'émulateur Android prend en charge une interface utilisateur graphique (GUI) et une interface de ligne de commande (CLI). Vous sélectionnez le flux de travail optimal pour votre environnement.

Créer et gérer l'interface graphique des appareils virtuels 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 un moyen flexible pour les utilisateurs expérimentés et l'automatisation. Par exemple, pour utiliser plusieurs AVD ou pour mettre en place des tests continus et une intégration continue. Pour commencer, consultez les exemples dans outils ).

Lancez un AVD de voiture AOSP à l'aide de pré-construits

Pour lancer et tester rapidement à l'aide d'AOSP Car AVD prédéfini, utilisez un script open source pour télécharger et lancer une version d'émulateur à partir de 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 le contenu du script launch_emu.sh dans votre fichier local, en supposant que vous utilisez launch_emu.sh comme nom de 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 à la branche aosp-main-throttled et sélectionnez une version récente dans laquelle sdk_car_x86_64 est vert. Par exemple, 11370359. Si vous ne voyez pas les informations de construction, déconnectez-vous de votre compte Google et réessayez.
Téléchargez et installez les fichiers binaires pertinents pour l'émulateur avec l'ID de build. Par exemple, ./launch_emu.sh -i -a 11370359 .
Après cela, vous pouvez utiliser ./launch_emu.sh pour lancer l'émulateur téléchargé et installé (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 pour nettoyer votre espace de travail, puis répétez les étapes 4 et 5 ci-dessus.

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

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

Construire un AVD de voiture AOSP

Le processus de création d'un AVD de voiture AOSP est similaire à 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 de code source . Revoyez ensuite Téléchargement de 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

Construisez 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 ligne de commande supplémentaires si nécessaire) :
```
emulator &
```
Par exemple:
Figure 1. Écran de l'émulateur virtuel Android
Notes sur ce processus :
- Étant donné que le processus de création est le même que celui requis pour créer Android pour un appareil physique, prévoyez un certain temps pour télécharger la source, puis la créer.
- Pour travailler sur d'autres branches, définissez $ANDROID_BRANCH sur une autre branche/tag .
- Les images AVD, telles que system.img , sont créées à $ANDROID_PRODUCT_OUT . Pour en savoir plus sur les images clés, consultez le répertoire système AVD .
- Consultez le fichier README pour savoir comment les binaires d'émulateur prédéfinis dans votre arborescence Android sont utilisés pour exécuter l'émulateur.

Créer un AVD de voiture

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

Pour créer un AVD de voiture :

Créez une entreprise et un dossier de périphérique selon vos besoins. Cet exemple utilise $ANDROID_BUILD_TOP/device/google_car/avd_car .
Créez le makefile du produit, avd_car.mk , qui définit comment créer l'AVD.
Créez un dossier de périphérique, avd_car_device , dans lequel contenir BoardConfig.mk et source.properties .
Ajoutez le nouveau makefile et le nouveau choix lunch à 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 de l'IHM et des applications sur votre nouvel AVD.

Emballez un fichier zip d'image AVD

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

Après avoir créé l'AVD, faites de emu_img_zip la 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 makefile à une version précédente. Par exemple, 1661582 fonctionne avec Android 11.

Construire un noyau AVD

Les noyaux AVD sont similaires aux autres noyaux Android dans la mesure où ils sont tous des images prédéfinies. Normalement, vous pouvez utiliser les images prédéfinies du noyau de poisson rouge standard, telles que celles de chaque version d'Android.

Pour expérimenter 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 conformément au makefile 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
Bifurquer	`common-android11-5.4` (utilisé dans Android 11)
Manifeste	`kernel/manifest/common-android11-5.4`
modules-communs/périphérique-virtuel	`kernel/common-modules/virtual-device/android11-5.4`
Noyau	`kernel/common/android11-5.4`

Créer un nouveau profil d'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 DPI, grâce à l'utilisation d'un fichier devices.xml inclus dans l'image AVD.

Par exemple, consultez les profils de périphérique automobile 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 OEM AVD dans le dossier [ABI] . Par exemple, comme x86_64 .
Les fabricants d'appareils peuvent également créer un skin d'émulateur . Par exemple, pour définir des boutons matériels supplémentaires pour une UX plus fidèle. Ceci n'est pas seulement utile pour les flux de travail des développeurs, mais également pour d'autres tâches telles que la recherche et la révision UX.

Créer le fichier XML de l'image AVD

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

Par exemple, consultez le fichier XML d'image AAOS AVD, 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 d'honneur), avec la licence pour l'émulateur Android. 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, comme 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éation de buckets de stockage .

Pour télécharger et rendre l'AVD accessible au public, voir Rendre les 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 : 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 par Android Studio, vous pouvez fournir un fichier XML complémentaire SDK. Pour plus de détails, consultez Mettre à jour les outils IDE et SDK .

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

Hébergez le fichier zip de l’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.

Alternativement, pour accélérer le développement, téléchargez 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 des images AVD) nommé ADDON_DIR .
Spécifiez l'URL sous la forme file://$ADDON_DIR/oem-sys-img2-1.xml .