Cette page a été traduite par l'API Cloud Translation.

Générer des instantanés VNDK

Un instantané VNDK est un ensemble de bibliothèques VNDK-core et VNDK-SP destinées à une version Android. Vous ne pouvez mettre à niveau la partition système que si le system.img inclut l'instantané VNDK correspondant nécessaire vendor.img

Les instantanés VNDK officiels sont créés automatiquement sur le serveur de compilation Android et vérifié dans /prebuilts/vndk de l'arborescence source Android. Pour vous pouvez créer des instantanés VNDK localement. Les instantanés VNDK sont compatible avec les types de TARGET_ARCH arm, arm64, x86 et x86_64.

Instantanés de compilation

Le serveur de compilation Android génère des artefacts de compilation et des fichiers d'instantané VNDK à l'aide des paramètres et commandes de compilation suivants.

Paramètres de compilation

Le nom de la cible de compilation est vndk. Configuration de la cible de compilation comme illustré ci-dessous.

`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 est identique à une image système générique (GSI) arches cibles (arm, arm64, x86, x86_64).
TARGET_ARCH_VARIANT Pour Snapshot v28 (Android 9) ou version ultérieure, inclut les configurations courantes mentionnées ci-dessus.

Commandes de compilation

Pour les photos instantanées officielles, Android 9 ou version ultérieure inclut un exemple de cible (vndk) dans vndk.mk qui crée et génère un VNDK ; sur $DIST_DIR. Le fichier d'instantané ZIP utilise le format android-vndk-$(TARGET_ARCH).zip Exemple :

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

Le serveur de compilation Android utilise Script build.sh permettant de créer toutes les architectures compatibles à l'aide de la commande suivante.

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

L'instantané VNDK d'une version d'Android est généré à partir de l'API version de sortie.

Compiler en local

Pendant le développement, vous pouvez créer des instantanés VNDK à partir d'une arborescence source locale avec les commandes suivantes.

Pour compiler toutes les arches compatibles en même temps, exécutez le script de compilation suivant (build.sh).
```
cd $ANDROID_BUILD_TOP
development/vndk/snapshot/build.sh
```
Pour créer un TARGET_ARCH spécifique, exécutez la commande suivante : commandes.
```
lunch aosp_TARGET_ARCH-user
m -j vndk dist
```

Le fichier android-vndk-$(TARGET_ARCH).zip correspondant est créé. moins de $DIST_DIR.

Fichiers d'instantané

Un instantané VNDK inclut les fichiers suivants.

Variante fournisseur des bibliothèques partagées VNDK-core et VNDK-SP.
- Les bibliothèques partagées LL-NDK ne sont pas nécessaires, car elles sont rétrocompatibles.
- Pour les cibles 64 bits, TARGET_ARCH et Les bibliothèques TARGET_2ND_ARCH sont compilées et incluses.
Vous trouverez la liste des bibliothèques VNDK-core, VNDK-SP, LL-NDK et VNDK-privées [vndkcore|vndksp|llndk|vndkprivate].libraries.txt
Fichiers de licence
module_paths.txt Enregistre les chemins d'accès aux modules pour tous les VNDK qui est nécessaire pour vérifier que les projets GPL disposent de sources publiée dans une arborescence source Android donnée.

Pour un fichier ZIP d'instantané VNDK donné, android-vndk-$(TARGET_ARCH).zip, les bibliothèques prédéfinies VNDK sont regroupés dans des répertoires distincts nommés arch-$(TARGET_ARCH)-$(TARGET_ARCH_VARIANT) selon l'ABI ou d'une minceur. Par exemple, pour android-vndk-arm64.zip, les bibliothèques 64 bits sont placés sous arch-arm64-armv8-a, et les bibliothèques 32 bits sont placé sous arch-arm-armv8-a. L'exemple ci-dessous illustre structure de répertoires pour un VNDK arm64 (TARGET_ARCH=arm64) fichier ZIP de l'instantané (android-vndk-arm64.zip).

Structure des répertoires des instantanés VNDK

Figure 1 : Structure du répertoire des instantanés VNDK (exemple)

Compiler pour les instantanés de fournisseurs

Compatible avec Android 11 fournisseur instantanés, qui vous permettent de créer des vendor.img indépendamment la version d'Android dans l'arborescence source. Un instantané VNDK par défaut contient fichiers de bibliothèque partagée (.so) pouvant être installés sur les appareils et puis liés à partir des binaires C++ du fournisseur dans l'environnement d'exécution. Pour compiler contre l'instantané VNDK, vous avez besoin d'artefacts supplémentaires, tels que des fichiers d'en-tête et options exportées.

Pour générer ces artefacts (ainsi que l'instantané VNDK) à partir d'une source locale utilisez la commande suivante.

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

Cette commande crée des fichiers android-vndk-$(TARGET_ARCH).zip sous $DIST_DIR L'exemple ci-dessous est un fichier ZIP d'instantanés VNDK VNDK arm64 à l'aide d'artefacts de compilation. Les fichiers en gras sont des fichiers récemment ajoutés au fichier VNDK normal. (cf. Figure 1) et incluez des fichiers JSON (qui stockent cflags de chaque bibliothèque) et tous les fichiers d'en-tête exportés.

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

Importer des instantanés VNDK

Les instantanés VNDK sont vérifiés dans l'arborescence source sous /prebuilts/vndk/vVER, où VER correspond à la version de l'instantané VNDK. (qui suit la version du SDK de la version Android correspondante). Pour par exemple, l'instantané VNDK Android 8.1 est de version 27.

Utiliser le script update.py

Script update.py (/development/vndk/snapshot/update.py) automatise le processus de en ajoutant un instantané VNDK prédéfini à l'arborescence source. Il détecte automatiquement de créer des artefacts et de renseigner les propriétés associées de manière appropriée dans le a généré Android.bp. Ce script effectue les tâches suivantes:

Dans /prebuilts/vndk/vVER, utilise repo start pour créer une branche Git.
Récupère et décompresse les artefacts de compilation de l'instantané VNDK.
Exécute gen_buildfiles.py pour générer automatiquement les fichiers de compilation (Android.bp).
Exécute check_gpl_license.py pour vérifier les bibliothèques prédéfinies sous licence en vertu de la licence publique générale (GPL, General Public License) ont des sources publiées en l'arborescence source actuelle.
Utilise git commit pour valider les nouvelles modifications.

Utiliser des instantanés VNDK créés localement

Vous pouvez également utiliser des instantanés VNDK créés localement. Lorsque le --local est spécifiée, le script update.py récupère l'instantané VNDK des artefacts de compilation à partir du répertoire local spécifié (au lieu du répertoire serveur de compilation) contenant les fichiers android-vndk-$(TARGET_ARCH).zip généré à partir de development/vndk/snapshot/build.sh. Avec l'attribut l'option --local, le script update.py ignore les instructions vérification des licences et git commit étapes.

Syntaxe:

python update.py VER --local local_path

Exemple de commande pour mettre à jour l'instantané VNDK Android 8.1 avec un build local artefacts dans /path/to/local/dir:

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

Exemple de structure de répertoire d'un instantané VNDK créé localement:

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)

Les artefacts de compilation locaux sont ajoutés automatiquement s'ils ont été compilés avec VNDK_SNAPSHOT_BUILD_ARTIFACTS=true

Installer des instantanés VNDK

L'image système installe les bibliothèques d'instantanés VNDK au moment de la compilation à l'aide de informations dans BOARD_VNDK_VERSION, PRODUCT_EXTRA_VNDK_VERSIONS et ro.vndk.version. Vous pouvez contrôler les instantanés VNDK à installer à partir du VNDK prédéfini des répertoires d'instantanés (par exemple, /prebuilts/vndk/v29 ou /prebuilts/vndk/v30) de l'une des façons suivantes.

Option 1:BOARD_VNDK_VERSION. Utilisez les modules d'instantanés afin de créer les modules du fournisseur actuel et d'installer uniquement modules d'instantanés requis pour les modules du fournisseur.
Option 2:PRODUCT_EXTRA_VNDK_VERSIONS. Installez les modules d'instantanés VNDK quels que soient les modules des fournisseurs actuels. Cette commande installe les instantanés VNDK prédéfinis répertoriés dans PRODUCT_EXTRA_VNDK_VERSIONS sans les associer à d'autres modules au moment de la compilation.

Définir BOARD_VNDK_VERSION

BOARD_VNDK_VERSION indique la version du VNDK de ce fournisseur actuel modules nécessaires à la compilation. Si BOARD_VNDK_VERSION comporte un la version d'instantané VNDK disponible dans le répertoire /prebuilts/vndk, L'instantané VNDK indiqué dans BOARD_VNDK_VERSION est installé. Si l'instantané VNDK n'est pas disponible dans le répertoire, une erreur de compilation se produit.

Définir BOARD_VNDK_VERSION permet également aux modules VNDK d'être installés. Les modules du fournisseur sont associés à la version de l'instantané VNDK définie dans BOARD_VNDK_VERSION au moment de la compilation (il ne s'agit pas modules VNDK dans la source système). Lorsque vous téléchargez l'arborescence source complète depuis dans un dépôt, les sources du système et des fournisseurs sont basées sur le même de sortie.

Définir PRODUCT_EXTRA_VNDK_VERSIONS

PRODUCT_EXTRA_VNDK_VERSIONS indique les versions supplémentaires du VNDK à installés. En règle générale, il suffit d'avoir un instantané VNDK pour le fichier actuel la partition des fournisseurs. Cependant, dans certains cas, vous devrez peut-être inclure plusieurs des instantanés dans une seule image système. Par exemple, le GSI a plusieurs instantanés à prendre en charge plusieurs versions de fournisseurs avec une seule image système. Par paramètre PRODUCT_EXTRA_VNDK_VERSIONS, vous pouvez installer l'instantané VNDK. modules en plus de la version du VNDK dans BOARD_VNDK_VERSION.

Si PRODUCT_EXTRA_VNDK_VERSIONS a une liste spécifique de versions, le système de compilation recherche des instantanés prédéfinis de la liste des versions dans prebuilts/vndk. Si le système de compilation localise tous les instantanés, il installe ces fichiers d'instantané dans chaque VNDK APEX (out/target/product/$(TARGET_DEVICE)/system_ext/apex/com.android.vndk.vVER, Les versions manquantes génèrent une erreur de compilation.

Les modules VNDK ne sont pas associés aux modules du fournisseur au moment de la compilation, mais peuvent être utilisé au moment de l'exécution si les modules du fournisseur dans la partition du fournisseur nécessitent l'un des les versions de VNDK installées. PRODUCT_EXTRA_VNDK_VERSIONS est valide uniquement si BOARD_VNDK_VERSION est défini.

PLATFORM_VNDK_VERSION

PLATFORM_VNDK_VERSION définit la version du VNDK pour le VNDK actuel modules dans la source système. La valeur est définie automatiquement:

Avant la sortie, PLATFORM_VNDK_VERSION est défini sur PLATFORM_VERSION_CODENAME
Lors de la publication, PLATFORM_SDK_VERSION est copié sur PLATFORM_VNDK_VERSION

Une fois la version d'Android publiée, les bibliothèques VNDK actuelles sont installé dans VNDK APEX (/system/apex/com.android.vndk.vVER), où VER est la version stockée dans PLATFORM_VNDK_VERSION

Lorsque BOARD_VNDK_VERSION est défini sur current, le PLATFORM_VNDK_VERSION est stocké dans ro.vndk.version. sinon BOARD_VNDK_VERSION est stocké dans ro.vndk.version PLATFORM_VNDK_VERSION est défini sur Version du SDK disponible lors du lancement d'Android avant la sortie, les caractères alphanumériques Android nom de code est utilisé pour PLATFORM_VNDK_VERSION.

Récapitulatif des paramètres de version de VNDK

Le tableau récapitule les paramètres de la version du VNDK.

Conception du fournisseur	Version du tableau	Version du SDK	Version de la plate-forme	Propriété de la version	Installer le répertoire
Modules VNDK actuels	`current`	Avant	`CODE_NAME`	`CODE_NAME`	`/system/apex/com.android.vndk.vCODE_NAME`
Modules VNDK actuels	`current`	Après	`SDK_VER`	`SDK_VER`	`/system/apex/com.android.vndk.vSDK_VER`
Modules d'instantanés prédéfinis	`VNDK_VER` pour l'instantané	Avant ou après	`CODE_NAME` ou `SDK_VER`	`VNDK_VER`	`/system_ext/apex/com.android.vndk.vVNDK_VER`

Version du Board (BOARD_VNDK_VERSION). VNDK version requise pour la compilation des modules du fournisseur. Défini sur current si les modules des fournisseurs peuvent être associés aux modules système actuels.
Version de la plate-forme (PLATFORM_VNDK_VERSION). Version du VNDK créée par les modules système actuels. Créé uniquement lorsque BOARD_VNDK_VERSION correspond à la valeur actuelle.
Propriété Version (ro.vndk.version). Propriété spécifiant la version du VNDK dont les binaires et les bibliothèques du fournisseur.img ont besoin exécuter. Stocké dans le vendor.img à /vendor/default.prop