Questa pagina è stata tradotta dall'API Cloud Translation.

Generazione di istantanee VNDK

Uno snapshot VNDK è un insieme di librerie VNDK-core e VNDK-SP per una versione Android. È possibile aggiornare solo la partizione di sistema se system.img include lo snapshot VNDK corrispondente necessario a vendor.img .

Gli snapshot VNDK ufficiali vengono creati automaticamente sul server di build Android e archiviati in /prebuilts/vndk dell'albero dei sorgenti Android. Per scopi di sviluppo, puoi creare snapshot VNDK localmente. Gli snapshot VNDK sono supportati per le versioni arm, arm64, x86 e x86_64 TARGET_ARCH .

Costruire istantanee

Il server di build Android genera artefatti di build e file snapshot VNDK utilizzando i seguenti parametri di build e comandi di build.

Costruisci parametri

Il nome della destinazione della build è vndk . La configurazione della destinazione della build è mostrata di seguito.

`TARGET_PRODUCT`	`TARGET_ARCH`	`TARGET_ARCH_VARIANT`
`aosp_arm`	`arm`	`armv7-a-neon`
`aosp_arm64`	`arm64`	`armv8-a`
`aosp_x86`	`x86`	`x86`
`aosp_x86_64`	`x86_64`	`x86_64`

TARGET_PRODUCT=aosp_$(TARGET_ARCH)
TARGET_BUILD_VARIANT=user
TARGET_ARCH è uguale agli archi target Generic System Image (GSI) ( arm , arm64 , x86 , x86_64 ).
TARGET_ARCH_VARIANT . Per snapshot v28 (Android 9) e versioni successive, include le configurazioni più comuni elencate sopra.

Costruisci comandi

Per gli snapshot ufficiali, Android 9 e versioni successive includono una destinazione di esempio ( vndk ) in vndk.mk che crea e restituisce uno snapshot VNDK su $DIST_DIR . Il file ZIP dell'istantanea utilizza il formato android-vndk-$(TARGET_ARCH).zip . Per esempio:

lunch aosp_TARGET_ARCH-user
make -j vndk dist [BOARD_VNDK_VERSION=current]

Il server di build Android utilizza lo script build.sh per creare tutte le versioni Arch supportate con il seguente comando.

DIST_DIR=dist_dir development/vndk/snapshot/build.sh

Lo snapshot VNDK per una versione Android viene generato dal ramo di rilascio di quella versione.

Costruire localmente

Durante lo sviluppo, puoi creare snapshot VNDK da un albero di origine locale con i seguenti comandi.

Per creare tutte le architetture supportate contemporaneamente, eseguire il seguente script di build ( build.sh ).
```
cd $ANDROID_BUILD_TOP
development/vndk/snapshot/build.sh
```
Per creare uno specifico TARGET_ARCH , eseguire i seguenti comandi.
```
lunch aosp_TARGET_ARCH-user
m -j vndk dist
```

Il file android-vndk-$(TARGET_ARCH).zip corrispondente viene creato in $DIST_DIR .

File di istantanee

Uno snapshot VNDK include i seguenti file.

Variante del fornitore delle librerie condivise VNDK-core e VNDK-SP.
- Le librerie condivise LL-NDK non sono necessarie poiché sono compatibili con le versioni precedenti.
- Per i target a 64 bit, vengono create e incluse entrambe le librerie TARGET_ARCH e TARGET_2ND_ARCH .
L'elenco delle librerie VNDK-core, VNDK-SP, LL-NDK e VNDK-private si trova su [vndkcore|vndksp|llndk|vndkprivate].libraries.txt .
File di licenza.
module_paths.txt . Registra i percorsi dei moduli per tutte le librerie VNDK, necessari per verificare che i progetti GPL dispongano di sorgenti rilasciati in un determinato albero dei sorgenti Android.

Per un determinato file ZIP dello snapshot VNDK, android-vndk-$(TARGET_ARCH).zip , le librerie predefinite VNDK sono raggruppate in directory separate denominate arch-$(TARGET_ARCH)-$(TARGET_ARCH_VARIANT) in base al bitness ABI. Ad esempio, per android-vndk-arm64.zip , le librerie a 64 bit vengono posizionate in arch-arm64-armv8-a e le librerie a 32 bit vengono posizionate in arch-arm-armv8-a . L'esempio seguente mostra la struttura della directory per un file ZIP snapshot VNDK arm64 ( TARGET_ARCH=arm64 ) ( android-vndk-arm64.zip ).

Struttura della directory delle istantanee VNDK

Figura 1. Struttura della directory degli snapshot VNDK (esempio)

Creazione di snapshot dei fornitori

Android 11 supporta gli snapshot dei fornitori , che consentono di creare vendor.img indipendentemente dalla versione di Android nell'albero dei sorgenti. Uno snapshot VNDK predefinito contiene i file della libreria condivisa ( .so ) che possono essere installati sui dispositivi e quindi collegati dai binari C++ del fornitore in runtime. Per sfruttare lo snapshot VNDK, sono necessari elementi aggiuntivi come file di intestazione e flag esportati.

Per generare tali artefatti (insieme allo snapshot VNDK) da un albero di origine locale, utilizzare il comando seguente.

VNDK_SNAPSHOT_BUILD_ARTIFACTS=true development/vndk/snapshot/build.sh

Questo comando crea file android-vndk-$(TARGET_ARCH).zip in $DIST_DIR . L'esempio seguente è un file ZIP di snapshot VNDK arm64 con artefatti di build. I file in grassetto sono file appena aggiunti alla normale istantanea VNDK (mostrati nella Figura 1) e includono file JSON (che memorizzano cflags di ciascuna libreria) e tutti i file di intestazione esportati.

android-vndk-arm64.zip
├── arch-arm64-armv8-a
│   └── shared
│       ├── vndk-core  -> *.so files, *.json files
│       └── vndk-sp    -> *.so files, *.json files
├── arch-arm-armv8-a   -> (same as arch-arm64-armv8-a)
├── configs            -> *.libraries.txt, module_paths.txt, module_names.txt
├── include            -> exported header files (*.h, *.hh, etc.)
└── NOTICE_FILES       -> license txt files

Caricamento di istantanee VNDK

Gli snapshot VNDK vengono controllati nell'albero dei sorgenti in /prebuilts/vndk/v VER , dove VER è uguale alla versione dello snapshot VNDK (che segue la versione SDK della corrispondente versione Android). Ad esempio, lo snapshot VNDK di Android 8.1 ha la versione 27.

Utilizzando lo script update.py

Lo script update.py ( /development/vndk/snapshot/update.py ) automatizza il processo di aggiunta di uno snapshot VNDK precostruito all'albero di origine. Rileva automaticamente gli artefatti della build e compila in modo appropriato le proprietà associate nel Android.bp generato. Questo script esegue le seguenti attività:

In /prebuilts/vndk/v VER , utilizza repo start per creare un nuovo ramo Git.
Recupera e decomprime gli artefatti di creazione di snapshot VNDK.
Esegue gen_buildfiles.py per generare automaticamente i file di build ( Android.bp ).
Esegue check_gpl_license.py per verificare che le librerie predefinite concesse in licenza sotto la General Public License (GPL) dispongano di sorgenti rilasciati nell'albero dei sorgenti corrente.
Utilizza git commit per eseguire il commit di nuove modifiche.

Utilizzo di snapshot VNDK creati localmente

Puoi anche utilizzare snapshot VNDK creati localmente. Quando viene specificata l'opzione --local , lo script update.py recupera gli artefatti della build dello snapshot VNDK dalla directory locale specificata (invece del server di build Android) che contiene i file android-vndk-$(TARGET_ARCH).zip generati dallo development/vndk/snapshot/build.sh . Con l'opzione --local , lo script update.py salta i passaggi di controllo della licenza GPL e git commit .

Sintassi:

python update.py VER --local local_path

Comando di esempio per l'aggiornamento dello snapshot VNDK di Android 8.1 con artefatti di build locale in /path/to/local/dir :

python update.py 27 --local /path/to/local/dir

Esempio di struttura di directory di uno snapshot VNDK creato localmente:

prebuilts/vndk
├── v30
│   ├── arm64
│   │   ├── arch-arm64-armv8-a -> (prebuilt libs)
│   │   ├── arch-arm-armv8-a   -> (prebuilt libs)
│   │   ├── configs            -> (config files)
│   │   ├── include            -> (exported header files)
│   │   └── Android.bp         -> (VNDK modules with cflags)
│   ├── arm                    -> (same as above)
│   ├── x86_64                 -> (same as above)
│   ├── x86                    -> (same as above)
│   ├── common
│   │   ├── NOTICE_FILES       -> (license files)
│   │   └── Android.bp         -> (license file modules)
│   └── Android.bp             -> (*.libraries.30.txt modules)
└── (other VNDK versions)      -> (same as above)

Gli artefatti di compilazione locale vengono aggiunti automaticamente se gli artefatti sono stati creati con VNDK_SNAPSHOT_BUILD_ARTIFACTS=true .

Installazione di istantanee VNDK

L'immagine di sistema installa le librerie di snapshot VNDK in fase di compilazione utilizzando le informazioni in BOARD_VNDK_VERSION , PRODUCT_EXTRA_VNDK_VERSIONS e ro.vndk.version . Puoi controllare quali snapshot VNDK vengono installati dalle directory di snapshot VNDK predefinite (ad esempio, /prebuilts/vndk/v29 o /prebuilts/vndk/v30 ) utilizzando una delle seguenti opzioni.

Opzione 1: BOARD_VNDK_VERSION . Utilizzare i moduli snapshot per creare i moduli del fornitore corrente e installare solo i moduli snapshot richiesti per i moduli del fornitore.
Opzione 2: PRODUCT_EXTRA_VNDK_VERSIONS . Installa i moduli snapshot VNDK indipendentemente dai moduli del fornitore corrente. Questo installa gli snapshot VNDK predefiniti elencati in PRODUCT_EXTRA_VNDK_VERSIONS senza collegarli ad altri moduli in fase di compilazione.

Impostazione BOARD_VNDK_VERSION

BOARD_VNDK_VERSION mostra la versione VNDK che i moduli del fornitore attuale devono compilare. Se BOARD_VNDK_VERSION ha una versione di snapshot VNDK disponibile nella directory /prebuilts/vndk , viene installato lo snapshot VNDK indicato in BOARD_VNDK_VERSION . Se lo snapshot VNDK non è disponibile nella directory, si verifica un errore di compilazione.

La definizione di BOARD_VNDK_VERSION consente inoltre l'installazione dei moduli VNDK. I moduli del fornitore si collegano alla versione dello snapshot VNDK definita in BOARD_VNDK_VERSION in fase di compilazione (questo non crea i moduli VNDK correnti nell'origine del sistema). Quando si scarica l'albero completo dei sorgenti da un repository, sia i sorgenti del sistema che quelli del fornitore si basano sulla stessa versione di Android.

Impostazione PRODUCT_EXTRA_VNDK_VERSIONS

PRODUCT_EXTRA_VNDK_VERSIONS elenca le versioni VNDK aggiuntive da installare. Normalmente è sufficiente avere uno snapshot VNDK per la partizione del fornitore corrente. Tuttavia, in alcuni casi potrebbe essere necessario includere più snapshot in un'unica immagine di sistema. Ad esempio, GSI dispone di più snapshot per supportare più versioni di fornitori con un'unica immagine di sistema. Impostando PRODUCT_EXTRA_VNDK_VERSIONS , è possibile installare i moduli snapshot VNDK oltre alla versione VNDK in BOARD_VNDK_VERSION .

Se PRODUCT_EXTRA_VNDK_VERSIONS ha un elenco specifico di versioni, il sistema di compilazione cerca gli snapshot predefiniti dell'elenco delle versioni nella directory prebuilts/vndk . Se il sistema di compilazione individua tutti gli snapshot elencati, installa tali file di snapshot su ciascun VNDK APEX ( out/target/product/$(TARGET_DEVICE)/system_ext/apex/com.android.vndk.v VER . Le versioni mancanti generano un errore di build.

I moduli VNDK non si collegano ai moduli del fornitore in fase di compilazione ma possono essere utilizzati in fase di esecuzione se i moduli del fornitore nella partizione del fornitore richiedono una delle versioni VNDK installate. PRODUCT_EXTRA_VNDK_VERSIONS è valido solo se è definito BOARD_VNDK_VERSION .

PIATTAFORMA_VNDK_VERSIONE

PLATFORM_VNDK_VERSION definisce la versione VNDK per i moduli VNDK correnti nell'origine del sistema. Il valore viene impostato automaticamente:

Prima del rilascio, PLATFORM_VNDK_VERSION è impostato come PLATFORM_VERSION_CODENAME .
Al momento del rilascio, PLATFORM_SDK_VERSION viene copiato in PLATFORM_VNDK_VERSION .

Dopo il rilascio della versione Android, le librerie VNDK correnti vengono installate su VNDK APEX ( /system/apex/com.android.vndk.v VER ), dove VER è la versione archiviata in PLATFORM_VNDK_VERSION .

Quando BOARD_VNDK_VERSION è impostato su current , PLATFORM_VNDK_VERSION viene archiviato in ro.vndk.version , altrimenti BOARD_VNDK_VERSION viene archiviato in ro.vndk.version . PLATFORM_VNDK_VERSION è impostato sulla versione dell'SDK al rilascio di Android; prima del rilascio, il nome in codice Android alfanumerico viene utilizzato per PLATFORM_VNDK_VERSION .

Riepilogo delle impostazioni della versione VNDK

La tabella seguente riassume le impostazioni della versione VNDK.

Venditore Costruire	Asse Versione	SDK Pubblicazione	piattaforma Versione	Versione Proprietà	Installa la directory
Moduli VNDK attuali	`current`	Prima	`CODE_NAME`	`CODE_NAME`	`/system/apex/com.android.vndk.v CODE_NAME`
Moduli VNDK attuali	`current`	Dopo	`SDK_VER`	`SDK_VER`	`/system/apex/com.android.vndk.v SDK_VER`
Moduli snapshot predefiniti	`VNDK_VER` per l'istantanea	Prima o dopo	`CODE_NAME` o `SDK_VER`	`VNDK_VER`	`/system_ext/apex/com.android.vndk.v VNDK_VER`

Versione scheda ( BOARD_VNDK_VERSION ). Versione VNDK richiesta per la creazione dei moduli del fornitore. Impostato su current se i moduli del fornitore possono collegarsi ai moduli del sistema corrente.
Versione della piattaforma ( PLATFORM_VNDK_VERSION ). Versione VNDK creata dai moduli di sistema attuali. Costruito solo quando BOARD_VNDK_VERSION è uguale a corrente.
Proprietà della versione ( ro.vndk.version ). Proprietà che specifica la versione VNDK richiesta dai file binari e dalle librerie in vendor.img per l'esecuzione. Memorizzato in vendor.img in /vendor/default.prop .