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 utilizar dispositivos virtuales de Android (AVD), Android Emulator admite una interfaz gráfica de usuario (GUI) y una interfaz de línea de comandos (CLI). Tú seleccionas el flujo de trabajo óptimo para tu entorno.

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

Cómo iniciar un AVD para automóviles del AOSP con compilación previa

Para iniciar y probar rápidamente con el AVD para autos del AOSP compilado previamente, usa una secuencia de comandos de código abierto para descargar y lanzar 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, haz lo siguiente:

Copia el launch_emu.sh de secuencias de comandos en tu archivo local, suponiendo que usas launch_emu.sh como el nombre del archivo local.
Haz que tu secuencia de comandos local sea ejecutable. Por ejemplo, ejecuta chmod +x ./launch_emu.sh.
Para verificar las opciones disponibles, ejecuta la secuencia de comandos con ./launch_emu.sh -h.
En ci.android.com, ve a la aosp-main-throttled y selecciona una compilación reciente en la que sdk_car_x86_64 es el verde. Por ejemplo: 11370359. Si no ves la opción sal de tu Cuenta de Google y vuelve a intentarlo.
Descarga e instala los archivos binarios relevantes del emulador con el ID de compilación. Por ejemplo, ./launch_emu.sh -i -a 11370359.
Luego, podrás usar ./launch_emu.sh para iniciar la versión descargada e instalada emulador (no uses las opciones -i ni -a).
Para descargar e instalar otro ID de compilación, ejecuta ./launch_emu.sh -c para limpiar tu y, luego, repite los pasos 4 y 5.

Cómo especificar Android Emulator Opciones de inicio de la línea de comandos cuando inicies el emulador, usa la opción -v. Por ejemplo:

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

Cómo compilar un AVD para un automóvil AOSP

El proceso para compilar un AVD para un automóvil AOSP es similar al siguiente: Cómo compilar imágenes de AVD para un teléfono (por ejemplo, aosp_car_x86_64):

Para configurar el entorno de desarrollo y, además, identificar una rama, consulta Herramientas de control de código fuente. Luego revisa Descarga la 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 del 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:
- El proceso de compilación es el mismo que se requiere para compilar Android. para un dispositivo físico, deja pasar un tiempo para descargar la fuente y, luego, compilarla.
- Para trabajar en otras ramas, establece $ANDROID_BRANCH en otra rama/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 AVD directorio del sistema.
- Consulta la README para obtener información sobre cómo se usan los objetos binarios del emulador precompilados en tu árbol de Android ejecuta el emulador.

Cómo crear un AVD de vehículo

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

Para crear un AVD de vehículo, haz lo siguiente:

Crea una empresa y una carpeta del dispositivo 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 para el dispositivo, avd_car_device, en la que BoardConfig.mk y source.properties.
Agrega el nuevo 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 &

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

Cómo empaquetar un archivo ZIP de imagen de AVD

Puedes empaquetar y compartir tu AVD con otros, o usarlo en otro que ya almacenaste en tu computadora. Usa emu_img_zip.mk. para generar el archivo ZIP de imagen de AVD:

Después de compilar el AVD, haz que emu_img_zip sea el destino:
```
m emu_img_zip
```
El archivo ZIP de la imagen de AVD, con el prefijo sdk-repo-linux-system-images, es creado en la carpeta llamada $ANDROID_PRODUCT_OUT.
Nota: Si bien emu_img_zip.mk se agregó después de Android 11, puedes hacer lo siguiente: adaptar el archivo makefile 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 en que todos son imágenes compiladas previamente. Por lo general, puedes usar las imágenes precompiladas del kernel estándar de goldfish tal como se presenta en cada versión de Android.

Para experimentar con los cambios en el 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 objeto binario del kernel en la base de código según el archivo makefile de 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` (en Android 11)
Manifest	`kernel/manifest/common-android11-5.4`
comunes-módulos/dispositivo-virtual	`kernel/common-modules/virtual-device/android11-5.4`
Kernel	`kernel/common/android11-5.4`

Cómo crear un perfil de dispositivo nuevo

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

Por ejemplo, consulta los perfiles de dispositivos de Automotive en automotive.xml.
Para el desarrollo o el prototipado de HMI, se pueden agregar varios dispositivos al para la misma imagen de AVD.
Incluye el archivo en el archivo ZIP de imagen de AVD de OEM en la carpeta [ABI]. Por ejemplo, como x86_64.
Los fabricantes de dispositivos también pueden crear un máscara de emulador. Por ejemplo, para definir botones de hardware adicionales que permitan 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 en UX y revisión.

Cómo crear el archivo en formato XML de imagen del AVD

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

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

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. un archivo ZIP. Por ejemplo, como oem_avd_img_x86_64.zip.
Actualiza oem-sys-img2-1.xml.
Actualiza el nombre del archivo ZIP, el tamaño y el shasum (los archivos en formato XML de muestra se proporcionan en tools).

Por ejemplo, para alojar el AVD en Google Cloud Storage, usa lo siguiente: consulta Creación buckets de almacenamiento.

Para subir el AVD y permitir el acceso público, consulta 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 URL del complemento del SDK de imagen de AVD es el siguiente: https://storage.googleapis.com/$BUCKET_NAME/oem-sys-img2-1.xml. Por ejemplo, si el BUCKET_NAME es aaos-avd, la URL será https://storage.googleapis.com/aaos-avd/oem-sys-img2-1.xml.

Para que tus usuarios puedan descargar imágenes del AVD y usar tu AVD mediante Android Studio, puedes hacer lo siguiente: proporcionar un archivo en formato XML para el complemento de SDK. Para obtener más información, consulta Actualiza el IDE y las herramientas del SDK.

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

Aloja el archivo ZIP de imagen y los archivos en formato XML en un servidor.
Proporciona la URL a los 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:

Guardar los archivos XML y todos los artefactos especificados en el archivo XML en una carpeta (por ejemplo, todos los archivos ZIP de la imagen del AVD) con el nombre ADDON_DIR.
Especifica la URL como file://$ADDON_DIR/oem-sys-img2-1.xml.