A partir de 2026, para alinearnos con nuestro modelo de desarrollo llamado Trunk Stable y garantizar la estabilidad de la plataforma para el ecosistema, publicaremos el código fuente en el AOSP en el segundo y cuarto trimestre. Para compilar el AOSP y contribuir a él, te recomendamos que utilices android-latest-release en lugar de aosp-main. La rama del manifiesto android-latest-release siempre hará referencia a la versión más reciente que se envió al AOSP. Para obtener más información, consulta Cambios en el AOSP.

Google uses AI technology to translate content into your preferred language. AI translations can contain errors.

Genera middleware

El middleware del lenguaje de definición de la interfaz de servicios para vehículos (VSIDL) define un conjunto de bibliotecas de Rust que crean una capa de abstracción sobre la pila de comunicación del vehículo definido por software (SDV) para simplificar el uso del ecosistema del SDV. El middleware proporciona una forma estandarizada para que los servicios se comuniquen e interactúen entre sí. Tanto el código generado por VSIDLC como tu código personalizado usan estas bibliotecas.

El compilador del lenguaje de definición de la interfaz de servicios para vehículos (VSIDLC) valida las definiciones, genera archivos de compilación (Android.bp) que contienen destinos genrule para producir código de middleware de Rust durante el proceso de compilación y crea configuraciones de implementación a partir de los archivos VSIDL y protobuf en un catálogo. En la figura 1, se muestran la entrada y la salida generada por VSIDLC:

Entradas y salidas de VSIDLC

Figura 1: Entradas y salidas de VSIDLC

A continuación, se explica el diagrama:

Como entradas, proporcionas los siguientes archivos organizados en directorios conocidos como catálogos:
- Los archivos .proto (con la extensión .proto) contienen estructuras de datos que se intercambian entre las unidades de servicio definidas por VSIDL.
- Los archivos VSIDL (con la extensión .vsidl) definen paquetes de servicios, unidades de servicio y propiedad del tipo de unidad.
- Los archivos Android.bp en cada directorio del catálogo definen los destinos de compilación rust_protobuf para todos los archivos .proto dentro del catálogo. VSIDLC usa el crate_name especificado en estos destinos para hacer referencia a los tipos de mensajes de protobuf generados en Rust.
Ejecuta VSIDLC para generar los siguientes archivos:
- Los archivos Android.bp se generan dentro de la carpeta de cada paquete de servicio. Si configuras --genrule, estos destinos generan archivos de Rust actualizados durante el proceso de compilación y, además, incluyen las dependencias de biblioteca rust_protobuf necesarias.
- Se generan archivos service_bundle.rs para cada paquete de servicios, que contienen el struct principal y las funciones para interactuar con los componentes de middleware.
- Se generan archivos lib.rs para cada servicio de RPC que pertenece a un paquete y se colocan en una subcarpeta con el nombre del servicio de RPC. Estos archivos incluyen lo siguiente:
- Un rasgo Interface implementa la lógica del servidor.
- Una estructura Client realiza llamadas a un servicio de RPC.
- Los archivos diagnostics.rs se generan si hay un diagnostics_declaration en el archivo VSIDL, lo que proporciona las vinculaciones necesarias para el diagnóstico basado en UDS.
- Cuando se usa la marca --apex, se generan las configuraciones de implementación y seguridad. Estos se colocan en los directorios apex/ y configs/, y se incluyen archivos de orquestación .textproto y políticas de seguridad (permisos) necesarios para la comunicación de servicio a servicio.
- Se genera un boilerplate de servicio cuando se usa la marca --services. Se coloca en un directorio services/ y contiene un esqueleto de aplicación de Rust, incluido un archivo main.rs, para iniciar rápidamente tu implementación.

Ejecuta VSIDLC

Para ejecutar VSIDLC, haz lo siguiente:

Si no configuraste tu entorno, ejecuta source build/envsetup.sh.
Ejecuta el siguiente comando para compilar VSIDLC:
```
m vsidlc
```
Asegúrate de que el directorio del catálogo de VSIDL tenga los archivos de compilación, protobuf y VSIDL necesarios.

Nota: Te recomendamos que definas bibliotecas rust_protobuf pequeñas agrupadas de forma lógica en lugar de una biblioteca grande para todo el catálogo. Para evitar ambigüedades, asegúrate de que cada archivo .proto pertenezca a un solo destino de biblioteca dentro del catálogo.
Ejecuta el comando vsidlc:
```
vsidlc -c path_to_catalog -o output_directory -p
```
En la que:
- -c path_to_catalog identifica la ruta de acceso al directorio principal del catálogo.
- -o output_directory identifica el directorio principal en el que se crea el directorio de salida generated_rs.
- (Opcional) --apex genera artefactos de configuración de seguridad y orquestación.
- (Opcional) --services genera un esqueleto de aplicación de Rust de inicio rápido.
- (opcional) -p borra los directorios existentes generados (como generated_rs y, si corresponde, apex, configs o services) antes de generar archivos nuevos.
- (opcional) --genrule genera Android.bp genrules en lugar de código de Rust. Las genrules generan el código de Rust necesario sobre la marcha cuando se ejecuta m para evitar colocar artefactos generados bajo control de versión.
Se crea un directorio generated_rs que contiene un Android.bp y los archivos de middleware generados. Este directorio se organiza en subdirectorios que corresponden a los nombres completamente calificados de los paquetes de servicios definidos.

Control de dependencias

De forma predeterminada, VSIDLC genera código solo para el catálogo principal, no para los catálogos de dependencias. Si tu catálogo usa tipos o unidades de servicio definidos en otros catálogos, especifica la ruta de acceso a cada catálogo de dependencia con la marca -d:

vsidlc -c path_to_catalog -o output_directory -d dep1_path -d dep2_path ...

Debes proporcionar rutas de acceso para todo el gráfico de dependencias, incluidas las dependencias transitivas (dependencias de dependencias). Por ejemplo, supón que tienes el siguiente árbol de dependencias del catálogo:

Ejemplo de árbol de dependencias de VSIDLC

Figura 2: Ejemplo de árbol de dependencias de VSIDLC.

Para generar el middleware de cada catálogo del árbol, debes ejecutar los siguientes comandos:

Catálogo objetivo	Dependencias	Comando
Catálogo principal de SDV	N/A	`vsidlc -o ./generated -c ./path/to/sdv_core_catalog`
Catálogo de diagnósticos	Catálogo principal de SDV	`vsidlc -o ./generated -c ./path/to/diagnostics_catalog -d ./path/to/sdv_core_catalog`
Catálogo de SOME/IP	Catálogo de diagnósticos, catálogo principal de SDV	`vsidlc -o ./generated -c ./path/to/someip_catalog -d ./path/to/diagnostics_catalog -d ./path/to/sdv_core_catalog`
Catálogo de OEM	Catálogo de diagnóstico, catálogo de SOMEIP y catálogo de SDV Core (de forma transitiva)	`vsidlc -o ./generated -c ./path/to/oem_catalog -d ./path/to/someip_catalog -d ./path/to/diagnostics_catalog -d ./path/to/sdv_core_catalog`

Da formato al resultado de Rust

De forma predeterminada, VSIDL usa rustfmt para dar formato al resultado de Rust. Para que el valor predeterminado funcione correctamente, configura la variable de entorno $ANDROID_BUILD_TOP o las variables de entorno RUSTFMT_PATH y RUSTFMT_TOML_PATH. Para cambiar el formato predeterminado que genera Rust, usa la opción --rust-formatter con pretty-please o none:

Para cambiar el formato de resultado al crate prettyplease, usa el valor pretty-please:

vsidlc -c path_to_catalog -o output_directory -p --rust-formatter pretty-please

Para cambiar el formato de salida a ninguno, usa el valor none:

vsidlc -c path_to_catalog -o output_directory -p --rust-formatter none

¿Qué sigue?

Después de generar el middleware, consulta Implementa tu lógica empresarial.