A partire dal 2026, per allinearci al nostro modello di sviluppo trunk stabile e garantire la stabilità della piattaforma per l'ecosistema, pubblicheremo il codice sorgente su AOSP nel secondo e nel quarto trimestre. Per compilare e contribuire ad AOSP, utilizza android-latest-release. Il branch del manifest android-latest-release farà sempre riferimento alla release più recente pubblicata su AOSP. Per saperne di più, consulta la sezione Modifiche ad AOSP.

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

Crea ed esegui il deployment di bundle di servizi

Dopo aver creato il middleware e scritto il codice personalizzato, puoi eseguire il deployment dei bundle di servizi come file APEX.

Crea i file di configurazione SDV:

Ruggine

Genera i file di configurazione SDV eseguendo:
```
vsidlc -c /path/to/catalog -o /path/to/output --apex
```
L'esecuzione di vsidlc con il flag --apex genera automaticamente tutti i file di configurazione necessari, tra cui:
- Manifest APEX (apex_manifest.json)
- Manifest dei metadati SDV (sdv_service_bundles_manifest.textproto)
- Configurazione del linker (linker.config.json)
- Contesti dei file SELinux (file_contexts)
- Chiavi pubbliche e private (.avbpubkey e .pem)
- Dichiarazioni di autorizzazione e configurazioni di orchestrazione
- Un file Android.bp che definisce tutti i moduli Soong necessari.
Puoi trovare le configurazioni generate in:
```
/path/to/output/apex/
```
e,
```
/path/to/output/configs/
```

C++

Crea un file manifest dei metadati SDV, service_bundle.manifest.textproto con questi campi di metadati di esecuzione essenziali:
- Nome del servizio in base alle convenzioni di denominazione
- Rappresentazione intera e stringa della versione del bundle di servizi
- Percorso della libreria creata in precedenza
La preparazione dei metadati essenziali del bundle di servizi è obbligatoria per il packaging e il deployment del bundle di servizi.

Nota: il nome del pacchetto non è obbligatorio nel file manifest; viene invece estratto dal nome del pacchetto.
```
# proto-file: //system/software_defined_vehicle/core_services/service_bundles_registry/proto/sdv_service_bundles_manifest.proto
# proto-message: SdvServiceBundleManifestEntry

# SDV service bundle metadata definition with mandatory fields.
sdv_service_bundle_metadata {
  # Service bundle name.
  name: "ServiceBundleName"
  # Service bundle integer version.
  version_number: 42
  # Service bundle version as a string.
  version_name: "42.alpha"
  # Service bundle library path.
  native_library_path: "lib64/libservice_bundle.so"
}
```
Suggerimento: per visualizzare tutti i metadati, consulta Metadati del bundle di servizi.
Crea un nuovo file di configurazione del linker, linker.config.json:
```
{ "visible": true }
```
Crea un nuovo file apex_manifest.json con questi campi:
- Nome del pacchetto SDV univoco
- Versione di APEX
- Dipendenza dalle librerie di comunicazione SDV
Attenzione: per evitare conflitti e problemi di avvio, il nome del pacchetto APEX definito nel manifest APEX deve essere univoco in tutto il sistema SDV. Per assicurarti che il sistema di compilazione possa applicare questa regola, ti consigliamo di utilizzare lo stesso nome del modulo APEX in Android.bp.
```
{
  "name": "com.sdv.oem.apex_and_module_name",
  "version": 1,
  "requireNativeLibs": [
      "libsdv_comms_ctx_ffi.so",
      "libsdv_comms_dt_ffi.so",
      "libsdv_comms_id_ffi.so",
      "libsdv_comms_sd_ffi.so"
  ]
}
```
Crea una chiave pubblica, apex_name.apex_key.avbpubkey e una chiave privata, apex_name.apex_key.pem.
Crea un nuovo contesto di file SELinux apex_file_contexts.
```
(/.*)?    u:object_r:system_file:s0
```
Per saperne di più, consulta Contesto e categorie di sicurezza.

Crea target predefiniti in un file Android.bp nuovo o esistente:

// SDV manifest file prebuilt.
prebuilt_etc {
    name: "com.sdv.oem.apex_and_module_name.service_bundles_manifest",
    // The source filename of the manifest file.
    src: "service_bundle.manifest.textproto",
    // The name of the installed file needs be `sdv_service_bundles_manifest.textproto`.
    filename: "sdv_service_bundles_manifest.textproto",
    // Disable direct installation of the prebuilt to one of the partitions.
    // The manifest is used only inside of an apex.
    installable: false,
}
// The linker config to allow libraries for the apex to be linkable.
linker_config {
    name: "com.sdv.oem.apex_and_module_name. linker_config",
    src: "linker.config.json",
    // Disable direct installation of the prebuilt to one of the partitions.
    // The linker configuration is used only inside of an apex.
    installable: false,
}
// Key to be used for signing the apex.
apex_key {
    name: "apex_name.apex_key",
    public_key: "apex_name.apex_key.avbpubkey",
    private_key: "apex_name.apex_key.pem",
}

Crea un nuovo modulo APEX in un file Android.bp nuovo o esistente. Utilizza il nome del pacchetto SDV come nome del modulo APEX.

apex {
    name: "com.sdv.oem.apex_and_module_name",
    // The service bundle(s) to be included in the apex.
    native_shared_libs: [
        "libservice_bundle",
    ],
    prebuilts: [
        // SDV service bundles manifest file.
        "com.sdv.oem.apex_and_module_name.service_bundles_manifest",
        // Linker configuration to enable loading library from apex.
        "com.sdv.oem.apex_and_module_name.linker_config",
    ],
    // Json manifest file describes metadata of the APEX package.
    // The 'name' field from the JSON is used as a mounting point.
    manifest: "apex_manifest.json",
    // Setting the security contexts to files in this APEX bundle.
    file_contexts: "apex_file_contexts",
    // Name of the apex_key module that provides the private key to sign the APEX bundle.
    key: "apex_name.apex_key",
    // Mark apex as non-updatable for now, this might be revisited going forward.
    updatable: false,
    // Service bundle package is installed into /product partition.
    product_specific: true,
}

Per includere il nuovo makefile in un'immagine SDV, aggiungi il nuovo modulo APEX a the PRODUCT_PACKAGES in the makefile del prodotto. Ad esempio, vedi sdv_samples_core_services.mk.
Se utilizzi Cuttlefish, esegui il seguente comando per avviare un dispositivo:
```
sdv-cf create --instance_name=instance1
```

Esegui il bundle di servizi all'avvio del sistema:

# Grant root access.
adb root
# Launch the new service bundle.
adb shell sdv_service_bundle start \
  local-vm:com.sdv.oem.apex_and_module_name.ServiceBundleName/instance-1

Gestione delle dipendenze del bundle di servizi

In alcuni scenari, puoi utilizzare il collegamento statico delle dipendenze del bundle di servizi per ridurre le dimensioni di APEX e il footprint della memoria del bundle di servizi e per migliorare il tempo di avvio dei bundle di servizi. Questi scenari includono APEX con:

Bundle di servizi singoli
Diversi bundle di servizi che non condividono molte dipendenze comuni

Per abilitare il collegamento statico, aggiungi le seguenti proprietà alla definizione della libreria del bundle di servizi:

// Service bundle library.
rust_ffi_shared {
  // See rust_ffi_shared basic template.
  ...
  // uses static linking for the dependencies
  prefer_rlib: true,
  // needed to correctly resolve commstack deps
  ld_flags: ["-Wl,--no-as-needed"],
}

Per ogni situazione, ti consigliamo di verificare che il collegamento statico alle dipendenze comporti miglioramenti nel footprint della memoria e nei tempi di avvio dei bundle di servizi.

Debug (dumpsys)

Il gestore del ciclo di vita implementa l'interfaccia dumpsys. Questa interfaccia mostra all'utente l'elenco dei bundle di servizi nello stato created o started. L'interfaccia mostra anche l'FQIN o l'UID del processo del bundle di servizi.

Per visualizzare lo stato attuale e gli identificatori dei bundle di servizi, esegui:

# Grant root access.
adb root

# Execute dumpsys to see service bundles state
adb shell dumpsys google.sdv.lifecycle.ILifecycleManager/default

Passaggi successivi

Per eseguire automaticamente vsidlc e consentire al plug-in IDE di utilizzare le dipendenze, consulta Aggiornamenti automatici del catalogo e integrazione LSP.