Questa pagina è stata tradotta dall'API Cloud Translation.

Genera snapshot VNDK

Uno snapshot VNDK è un insieme di librerie VNDK-core e VNDK-SP per una release di Android. Puoi eseguire l'upgrade solo della partizione di sistema se system.img include lo snapshot VNDK corrispondente necessario per vendor.img.

Gli snapshot VNDK ufficiali vengono compilati automaticamente sul server di compilazione Android e sottoposti a check-in in /prebuilts/vndk della struttura ad albero del codice sorgente di Android. Per scopi di sviluppo, puoi creare snapshot VNDK localmente. Gli snapshot VNDK sono supportati per le versioni TARGET_ARCH arm, arm64, x86 e x86_64.

Crea snapshot

Il server di compilazione Android genera gli elementi di compilazione e i file di snapshot VNDK utilizzando i seguenti parametri di compilazione e comandi di compilazione.

Parametri di compilazione

Il nome del target di compilazione è vndk. La configurazione del target di compilazione è riportata 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 corrisponde alle architetture target (arm, arm64, x86, x86_64) dell'immagine di sistema generica (GSI).
TARGET_ARCH_VARIANT. Per lo snapshot v28 (Android 9) e versioni successive, include le configurazioni più diffuse elencate sopra.

Comandi di compilazione

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

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

Il server di compilazione Android utilizza lo script build.sh per compilare tutti i gusti arch supportati con il seguente comando.

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

Lo snapshot VNDK per una versione di Android viene generato dal ramo di release della versione.

Esegui il build in locale

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

Per compilare tutte le architetture supportate contemporaneamente, esegui il seguente script di compilazione (build.sh).
```
cd $ANDROID_BUILD_TOP
development/vndk/snapshot/build.sh
```
Per compilare un TARGET_ARCH specifico, esegui 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 snapshot

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 perché sono compatibili con le versioni precedenti.
- Per i target a 64 bit, vengono compilate e incluse entrambe le librerie TARGET_ARCH e TARGET_2ND_ARCH.
L'elenco delle librerie VNDK-core, VNDK-SP, LL-NDK e VNDK-private è disponibile all'indirizzo [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 abbiano le origini rilasciate in una determinata struttura ad albero di origine di Android.

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

Struttura della directory degli snapshot VNDK

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

Build per gli snapshot del fornitore

Android 11 supporta gli snapshot del fornitore, che ti consentono di compilare vendor.img indipendentemente dalla versione di Android nella struttura di origine. Uno snapshot VNDK predefinito contiene i file delle librerie condivise (.so) che possono essere installati sui dispositivi e poi collegati dai binari C++ del fornitore in fase di runtime. Per eseguire la compilazione in base a questo snapshot VNDK, sono necessari altri elementi, come file di intestazione e parametri esportati.

Per generare questi elementi (insieme allo snapshot VNDK) da un albero di origine locale, utilizza il seguente comando.

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 dello snapshot VNDK per arm64 con gli elementi di build. I file in grassetto sono i file appena aggiunti allo snapshot VNDK normale (mostrato in Figura 1) e includono file JSON (che memorizzano cflags di ogni 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

Carica gli snapshot VNDK

Gli snapshot VNDK vengono controllati nella struttura ad albero delle sorgenti in /prebuilts/vndk/vVER, dove /prebuilts/vndk/vVER è uguale alla versione dello snapshot VNDK (che segue la versione dell'SDK della release Android corrispondente).VER Ad esempio, lo snapshot VNDK di Android 8.1 ha la versione 27.

Utilizza lo script update.py

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

In /prebuilts/vndk/vVER, utilizza repo start per creare un nuovo ramo Git.
Recupera e decomprime gli elementi di compilazione dello snapshot VNDK.
Esegui gen_buildfiles.py per generare automaticamente i file di compilazione (Android.bp).
Esegue check_gpl_license.py per verificare che le librerie predefinite concesse in uso ai sensi della General Public License (GPL) abbiano sorgenti rilasciate nell'albero di origine corrente.
Utilizza git commit per applicare le nuove modifiche.

Utilizzare gli snapshot VNDK compilati localmente

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

Sintassi:

python update.py VER --local local_path

Comando di esempio per aggiornare lo snapshot VNDK di Android 8.1 con gli elementi della 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 compilato 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 elementi di compilazione locale vengono aggiunti automaticamente se sono stati compilati con VNDK_SNAPSHOT_BUILD_ARTIFACTS=true.

Installa gli snapshot VNDK

L'immagine di sistema installa le librerie di istantanee 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 degli snapshot VNDK precompilati (ad esempio /prebuilts/vndk/v29 o /prebuilts/vndk/v30) utilizzando una delle seguenti opzioni.

Opzione 1: BOARD_VNDK_VERSION. Utilizza i moduli snapshot per compilare i moduli del fornitore attuali e installa solo i moduli snapshot necessari per i moduli del fornitore.
Opzione 2: PRODUCT_EXTRA_VNDK_VERSIONS. Installa i moduli snapshot VNDK indipendentemente dai moduli del fornitore correnti. Vengono installati gli snapshot VNDK predefiniti elencati in PRODUCT_EXTRA_VNDK_VERSIONS senza collegarli ad altri moduli in fase di compilazione.

Imposta BOARD_VNDK_VERSION

BOARD_VNDK_VERSION mostra la versione VNDK necessaria per compilare i moduli dei fornitori attuali. Se BOARD_VNDK_VERSION ha una versione dello snapshot VNDK disponibile nella directory /prebuilts/vndk, lo snapshot VNDK indicato in BOARD_VNDK_VERSION è installato. Se lo snapshot VNDK non è disponibile nella directory, si verifica un errore di compilazione.

La definizione di BOARD_VNDK_VERSION consente inoltre di installare i moduli VNDK. I moduli del fornitore si collegano alla versione dello snapshot VNDK definita in BOARD_VNDK_VERSION al momento della compilazione (non vengono compilati i moduli VNDK attuali nel codice di sistema). Quando scarichi l'albero delle sorgenti completo da un repository, sia le sorgenti di sistema sia quelle del fornitore si basano sulla stessa release di Android.

Impostare PRODUCT_EXTRA_VNDK_VERSIONS

PRODUCT_EXTRA_VNDK_VERSIONS elenca le versioni VNDK aggiuntive da installare. In genere è sufficiente avere uno snapshot VNDK per la partizione del fornitore corrente. Tuttavia, in alcuni casi potresti dover includere più snapshot in un'immagine di sistema. Ad esempio, l'immagine di sistema generica ha più snapshot per supportare più versioni del fornitore con un'immagine di sistema. Impostando PRODUCT_EXTRA_VNDK_VERSIONS, puoi installare i moduli dello 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 precompilati dell'elenco di versioni nella directory prebuilts/vndk. Se il sistema di compilazione individua tutti gli snapshot elencati, installa i file di snapshot in ogni APEX VNDK (out/target/product/$(TARGET_DEVICE)/system_ext/apex/com.android.vndk.vVER). Le versioni mancanti generano un errore di compilazione.

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 BOARD_VNDK_VERSION è definito.

PLATFORM_VNDK_VERSION

PLATFORM_VNDK_VERSION definisce la versione VNDK per i moduli VNDK attuali nel codice di sistema. Il valore viene impostato automaticamente:

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

Dopo il rilascio della versione per Android, le attuali librerie VNDK vengono installate in VNDK APEX (/system/apex/com.android.vndk.vVER), dove VER è la versione memorizzata in PLATFORM_VNDK_VERSION.

Quando BOARD_VNDK_VERSION è impostato su current, PLATFORM_VNDK_VERSION viene memorizzato in ro.vndk.version, altrimenti BOARD_VNDK_VERSION viene memorizzato in ro.vndk.version. PLATFORM_VNDK_VERSION viene impostato sulla versione dell'SDK quando vengono rilasciate le release di Android. Prima della release, per PLATFORM_VNDK_VERSION viene utilizzato il nome in codice alfanumerico di Android.

Riepilogo delle impostazioni della versione VNDK

La tabella riassume le impostazioni della versione VNDK.

Build del fornitore	Scheda Versione	SDK Release	Versione piattaforma	Proprietà Version	Install Directory
Moduli VNDK attuali	`current`	Prima	`CODE_NAME`	`CODE_NAME`	`/system/apex/com.android.vndk.vCODE_NAME`
Moduli VNDK attuali	`current`	Dopo	`SDK_VER`	`SDK_VER`	`/system/apex/com.android.vndk.vSDK_VER`
Moduli di snapshot predefiniti	`VNDK_VER` per snapshot	Prima o dopo	`CODE_NAME` o `SDK_VER`	`VNDK_VER`	`/system_ext/apex/com.android.vndk.vVNDK_VER`

Versione della scheda (BOARD_VNDK_VERSION). Versione VNDK necessaria per la compilazione dei moduli del fornitore. Imposta su current se i moduli del fornitore possono collegarsi ai moduli di sistema attuali.
Versione piattaforma (PLATFORM_VNDK_VERSION). La versione VNDK di cui vengono eseguiti i build dei moduli di sistema attuali. Viene creato solo quando BOARD_VNDK_VERSION è uguale all'attuale.
Proprietà Version (ro.vndk.version). Proprietà che specifica la versione VNDK richiesta per l'esecuzione dei binari e delle librerie in vendor.img. Memorizzato in vendor.img in /vendor/default.prop.