Gerando instantâneos do VNDK

Um snapshot do VNDK é um conjunto de bibliotecas VNDK-core e VNDK-SP para uma versão do Android. Você só poderá atualizar a partição do sistema se o system.img incluir o snapshot do VNDK correspondente necessário ao vendor.img .

Os snapshots oficiais do VNDK são criados automaticamente no servidor de compilação do Android e verificados em /prebuilts/vndk da árvore de origem do Android. Para fins de desenvolvimento, você pode criar snapshots do VNDK localmente. Os snapshots VNDK são compatíveis com os sabores arm, arm64, x86 e x86_64 TARGET_ARCH .

Construindo instantâneos

O servidor de build do Android gera artefatos de build e arquivos de snapshot do VNDK usando os parâmetros e comandos de build a seguir.

Parâmetros de construção

O nome do destino de compilação é vndk . A configuração do destino de compilação é mostrada abaixo.

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 é igual aos arcos de destino da imagem genérica do sistema (GSI) ( arm , arm64 , x86 , x86_64 ).
  • TARGET_ARCH_VARIANT . Para snapshot v28 (Android 9) e superior, inclui configurações populares listadas acima.

Comandos de construção

Para snapshots oficiais, o Android 9 e versões posteriores incluem um destino de amostra ( vndk ) em vndk.mk que cria e gera um snapshot VNDK para $DIST_DIR . O arquivo ZIP de instantâneo usa o formato android-vndk-$(TARGET_ARCH).zip . Por exemplo:

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

O servidor de compilação do Android usa o script build.sh para criar todos os tipos de arch suportados com o comando a seguir.

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

O snapshot do VNDK para uma versão do Android é gerado a partir do branch de lançamento dessa versão.

Construindo localmente

Durante o desenvolvimento, você pode criar snapshots do VNDK a partir de uma árvore de origem local com os comandos a seguir.

  • Para construir todos os arcos suportados de uma vez, execute o seguinte script de construção ( build.sh ).
    cd $ANDROID_BUILD_TOP
development/vndk/snapshot/build.sh
  • Para construir um TARGET_ARCH específico, execute os comandos a seguir.
    lunch aosp_TARGET_ARCH-user
m -j vndk dist

O arquivo android-vndk-$(TARGET_ARCH).zip correspondente é criado em $DIST_DIR .

Arquivos de instantâneo

Um snapshot do VNDK inclui os arquivos a seguir.

  • Variante do fornecedor de bibliotecas compartilhadas VNDK-core e VNDK-SP.
    • As bibliotecas compartilhadas LL-NDK não são necessárias porque são compatíveis com versões anteriores.
    • Para destinos de 64 bits, as bibliotecas TARGET_ARCH e TARGET_2ND_ARCH são construídas e incluídas.
  • A lista de bibliotecas VNDK-core, VNDK-SP, LL-NDK e VNDK-private está em [vndkcore|vndksp|llndk|vndkprivate].libraries.txt .
  • Arquivos de licença.
  • module_paths.txt . Registra os caminhos dos módulos para todas as bibliotecas VNDK, o que é necessário para verificar se os projetos GPL têm fontes lançadas em uma determinada árvore de fontes do Android.

Para um determinado arquivo ZIP de snapshot do VNDK, android-vndk-$(TARGET_ARCH).zip , as bibliotecas pré-construídas do VNDK são agrupadas em diretórios separados chamados arch-$(TARGET_ARCH)-$(TARGET_ARCH_VARIANT) de acordo com o número de bits da ABI. Por exemplo, para android-vndk-arm64.zip , as bibliotecas de 64 bits são colocadas em arch-arm64-armv8-a e as bibliotecas de 32 bits são colocadas em arch-arm-armv8-a . O exemplo abaixo mostra a estrutura de diretórios de um arquivo ZIP de snapshot VNDK arm64 ( TARGET_ARCH=arm64 ) ( android-vndk-arm64.zip ).

Estrutura de diretório de instantâneos VNDK
Figura 1. Estrutura de diretórios de snapshots do VNDK (exemplo)

Criando snapshots para fornecedores

O Android 11 oferece suporte a snapshots de fornecedores , que permitem criar vendor.img independentemente da versão do Android na árvore de origem. Um snapshot padrão do VNDK contém os arquivos de biblioteca compartilhada ( .so ) que podem ser instalados em dispositivos e depois vinculados a partir de binários C++ do fornecedor em tempo de execução. Para criar esse snapshot do VNDK, você precisa de artefatos adicionais, como arquivos de cabeçalho e sinalizadores exportados.

Para gerar esses artefatos (juntamente com o snapshot do VNDK) a partir de uma árvore de origem local, use o comando a seguir.

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

Este comando cria arquivos android-vndk-$(TARGET_ARCH).zip em $DIST_DIR . O exemplo abaixo é um arquivo ZIP de snapshot arm64 VNDK com artefatos de construção. Os arquivos em negrito são arquivos recém-adicionados ao snapshot normal do VNDK (mostrados na Figura 1) e incluem arquivos JSON (que armazenam cflags de cada biblioteca) e todos os arquivos de cabeçalho exportados.

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

Fazendo upload de instantâneos do VNDK

Os snapshots do VNDK são verificados na árvore de origem em /prebuilts/vndk/v VER , onde VER é igual à versão do snapshot do VNDK (que segue a versão do SDK da versão correspondente do Android). Por exemplo, o snapshot VNDK do Android 8.1 tem a versão 27.

Usando o script update.py

O script update.py ( /development/vndk/snapshot/update.py ) automatiza o processo de adição de um snapshot VNDK pré-construído à árvore de origem. Ele detecta automaticamente artefatos de construção e preenche adequadamente as propriedades associadas no Android.bp gerado. Este script executa as seguintes tarefas:

  1. Em /prebuilts/vndk/v VER , usa repo start para criar uma nova ramificação Git.
  2. Busca e descompacta artefatos de construção de snapshot do VNDK.
  3. Executa gen_buildfiles.py para gerar automaticamente os arquivos de compilação ( Android.bp ).
  4. Executa check_gpl_license.py para verificar se as bibliotecas pré-construídas licenciadas sob a Licença Pública Geral (GPL) têm fontes lançadas na árvore de fontes atual.
  5. Usa git commit para confirmar novas alterações.

Usando snapshots do VNDK criados localmente

Você também pode usar snapshots do VNDK criados localmente. Quando a opção --local é especificada, o script update.py busca artefatos de build de snapshot do VNDK no diretório local especificado (em vez do servidor de build do Android) que contém os arquivos android-vndk-$(TARGET_ARCH).zip gerados a partir do development/vndk/snapshot/build.sh . Com a opção --local , o script update.py ignora a verificação da licença GPL e as etapas git commit .

Sintaxe:

python update.py VER --local local_path

Comando de exemplo para atualizar o snapshot VNDK do Android 8.1 com artefatos de compilação local em /path/to/local/dir :

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

Exemplo de estrutura de diretório de um snapshot do VNDK criado 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)
Os artefatos de construção local serão adicionados automaticamente se os artefatos tiverem sido construídos com VNDK_SNAPSHOT_BUILD_ARTIFACTS=true .

Instalando instantâneos do VNDK

A imagem do sistema instala bibliotecas de snapshots do VNDK no momento da compilação usando as informações em BOARD_VNDK_VERSION , PRODUCT_EXTRA_VNDK_VERSIONS e ro.vndk.version . Você pode controlar quais snapshots do VNDK são instalados a partir dos diretórios de snapshots do VNDK pré-construídos (por exemplo, /prebuilts/vndk/v29 ou /prebuilts/vndk/v30 ) usando uma das opções a seguir.

  • Opção 1: BOARD_VNDK_VERSION . Use os módulos de captura instantânea para construir os módulos do fornecedor atual e instale apenas os módulos de captura instantânea necessários para os módulos do fornecedor.
  • Opção 2: PRODUCT_EXTRA_VNDK_VERSIONS . Instale os módulos de snapshot do VNDK independentemente dos módulos do fornecedor atual. Isso instala os snapshots pré-construídos do VNDK listados em PRODUCT_EXTRA_VNDK_VERSIONS sem vinculá-los a quaisquer outros módulos no momento da compilação.

Configurando BOARD_VNDK_VERSION

BOARD_VNDK_VERSION mostra a versão do VNDK que os módulos do fornecedor atual devem construir. Se BOARD_VNDK_VERSION tiver uma versão de snapshot do VNDK disponível no diretório /prebuilts/vndk , o snapshot do VNDK indicado em BOARD_VNDK_VERSION será instalado. Se o snapshot do VNDK não estiver disponível no diretório, ocorrerá um erro de compilação.

Definir BOARD_VNDK_VERSION também permite que os módulos VNDK sejam instalados. Os módulos do fornecedor são vinculados à versão do snapshot do VNDK definida em BOARD_VNDK_VERSION no momento da compilação (isso não cria os módulos VNDK atuais na origem do sistema). Ao baixar a árvore de código-fonte completa de um repositório, as fontes do sistema e do fornecedor são baseadas na mesma versão do Android.

Configurando PRODUCT_EXTRA_VNDK_VERSIONS

PRODUCT_EXTRA_VNDK_VERSIONS lista as versões extras do VNDK a serem instaladas. Normalmente é suficiente ter um snapshot do VNDK para a partição do fornecedor atual. No entanto, em alguns casos, pode ser necessário incluir vários instantâneos em uma imagem do sistema. Por exemplo, o GSI possui vários instantâneos para suportar versões de vários fornecedores com uma imagem de sistema. Ao definir PRODUCT_EXTRA_VNDK_VERSIONS , você pode instalar os módulos de snapshot do VNDK além da versão do VNDK em BOARD_VNDK_VERSION .

Se PRODUCT_EXTRA_VNDK_VERSIONS tiver uma lista específica de versões, o sistema de compilação procurará instantâneos pré-construídos da lista de versões no diretório prebuilts/vndk . Se o sistema de compilação localizar todos os snapshots listados, ele instalará esses arquivos de snapshot em cada VNDK APEX ( out/target/product/$(TARGET_DEVICE)/system_ext/apex/com.android.vndk.v VER . Versões ausentes geram um erro de compilação.

Os módulos VNDK não são vinculados aos módulos do fornecedor no momento da compilação, mas podem ser usados ​​no tempo de execução se os módulos do fornecedor na partição do fornecedor exigirem uma das versões do VNDK instaladas. PRODUCT_EXTRA_VNDK_VERSIONS é válido somente se BOARD_VNDK_VERSION estiver definido.

PLATFORM_VNDK_VERSION

PLATFORM_VNDK_VERSION define a versão do VNDK para os módulos VNDK atuais na origem do sistema. O valor é definido automaticamente:

  • Antes do lançamento, PLATFORM_VNDK_VERSION é definido como PLATFORM_VERSION_CODENAME .
  • No lançamento, PLATFORM_SDK_VERSION é copiado para PLATFORM_VNDK_VERSION .

Após o lançamento da versão do Android, as bibliotecas VNDK atuais são instaladas no VNDK APEX ( /system/apex/com.android.vndk.v VER ), onde VER é a versão armazenada em PLATFORM_VNDK_VERSION .

Quando BOARD_VNDK_VERSION é definido como current , PLATFORM_VNDK_VERSION é armazenado em ro.vndk.version , caso contrário, BOARD_VNDK_VERSION é armazenado em ro.vndk.version . PLATFORM_VNDK_VERSION é definido para a versão do SDK quando o Android é lançado; antes do lançamento, o nome de código alfanumérico do Android é usado para PLATFORM_VNDK_VERSION .

Resumo das configurações da versão do VNDK

A tabela abaixo resume as configurações da versão do VNDK.

Fornecedor
Construir		 Quadro
Versão		 SDK
Liberar		 Plataforma
Versão		 Versão
Propriedade		 Diretório de instalação
Módulos VNDK atuais current Antes CODE_NAME CODE_NAME /system/apex/com.android.vndk.v CODE_NAME
Depois SDK_VER SDK_VER /system/apex/com.android.vndk.v SDK_VER
Módulos de snapshot pré-construídos VNDK_VER
para instantâneo		 Antes ou depois CODE_NAME
ou SDK_VER		 VNDK_VER /system_ext/apex/com.android.vndk.v VNDK_VER
  • Versão da placa ( BOARD_VNDK_VERSION ). Versão do VNDK que os módulos do fornecedor exigem para serem criados. Defina como current se os módulos do fornecedor puderem ser vinculados aos módulos atuais do sistema.
  • Versão da plataforma ( PLATFORM_VNDK_VERSION ). Versão do VNDK que os módulos atuais do sistema estão construindo. Construído somente quando BOARD_VNDK_VERSION é igual ao atual.
  • Propriedade de versão ( ro.vndk.version ). Propriedade que especifica a versão do VNDK que os binários e bibliotecas em vendor.img exigem para serem executados. Armazenado em vendor.img em /vendor/default.prop .