Google se compromete a impulsar la igualdad racial para las comunidades afrodescendientes. Obtén información al respecto.

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

Dispositivo virtual de Android como plataforma de desarrollo

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

Cómo crear y administrar dispositivos virtuales La GUI es una herramienta sencilla que se proporciona a la mayoría de los desarrolladores y usuarios de apps.
Iniciar el emulador desde la línea de comandos proporciona una forma flexible para los usuarios avanzados y la automatización. Por ejemplo, para usar varios AVD o configurar pruebas continuas y una integración continua. Para comenzar, consulta los ejemplos en Herramientas.

Cómo iniciar un AVD de AOSP para vehículos con un elemento precompilado

Para iniciar y probar rápidamente con un AVD de AOSP Car precompilado, usa una secuencia de comandos de código abierto para descargar y, luego, iniciar una compilación del emulador desde ci.android.com. La secuencia de comandos se probó en macOS y Linux.

Necesitarás Curl para usar esta secuencia de comandos.

Para ejecutar la secuencia de comandos, sigue estos pasos:

Copia el contenido de la secuencia de comandos launch_emu.sh en tu archivo local, siempre que uses launch_emu.sh como nombre del archivo local.
Haz que tu secuencia de comandos local sea ejecutable. Por ejemplo, ejecuta chmod +x ./launch_emu.sh.
Ejecuta la secuencia de comandos con ./launch_emu.sh -h para verificar las opciones disponibles.
En ci.android.com, ve a la rama aosp-main-throttled y selecciona una compilación reciente en la que sdk_car_x86_64 sea verde. Por ejemplo, 11370359. Si no ves la información de compilación, sal de tu Cuenta de Google y vuelve a intentarlo.
Descarga e instala los archivos binarios relevantes para el emulador con el ID de compilación. Por ejemplo, ./launch_emu.sh -i -a 11370359.
Después de esto, puedes usar ./launch_emu.sh para iniciar el emulador descargado e instalado (no uses las opciones -i ni -a).
Para descargar e instalar otro ID de compilación, ejecuta ./launch_emu.sh -c para limpiar tu espacio de trabajo y, luego, repite los pasos 4 y 5 anteriores.

Para especificar las opciones de inicio de la línea de comandos de Android Emulator cuando lo inicias, usa la opción -v. Por ejemplo:

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

Cómo compilar un AVD de AOSP para vehículos

El proceso para compilar un AVD de AOSP Car es similar al de compilación de imágenes de AVD para un teléfono (por ejemplo, aosp_car_x86_64):

Para configurar el entorno de desarrollo y, luego, identificar una rama, consulta Herramientas de control de código fuente. Luego, revisa Cómo descargar el archivo fuente:

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

Compila la imagen del AVD:

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

Ejecuta la imagen de AVD (agrega opciones de inicio de la línea de comandos adicionales según sea necesario):
```
emulator &
```
Por ejemplo:

Figura 1: Pantalla de Android Virtual Emulator

Notas sobre este proceso:
- Dado que el proceso de compilación es el mismo que el necesario para compilar Android para un dispositivo físico, espera un tiempo para descargar la fuente y, luego, compilarla.
- Para trabajar en otras ramas, establece $ANDROID_BRANCH en otra rama o etiqueta.
- Las imágenes de AVD, como system.img, se compilan en $ANDROID_PRODUCT_OUT. Para obtener más información sobre las imágenes clave, consulta el directorio del sistema de AVD.
- Consulta el archivo README para obtener información sobre cómo se usan los objetos binarios del emulador precompilado en el árbol de Android para ejecutar el emulador.

Crea un AVD de vehículo

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

Para crear un AVD de vehículo, sigue estos pasos:

Crea una empresa y una carpeta de dispositivos según sea necesario. En este ejemplo, se usa $ANDROID_BUILD_TOP/device/google_car/avd_car.
Crea el archivo makefile del producto, avd_car.mk, que define cómo compilar el AVD.
Crea una carpeta del dispositivo, avd_car_device, en la que se contengan BoardConfig.mk y source.properties.
Agrega la nueva makefile y la nueva opción lunch a AndroidProducts.mk.

Para compilar y ejecutar el nuevo AVD de avd_car, haz lo siguiente:

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

Ya está todo listo para crear prototipos de la mayoría de las funciones de la HMI y de la app en tu nuevo AVD.

Cómo empaquetar un archivo ZIP de imagen de AVD

Puedes empaquetar y compartir tu AVD con otras personas o usarlo en otra computadora. Usa emu_img_zip.mk para generar el archivo ZIP de la imagen del AVD:

Después de compilar el AVD, establece emu_img_zip como destino:
```
m emu_img_zip
```
El archivo ZIP de la imagen del AVD, con el prefijo sdk-repo-linux-system-images, se crea en la carpeta llamada $ANDROID_PRODUCT_OUT.
Nota: Si bien emu_img_zip.mk se agregó después de Android 11, puedes adaptar el archivo de configuración de make a una versión anterior. Por ejemplo, 1661582 funciona con Android 11.

Cómo compilar un kernel de AVD

Los kernels de AVD son similares a otros kernels de Android, ya que todos son imágenes precompiladas. Por lo general, puedes usar las imágenes precompiladas del kernel de goldfish estándar tal como están en cada versión de Android.

Para experimentar con los cambios del kernel, haz lo siguiente:

Ejecuta 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/

Reemplaza el binario del kernel en la base de código según el archivo de configuración de make del AVD. Por ejemplo, x86_64-vendor.mk incluye x86_64-kernel.mk.

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

Artículo	Valor
Branch	`common-android11-5.4` (se usa en Android 11)
Manifest	`kernel/manifest/common-android11-5.4`
common-modules/virtual-device	`kernel/common-modules/virtual-device/android11-5.4`
Kernel	`kernel/common/android11-5.4`

Crea un nuevo perfil de dispositivo

Para permitir que los usuarios creen un AVD específico en el Administrador de AVD de Android Studio, consulta Cómo crear y administrar dispositivos virtuales. Los fabricantes de dispositivos pueden definir sus propias especificaciones de hardware, como el tamaño de la pantalla y el DPI, con el uso de un archivo devices.xml incluido en la imagen del AVD.

Por ejemplo, consulta los perfiles de dispositivos automotrices en automotive.xml.
Para el desarrollo o el prototipado de la HMI, se pueden agregar varios dispositivos al archivo para la misma imagen de AVD.
Incluye el archivo en el archivo ZIP de la imagen del AVD del OEM 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 UX 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 la revisión de UX.

Crea el archivo en formato XML de imagen de AVD

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

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

Para crear la imagen, haz lo siguiente:

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

Por ejemplo, para alojar el AVD en Cloud Storage de Google, consulta Cómo crear buckets de almacenamiento.

Para subir el AVD y permitir el acceso público, consulta Haz 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 la imagen del AVD es 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 los usuarios puedan descargar imágenes de AVD y usarlas con Android Studio, puedes proporcionar un archivo en formato XML del complemento del SDK. Para obtener más información, consulta Cómo actualizar el IDE y las herramientas del SDK.

Para descargar el AVD de la red, haz lo siguiente:

Aloja el archivo ZIP de imágenes y los archivos en formato XML en un servidor.
Proporciona la URL a tus usuarios objetivo.
(Opcional) Limita el acceso por nombre de usuario y contraseña.

Como alternativa, para acelerar el desarrollo, descarga el AVD en un directorio local:

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