Configura un IDE para el desarrollo de SDV

Android Studio for Platform (ASfP) es el entorno de desarrollo integrado (IDE) recomendado para el desarrollo de la plataforma de vehículos definidos por software (SDV) del SO Android Automotive (AAOS). ASfP admite todos los lenguajes que usa la plataforma de SDV de AAOS, incluido Rust para los paquetes de servicios de SDV.

En esta página, solo se explica la configuración específica de SDV. Para obtener más información sobre las funciones y los flujos de trabajo generales de ASfP, consulta Android Studio for Platform.

ASfP solo se ejecuta en Linux de 64 bits con CPUs x86-64. Puedes usarla en una estación de trabajo local de Linux o en la nube. Para obtener más información sobre la configuración de la nube, consulta Desarrollo en la nube.

Instala ASfP

ASfP tiene un tamaño de montón máximo predeterminado de 30 GB. La indexación de una confirmación de la plataforma usa mucha memoria, en especial cuando también ejecutas dispositivos Cuttlefish con varias VMs en la misma máquina. Mantén el alcance del proyecto en los directorios en los que trabajas y, si es necesario, ajusta el tamaño máximo del montón en la configuración de memoria de ASfP.

ASfP admite actualizaciones automáticas en el IDE. Para obtener más información, consulta Cómo actualizar Android Studio para la plataforma. Para obtener más información sobre cómo descargar e instalar ASfP y verificar los requisitos del sistema, consulta Instala Android Studio for Platform.

Crea un proyecto de SDV

Inicializa, sincroniza y compila tu confirmación de compra de SDV de AAOS antes de comenzar. Para obtener más información sobre cómo configurar la confirmación de la compra, consulta Ubicación del código y Descarga, compila y ejecuta.

Para crear un proyecto de SDV, sigue estos pasos:

  1. Crea un proyecto nuevo en ASfP y selecciona la raíz de tu implementación de AAOS SDV como la implementación del repositorio. Para obtener más información sobre los pasos del asistente, consulta Cómo crear o importar un proyecto.
  2. Después de que ASfP cree el proyecto, selecciona ASfP > Project > Open Config para abrir el archivo .asfp-project.
  3. Reemplaza el contenido del archivo por el siguiente ejemplo y, luego, establece repo en la ruta de acceso de tu confirmación de la compra:

    repo: /path/to/sdv_source
    lunch: sdv_core_cf-aosp_current-userdebug
    directories:
      include:
        -   system/software_defined_vehicle/samples
    other_languages:
      -   rust
    
  4. Actualiza lunch y directories para el área en la que trabajas. Para que la indexación y la sincronización sean rápidas, incluye solo los directorios que modificas de forma activa. En la siguiente tabla, se enumeran los destinos y directorios comunes de SDV:

    Enfoque de desarrollo de SDV lunch objetivo Recomendación: directories
    Paquetes de servicios de SDV sdv_core_cf-aosp_current-userdebug Tu catálogo de servicios y directorio de paquetes, como system/software_defined_vehicle/samples
    Integración de la plataforma principal de SDV sdv_core_cf-aosp_current-userdebug system/software_defined_vehicle/middleware, system/software_defined_vehicle/automotive_services, device/google/sdv
    Puerta de enlace de SDV en IVI de SDV sdv_ivi_cf-aosp_current-userdebug system/software_defined_vehicle/sdv_gateway, system/software_defined_vehicle/samples/sdv_gateway, packages/services/Car
    Display Safety on SDV Media sdv_media_har_cf-aosp_current-userdebug packages/services/display_safety, device/google/sdv_display_safety
    Seguridad de la pantalla en el IVI de SDV sdv_ivi_cf_ds-aosp_current-userdebug packages/apps/Car/DriverUI, packages/services/display_safety/service

    Si tu confirmación de la compra usa un manifiesto trunk_staging, reemplaza -aosp_current-userdebug por -trunk_staging-userdebug. Para explorar también el código de la plataforma nativa, agrega cpp a other_languages. Para obtener más información sobre todas las opciones de configuración, consulta Parámetros de configuración.

  5. Para aplicar los cambios, selecciona ASfP > Sync > Sync Project. Para obtener más información sobre los modos de sincronización (Full Sync, Partial Sync y No-Build Sync) y la exportación o importación de plantillas de .asfp-project que se pueden compartir para tu equipo, consulta Modos de sincronización y ventana de herramientas de Soong y Plantillas de proyectos que se pueden compartir (exportación e importación).

Implementa paquetes de servicios de SDV

ASfP incluye un complemento de SDV que implementa un APEX que contiene tus paquetes de servicios directamente en un dispositivo SDV en ejecución. El complemento está inhabilitado de forma predeterminada. Para usarlo, habilita el complemento de SDV en Settings > Plugins. Para obtener más información sobre el empaquetado de APEX, consulta Compila e implementa paquetes de servicios.

La forma en que implementes dependerá de si el APEX ya está en el dispositivo:

  • Si el APEX ya está instalado, puedes implementar los cambios directamente desde ASfP.
  • Si el APEX es nuevo, primero debes volver a compilar y reiniciar la imagen del sistema, o bien usar una imagen del sistema que incluya la clave que se usó para firmar el APEX. Luego, puedes realizar la implementación desde ASfP.

Para implementar un APEX de paquete de servicios, sigue estos pasos:

  1. Inicia tu dispositivo SDV con el complemento de Cuttlefish. Para obtener más información, consulta Cómo ejecutar dispositivos SDV en Cuttlefish.
  2. Abre el archivo apex/Android.bp de tu paquete de servicios y haz clic en el ícono Run en el medianil junto al bloque apex {.
  3. En el menú que se abre, selecciona Run 'Deploy APEX_NAME'. También puedes compilar el APEX sin implementarlo o cambiar la configuración de ejecución desde el mismo menú.

Cómo ejecutar dispositivos SDV en Cuttlefish

ASfP incluye un complemento de Cuttlefish que crea y ejecuta dispositivos locales de Cuttlefish. El complemento necesita el organizador de hosts de Cuttlefish. Si el organizador de hosts no está disponible, ASfP muestra instrucciones para configurarlo.

Para crear un dispositivo SDV, sigue estos pasos:

  1. Selecciona Herramientas > Administrador de dispositivos, haz clic en + y selecciona Crear dispositivo Cuttlefish.
  2. Para crear una configuración de varias VMs, selecciona From canonical configuration y crea o importa una configuración para tu configuración, como SDV Core con SDV IVI o SDV Media con SDV IVI para Display Safety. Para crear una sola VM, selecciona From local Android source tree checkout.

Para ver todas las pantallas de VM en una sola pantalla y acceder a opciones adicionales del dispositivo, usa la ventana de herramientas de Cuttlefish. Para abrirlo, selecciona el ícono ... en el panel lateral y selecciona Cuttlefish, o busca Cuttlefish en Help > Find Action. También puedes ver pantallas individuales en Running Devices. Como SDV Core se ejecuta sin una pantalla, usa Logcat y la Terminal para inspeccionarlo.

Depura y prueba

ASfP incluye un depurador LLDB integrado para el código de C++ y Rust. Para obtener más información sobre la depuración y las pruebas en ASfP, consulta Cómo depurar código de la plataforma, Cómo depurar código de Rust, Cómo probar código de la plataforma con atest y Cómo depurar destinos cc_test y rust_test en LLDB.

Cuando adjuntes el depurador a un paquete de servicios, adjúntalo al proceso que lo aloja. Los nombres de los procesos usan el formato <bundle_name>:<instance_name>, como OrchestratorSampleRustServiceBundle:sample-main-no-conditions. Con el siguiente comando, se enumeran los procesos que coinciden y sus ID de proceso:

adb shell ps -A | grep <bundle_name>

Para obtener más información sobre los flujos de trabajo de depuración de SDV, como la conexión a varios dispositivos y la visualización de registros, consulta Depura SDV.

Editar archivos VSIDL

ASfP incluye el servidor de lenguaje VSIDL (vsidl-lsp). Para obtener más información sobre cómo configurar tu catálogo para el servidor de lenguaje, consulta Actualizaciones automáticas del catálogo y la integración de LSP. Cuando tu catálogo incluye un archivo CATALOG_UPDATE, el editor proporciona las siguientes funciones para los archivos .vsidl:

  • Validación en vivo: El editor destaca las palabras clave de VSIDL y muestra errores de sintaxis, tipos sin resolver y errores de validación de VSIDLC en la ventana Problems. Para obtener más información sobre las reglas de validación y sus códigos de error, consulta la especificación del lenguaje VSIDL.
  • Autocompletado y documentación: Puedes presionar Ctrl + barra espaciadora para obtener sugerencias de palabras clave, mensajes, servicios, temas y canales, y presionar Ctrl + Q para ver los comentarios de la documentación.
  • Navegación y formato: Puedes presionar Ctrl + B para ir a las definiciones de .vsidl o .proto, Alt + Mayúsculas + F7 para buscar referencias, Ctrl + F12 para ver la estructura del archivo y Ctrl + Alt + L para darle formato al archivo.

Agrega contexto de SDV para los asistentes de IA

ASfP incluye IA en Android Studio y un agente integrado con herramientas de compilación de Soong y atest. Como los archivos AGENTS.md se encuentran junto al código fuente en el control de versiones, puedes compartir las mismas reglas de SDV en el agente integrado de ASfP y en los agentes de programación basados en contenedores o en la línea de comandos que leen AGENTS.md. Cuando envías una instrucción con un archivo abierto en ASfP, el agente carga los archivos AGENTS.md desde el directorio de ese archivo y sus directorios superiores (a menos que un archivo GEMINI.md en el mismo directorio tenga prioridad), y puedes verificar los archivos activos en el panel Contexto del panel de chat en Archivos AGENTS.md. Para obtener más información, consulta Conoce Android Studio for Platform y Personaliza el agente con archivos AGENTS.md.

Las siguientes plantillas proporcionan puntos de partida para los flujos de trabajo en Crea un proyecto de SDV.

Paquetes de servicios de SDV

Coloca este archivo AGENTS.md en el directorio del paquete incluido en .asfp-project que contiene tus carpetas catalog/, services/ y apex/. Para obtener más información, consulta Genera middleware, Compila e implementa paquetes de servicios, Escribe un archivo de asignación de SOME/IP y Descripción general de la autorización de comunicaciones de SDV.

# AAOS SDV service bundle and VSIDL rules

## Build and test
- Initialize the build environment (`source build/envsetup.sh` and
  `lunch sdv_core_cf-aosp_current-userdebug`) when running outside ASfP, build
  modules with Soong (`m <module_name>`), and run tests with
  `atest <TestModuleName>` (`rust_test`, `rust_test_host`, `cc_test`, or
  `python_test_host`), without creating `Cargo.toml` files or running `cargo`
- In catalog `Android.bp` files, avoid `defaults` on `rust_protobuf` modules
  (`vsidlc` uses a regex parser), include each `.proto` file in at most one
  `rust_protobuf` target, and cover all catalog files in the first `filegroup`
  (`srcs: ["**/*"]`)

## Protobuf, VSIDL, and AUTOSAR SOME/IP mapping conventions
- Keep `.proto` files limited to `message`, `enum`, and RPC `service` schemas
  (using `sdv/vsidl/v1/annotations.proto` only for field size bounds), without
  topic names, channel names, or queue capacities
- Write `.vsidl` files in TextProto `VsidlEntry` syntax (`package: "..."`,
  `service_bundle { name: "..." }`, `publisher` or `subscriber` with `message`
  and `topic`, and `server` or `client` with `service` and `channel`, without
  `import` statements; RPCs support unary, client-streaming, and
  server-streaming methods, not bidirectional streaming), and isolate
  `some_ip_mapping` (`sdv_type_mapping` and `someip_service_mapping` for
  AUTOSAR electronic control unit (ECU) `ARXML` or `vsomeip` IDs) or
  `vhal_mapping` rules in dedicated `.vsidl` mapping files so core bundles stay
  transport-independent
- Use `PascalCase` for `service_bundle` names (avoiding Rust, C++, and Java
  keywords), `snake_case` for `build_cfg.target_name`, a globally unique
  lowercase `package` with at least four segments (`com.<org>.sdv.<domain>`;
  never reuse platform-reserved `com.android.sdv.*` or sample `com.sdv.*`
  names), and lowercase dash-case starting with a letter (no consecutive or
  trailing hyphens, underscores, or slashes) for `topic`, `channel`, and
  instance names
- Set `capacity` on every `publisher` to an even integer greater than or equal
  to 2, and pair every `subscriber` and RPC `client` with a matching
  `publisher` or `server` in the catalog or its `-d` dependency catalogs

## Code generation, authorization, and APEX packaging
- Export `ANDROID_BUILD_TOP`, check `CATALOG_UPDATE` for catalog-relative
  `output_path` (such as `".."`), `dependency_catalog_paths` (`-d`), and
  `vsidlc_gen_args`, and run `vsidlc -c <catalog_dir> -o <output_dir>`; omit
  `--services` from `vsidlc_gen_args` and avoid `-p` (`--purge`) or
  `regenerator` when `output_path` holds handwritten `services/` code
- Leave generated files in `generated_rs/`, `apex/`, and `configs/` unmodified,
  and implement Rust logic in `services/<ServiceBundleName>/src/main.rs` (even
  though the initial `vsidlc --services` skeleton header says not to edit; C++
  bundles do not use `vsidlc` C++ codegen and instead use
  `libsdv_lifecycle_client_cpp`, `libsdv_comms_cpp`, and
  `sdv_service_bundle_metadata` with `native_library_path: "lib64/lib<so>.so"`
  in `sdv_service_bundles_manifest.textproto`)
- Keep communications authorization `.textproto` policies in `configs/` aligned
  with every `publisher`, `subscriber`, `server`, and `client` unit (omitting
  `capacity` inside manual authorization `.textproto` `publisher` entries) so
  Service Discovery does not reject endpoints at runtime
- In Rust bundles, wait for publisher or RPC server availability before
  creating subscribers or clients, stop active tasks in `on_stop`, and run
  blocking work in `tokio::spawn_blocking`
- Generate Rust service bundle APEXes with `vsidlc --apex` (`updatable: true`,
  `min_sdk_version: "35"`, and `product_specific: true` in `apex/Android.bp`,
  never `vendor: true` or `soc_specific: true`, with matching unique `name` and
  `version` >= 1 in `apex_manifest.json`), and do not set
  `supportsRebootlessUpdate: true` or run `adb install --force-non-staged`
  because SDV APEX updates require a reboot

Puerta de enlace de SDV en IVI de SDV

Coloca este archivo AGENTS.md en el directorio del módulo del cliente de IVI o en system/software_defined_vehicle/sdv_gateway/. Para obtener más información, consulta Usa la puerta de enlace de SDV en IVI.

# AAOS SDV Gateway on SDV IVI rules

- Initialize the build environment (`source build/envsetup.sh` and
  `lunch sdv_ivi_cf-aosp_current-userdebug`) when running outside ASfP, build
  IVI modules with Soong (`m <module_name>`), and run verification with
  `atest <TestModuleName>`
- For native C or C++ IVI clients (including vehicle hardware abstraction layer
  (VHAL) integrations), link `libsdvgatewayclient`
  (`#include "libsdvgatewayclient.h"`) or `ISdvGateway`; for in-tree system Java
  or Kotlin clients, use `libsdvgatewayclient-java`,
  `libsdvgatewayclient-java-sdk.stubs`, `libsdvgatewayclient-java-sdk`, and
  `com.android.sdv.gateway.client`
- Start the Binder thread pool before calling `ASDVGateway_Client_new`, and
  call `ASDVGateway_Client_initComms` (or `SdvGatewayClient.initComms`) before
  any service discovery, data tunnel, or RPC calls
- Check `ASDVGateway_Client_isRpcAvailable` or
  `ASDVGateway_Client_isProcessBoundToSdvRpcNetworkInterface` before opening
  RPC sockets on early boot, treat `ASDVGateway_StatusCode_OK` with null
  `ASDVGateway_RpcCredentials_t` as insecure `UNLOCKED` boot mode, and free
  non-null credentials with `ASDVGateway_Client_deleteRpcCredentials`
- Grant `sdv_gateway_client_domain(<domain>)` in SELinux (do not add
  `binder_use` on `/vendor` daemons, which violates Treble `neverallow`; add
  `group inet` on native init services, and `INTERNET` plus
  `CONNECTIVITY_USE_RESTRICTED_NETWORKS` privapp permissions for system Java
  RPC clients)

Seguridad de la pantalla

Coloca este archivo AGENTS.md en packages/services/display_safety/ o en el directorio de la app del tablero de instrumentos. Para obtener más información, consulta Comienza a usar Display Safety, Capa de abstracción de la plataforma de HAR, Cadena de herramientas de diseño de seguridad y DriverUI.

# AAOS Display Safety partner integration rules

- Display Safety spans two guest VMs with separate `lunch` targets: keep
  safety-critical telltales, gauges, camera views, chimes, and early-boot or
  fallback placeholders in the Rust high availability renderer (HAR) and safety
  monitor on SDV Media (`sdv_media_har_cf`), and build non-safety cluster UI on
  SDV IVI (`sdv_ivi_cf_ds`) using `ClusterHomeManager` (`Cluster2` rather than
  legacy `Cluster1`)
- Implement target OS and hardware subsystems (display, graphics, exterior view
  system (EVS) cameras, audio, user input, and vehicle signals) in a dedicated
  `har-platform-<target>` platform abstraction layer (PAL) crate implementing
  `har-platform-api` traits rather than modifying core `harry` framework crates,
  and verify PAL crates against the HAR platform test suite with `atest`
- Generate safety monitor configurations and telltale inspection artifacts from
  the serialized Automotive Design for Compose document and safety JSON mapping
  (`{"documents": [{"rootnode": "#...", "display_id": 1, "document_id": "...",`
  `"states": {"<signal>": "#<node_id>"}}]}`) using the safety design compiler
  rather than hardcoding telltale pixel coordinates
- Because the HAR display plane composites above Android IVI, ensure HAR clears
  the cluster viewport region to `alpha = 0.0` while valid `HeartbeatRequest`
  gRPC messages arrive from IVI, and set opaque pixels in custom HAR OpenGL ES
  surfaces to `alpha = 1.0` (`0xFF`)
- Initialize the build environment (`source build/envsetup.sh` and `lunch`) when
  running outside ASfP, integrate prebuilt cluster APKs into `sdv_ivi_cf_ds`
  through `DriverUIPrebuilt` (`overrides: ["DriverUIStubApp"]`), launch dual-VM
  Cuttlefish setups from ASfP or with `ds_toolkit launch`, pass `--user 0` to
  `adb shell am` cluster commands, and note that
  `adb shell dumpsys SurfaceFlinger` on SDV IVI inspects only Android layers
  rather than the overlying HAR plane