Pour utiliser des appareils virtuels Android (AVD), Android Emulator 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.
- Le démarrage de 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 Outils.
Lancer un AVD pour voiture AOSP à l'aide d'un précompilé
Pour lancer et tester rapidement à l'aide d'un AVD AOSP Car précompilé, utilisez un script Open Source pour télécharger et lancer une version de l'é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 utilisezlaunch_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 brancheaosp-main-throttled
et sélectionnez une version récente dans laquellesdk_car_x86_64
est vert. Par exemple, 11370359. Si aucune information de compilation ne s'affiche, déconnectez-vous de votre compte Google, puis 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
. - Vous pouvez ensuite 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 compilation, 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 lorsque vous lancez l'émulateur, utilisez l'option -v
. Exemple :
./launch_emu.sh -v “-cores 4 -memory 6144 -no-snapshot"
Créer un AVD pour une voiture AOSP
Le processus de création d'un AVD AOSP pour voiture est semblable à 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 la section Outils de contrôle des sources. Consultez ensuite la section 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 des options de démarrage de la ligne de commande supplémentaires si nécessaire):
emulator &
Exemple :
Figure 1 : Écran d'Android Virtual Emulator
Remarques sur 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 à$ANDROID_PRODUCT_OUT
. Pour en savoir plus sur les images de 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 une voiture
L'ajout d'un AVD de voiture est presque identique à l'ajout d'un 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 placerBoardConfig.mk
etsource.properties
. - Ajoutez le nouveau
makefile
et le nouveau choixlunch
àAndroidProducts.mk
. - Pour compiler et exécuter le nouvel AVD
avd_car
:. build/envsetup.sh && lunch acar-userdebug && m -j32 && emulator &
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 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é du préfixe
sdk-repo-linux-system-images
, est créé dans le dossier nommé$ANDROID_PRODUCT_OUT
.
Créer un noyau AVD
Les noyaux AVD sont semblables aux autres noyaux Android en ce sens qu'ils sont tous des images prédéfinies. En règle générale, vous pouvez utiliser les images prédéfinies 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 kernel dans le codebase conformément au fichier makefile de l'AVD. Par exemple,
x86_64-vendor.mk
inclutx86_64-kernel.mk
.
Le code et la configuration du kernel 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'appareils virtuels Android Studio, consultez la section 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 la densité PPP, à 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'une IHM, vous pouvez ajouter plusieurs appareils 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 afin d'améliorer l'expérience utilisateur. Cela n'est pas seulement utile 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 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 d'image de l'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 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 dossierx86_64
, puis compressez le fichier dans un fichier ZIP. Par exemple,oem_avd_img_x86_64.zip
. - Mettez à jour
oem-sys-img2-1.xml
. - Modifiez le nom, la taille et le hachage du fichier ZIP (des exemples de fichiers XML sont fournis dans
tools
).
Par exemple, pour héberger l'AVD sur Cloud Storage de Google, consultez Créer des buckets de stockage.
Pour importer l'AVD et la rendre accessible au public, consultez la section 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 le nom du bucket est aaos-avd, l'URL est https://storage.googleapis.com/aaos-avd/oem-sys-img2-1.xml
.
Partager une image AVD avec les utilisateurs d'Android Studio
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 de SDK. Pour en savoir plus, consultez la section Mettre à jour l'IDE et SDK Tools.
Pour télécharger l'AVD à partir du 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.
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
.