Se usó la API de Cloud Translation para traducir esta página.

Dispositivo virtual Android como plataforma de desarrollo

Para usar dispositivos virtuales de Android (AVD), el emulador de Android admite una interfaz gráfica de usuario (GUI) y una interfaz de línea de comandos (CLI). Usted selecciona el flujo de trabajo óptimo para su entorno.

Crear y administrar dispositivos virtuales La GUI es una herramienta sencilla que se proporciona a la mayoría de los desarrolladores y usuarios de aplicaciones.
Iniciar el emulador desde la línea de comandos proporciona una forma flexible para usuarios avanzados y automatización. Por ejemplo, para usar múltiples AVD o configurar pruebas continuas e integración continua. Para comenzar, consulte los ejemplos en herramientas .

Construir un AVD de coche AOSP

El proceso para crear un AOSP Car AVD es similar a la creación de imágenes AVD para un teléfono (por ejemplo, aosp_car_x86_64 ):

Para configurar el entorno de desarrollo e identificar una rama, consulte Herramientas de control de código fuente . Luego revise Descargar la fuente :

ANDROID_BRANCH="android11-qpr2-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

Cree la imagen AVD:

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

Ejecute la imagen de AVD (agregue opciones de inicio de línea de comandos adicionales según sea necesario):
```
emulator &
```
Por ejemplo:
Figura 1. Pantalla del emulador virtual de Android
Notas sobre este proceso:
- Debido a que el proceso de compilación es el mismo que se requiere para compilar Android para un dispositivo físico, espere un tiempo para descargar el código fuente y luego compilarlo.
- Para trabajar en otras sucursales, establezca $ANDROID_BRANCH en otra sucursal/etiqueta .
- Las imágenes AVD, como system.img , se construyen en $ANDROID_PRODUCT_OUT . Para obtener más información sobre las imágenes clave, consulte el directorio del sistema AVD .
- Consulte el archivo LÉAME para obtener información sobre cómo se utilizan los archivos binarios del emulador preconstruidos en su árbol de Android para ejecutar el emulador.

Crear un AVD de coche

Agregar un AVD de automóvil nuevo es casi idéntico a Agregar un dispositivo nuevo . Por ejemplo, 1660554 crea un nuevo AVD avd_car .

Para crear un AVD de coche:

Cree una empresa y una carpeta de dispositivo según sea necesario. Este ejemplo usa $ANDROID_BUILD_TOP/device/google_car/avd_car .
Cree el archivo MAKE del producto, avd_car.mk , que define cómo construir el AVD.
Cree una carpeta de dispositivos, avd_car_device , en la que se BoardConfig.mk y source.properties .
Agregue el nuevo makefile y la nueva opción de lunch a AndroidProducts.mk .

Para compilar y ejecutar el nuevo avd_car AVD:

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

Ahora está listo para crear prototipos de la mayoría de las funciones de HMI y aplicaciones en su nuevo AVD.

Empaquetar un archivo zip de imagen AVD

Puede empaquetar y compartir su AVD con otros o usarlo en otra computadora. Use emu_img_zip.mk para generar el archivo zip de la imagen AVD:

Después de compilar el AVD, haga que emu_img_zip sea el destino:
```
m emu_img_zip
```
El archivo zip de la imagen AVD, con el prefijo sdk-repo-linux-system-images , se crea en la carpeta denominada $ANDROID_PRODUCT_OUT .
Nota: Si bien emu_img_zip.mk se agregó después de Android 11, puede adaptar el archivo MAKE a una versión anterior. Por ejemplo, 1661582 funciona con Android 11.

Construir un núcleo AVD

Los núcleos AVD son similares a otros núcleos de Android en el sentido de que todos son imágenes preconstruidas. Normalmente, puede usar las imágenes preconstruidas estándar del kernel de goldfish tal como están en cada versión de Android.

Para experimentar con cambios en el kernel:

Ejecute la siguiente serie de instrucciones:

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/

Reemplace el binario del kernel en el código base de acuerdo con el archivo MAKE de AVD. Por ejemplo, x86_64-vendor.mk incluye x86_64-kernel.mk .

El código del kernel y la configuración se encuentran de la siguiente manera:

Artículo	Valor
Rama	`common-android11-5.4` (usado en Android 11)
Manifiesto	`kernel/manifest/common-android11-5.4`
módulos-comunes/dispositivo-virtual	`kernel/common-modules/virtual-device/android11-5.4`
Núcleo	`kernel/common/android11-5.4`

Crear un nuevo perfil de dispositivo

Para permitir que los usuarios creen un AVD específico en Android Studio AVD Manager, consulte Crear y administrar dispositivos virtuales . Los fabricantes de dispositivos pueden definir sus propias especificaciones de hardware, como tamaño de pantalla y DPI, mediante el uso de un archivo devices.xml incluido en la imagen AVD.

Por ejemplo, consulte los perfiles de dispositivos automotrices en automotive.xml .
Para el desarrollo o creación de prototipos de HMI, se pueden agregar varios dispositivos al archivo para la misma imagen AVD.
Incluya el archivo en el archivo zip de la imagen OEM AVD en la carpeta [ABI] . Por ejemplo, como x86_64 .
Los fabricantes de dispositivos también pueden crear una máscara de emulador . Por ejemplo, para definir botones de hardware adicionales para una experiencia de usuario de mayor fidelidad. Esto no solo es útil para los flujos de trabajo de los desarrolladores, sino también para otras tareas, como la investigación y revisión de UX.

Cree el archivo XML de imagen AVD

Los fabricantes de dispositivos pueden crear un archivo XML de imagen AVD para que Android Studio lo descargue.

Por ejemplo, consulte el archivo XML de imagen AAOS AVD, sys-img2-1.xml .
Los fabricantes de dispositivos pueden definir su propio acuerdo de licencia OEM AVD para sus usuarios objetivo (empleando el sistema de honor), con la licencia para Android Emulator. Android Studio obtiene el consenso de los usuarios cuando se incluye dicha licencia.

Para crear la imagen:

Prepare un archivo zip de imagen AVD.
Descomprima ${ANDROID_PRODUCT_OUT}/sdk-repo-linux-system-images-*.zip .
Agregue devices.xml a la carpeta x86_64 y luego comprima el archivo en un archivo zip. Por ejemplo, como oem_avd_img_x86_64.zip .
Actualice oem-sys-img2-1.xml .
Actualice el nombre, el tamaño y el shasum del archivo zip (los archivos XML de muestra se proporcionan en tools ).

Por ejemplo, para alojar el AVD en Google Cloud Storage , consulte Creación de depósitos de almacenamiento .

Para cargar y hacer que el AVD sea de acceso público, consulte Hacer públicos los datos :

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

El formato de la URL del complemento del SDK de imágenes de AVD es el siguiente: https://storage.googleapis.com/$BUCKET_NAME/oem-sys-img2-1.xml . Por ejemplo, si BUCKET_NAME es aaos-avd, la URL es: https://storage.googleapis.com/aaos-avd/oem-sys-img2-1.xml .

Para que sus usuarios puedan descargar imágenes de AVD y usar su AVD de Android Studio, puede proporcionar un archivo XML adicional de SDK. Para obtener más información, consulte Actualización de las herramientas IDE y SDK .

Para descargar el AVD de la red:

Aloja el archivo zip de la imagen y los archivos XML en un servidor.
Proporcione la URL a sus usuarios objetivo.
( Opcional ) Limite el acceso por nombre de usuario y contraseña.

Alternativamente, para acelerar el desarrollo, descargue el AVD a un directorio local:

Guarde los archivos XML y todos los artefactos especificados en el archivo XML en una carpeta (por ejemplo, todos los archivos zip de imágenes AVD) denominada ADDON_DIR .
Especifique la URL como file://$ADDON_DIR/oem-sys-img2-1.xml .