O Google tem o compromisso de promover a igualdade racial para as comunidades negras. Saiba como.

Esta página foi traduzida pela API Cloud Translation.

Gerar snapshots do VNDK

Um instantâneo do VNDK é um conjunto de bibliotecas VNDK-core e VNDK-SP para uma versão do Android. É possível fazer upgrade apenas da partição do sistema se a system.img inclui o snapshot do VNDK correspondente necessário para o vendor.img.

Os snapshots oficiais do VNDK são criados automaticamente no servidor de build do Android. e fez check-in em /prebuilts/vndk da árvore de origem do Android. Para para fins de desenvolvimento, você pode criar snapshots do VNDK localmente. Os snapshots de VNDK são compatível com as variações TARGET_ARCH arm, arm64, x86 e x86_64;

Criar snapshots

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 build

O nome do destino do build é vndk. A configuração de destino do build é 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 é o mesmo que a imagem genérica do sistema (GSI) arcos de destino (arm, arm64, x86, x86_64).
TARGET_ARCH_VARIANT: Para o snapshot v28 (Android 9) e mais recentes, inclui as configurações comuns listadas acima.

Comandos de build

Para snapshots oficiais, Android 9 e versões mais recentes inclui um destino de amostra (vndk) em vndk.mk que cria e gera um VNDK snapshot para $DIST_DIR. O arquivo ZIP do snapshot usa o formato android-vndk-$(TARGET_ARCH).zip: Exemplo:

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

O servidor de compilação do Android usa Script build.sh para criar toda a arquitetura compatível com o comando a seguir.

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

O snapshot do VNDK de uma versão do Android é gerado com base no de lançamento.

Criar localmente

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

Para criar todas as arquiteturas com suporte de uma só vez, execute o seguinte script de compilação: (build.sh).
```
cd $ANDROID_BUILD_TOP
development/vndk/snapshot/build.sh
```
Para criar um TARGET_ARCH específico, execute o seguinte: comandos
```
lunch aosp_TARGET_ARCH-user
m -j vndk dist
```

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

Arquivos de snapshot

Um snapshot do VNDK inclui os arquivos a seguir.

Variante do fornecedor das bibliotecas compartilhadas VNDK-core e VNDK-SP.
- As bibliotecas compartilhadas do LL-NDK não são necessárias porque têm compatibilidade com versões anteriores.
- Para destinos de 64 bits, tanto TARGET_ARCH quanto Bibliotecas TARGET_2ND_ARCH são criadas 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 do módulo para todos os VNDK , que é necessária para verificar se os projetos GPL têm fontes em uma determinada árvore de origem do Android.

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

Estrutura de diretórios de snapshots do VNDK

Figura 1. Estrutura de diretórios do snapshot do VNDK (exemplo)

Criar snapshots do fornecedor

O Android 11 oferece suporte fornecedor snapshots, que permitem criar vendor.img independentemente da a versão do Android na árvore de origem. Um snapshot padrão do VNDK contém as arquivos de biblioteca compartilhada (.so) que podem ser instalados nos dispositivos e e vinculados a partir de binários C++ do fornecedor durante a execução. Para desenvolver com base em esse snapshot do VNDK, você precisa de artefatos adicionais, como arquivos de cabeçalho e e as sinalizações exportadas.

Gerar esses artefatos (junto com o snapshot do VNDK) de uma fonte local use o comando a seguir.

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

Esse comando cria arquivos android-vndk-$(TARGET_ARCH).zip em $DIST_DIR. O exemplo abaixo é um arquivo ZIP de snapshot do VNDK arm64 com artefatos de versão. Os arquivos em negrito são arquivos adicionados recentemente ao VNDK normal. (mostrado 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

Fazer upload de snapshots do VNDK

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

Usar o script update.py

O script update.py (/development/vndk/snapshot/update.py) automatiza o processo de adicionando um snapshot do VNDK pré-criado à árvore de origem. Ele detecta automaticamente artefatos de build e preenche adequadamente as propriedades associadas na gerou Android.bp. Esse script executa as seguintes tarefas:

Em /prebuilts/vndk/vVER, usa repo start para criar uma nova ramificação do Git.
Busca e descompacta artefatos de compilação de snapshots do VNDK.
Executa gen_buildfiles.py para gerar automaticamente os arquivos de build Android.bp).
executa check_gpl_license.py para verificar as bibliotecas pré-criadas; licenciadas sob a Licença Pública Geral (GPL) têm fontes lançadas em árvore de origem atual.
Usa git commit para confirmar novas mudanças.

Usar snapshots do VNDK criados localmente

Também é possível usar snapshots do VNDK criados localmente. Quando a solicitação --local for especificada, o script update.py buscará o snapshot do VNDK artefatos de build do diretório local especificado (em vez do diretório local servidor de build) que tenha os arquivos android-vndk-$(TARGET_ARCH).zip gerado pelo development/vndk/snapshot/build.sh. Com o a opção --local, o script update.py ignora a GPL; verificação de licença e git commit etapas.

Sintaxe:

python update.py VER --local local_path

Exemplo de comando para atualizar o snapshot do VNDK do Android 8.1 com build local artefatos em /path/to/local/dir:

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

Exemplo de estrutura de diretórios 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 build locais serão adicionados automaticamente se os artefatos forem criados com VNDK_SNAPSHOT_BUILD_ARTIFACTS=true.

Instalar snapshots do VNDK

A imagem do sistema instala bibliotecas de snapshots do VNDK no tempo de build usando o informações em BOARD_VNDK_VERSION, PRODUCT_EXTRA_VNDK_VERSIONS e ro.vndk.version. É possível controlar quais snapshots do VNDK são instalados no VNDK pré-criado diretórios de snapshots (por exemplo, /prebuilts/vndk/v29 ou /prebuilts/vndk/v30) usando uma das opções a seguir.

Opção 1:BOARD_VNDK_VERSION. Use o módulos do snapshot para criar os módulos atuais do fornecedor e instalar apenas os módulos de snapshots 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 atuais do fornecedor. Isso instala os snapshots pré-criados do VNDK listados em PRODUCT_EXTRA_VNDK_VERSIONS sem vinculá-los a nenhum outro módulos no tempo de build.

Definir BOARD_VNDK_VERSION

BOARD_VNDK_VERSION mostra a versão do VNDK que o fornecedor atual. módulos necessários para a criação. Se BOARD_VNDK_VERSION tiver um versão do snapshot do VNDK disponível no diretório /prebuilts/vndk, o O snapshot do VNDK indicado em BOARD_VNDK_VERSION está 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 instalado. Os módulos do fornecedor têm um link com a versão do snapshot do VNDK definida em BOARD_VNDK_VERSION no tempo de build (não é criado módulos VNDK na origem do sistema). Ao fazer o download da árvore de origem completa do repositório, as fontes do sistema e do fornecedor são baseadas no mesmo sistema lançamento.

Definir PRODUCT_EXTRA_VNDK_VERSIONS

PRODUCT_EXTRA_VNDK_VERSIONS lista as versões extras do VNDK a serem instalado. Normalmente, ter um snapshot de VNDK é suficiente para o fornecedora. No entanto, em alguns casos, talvez seja necessário incluir vários snapshots em uma imagem do sistema. Por exemplo, a GSI tem vários snapshots oferecem suporte a várias versões de fornecedores com uma imagem do sistema. Por configuração PRODUCT_EXTRA_VNDK_VERSIONS, você pode instalar o snapshot do VNDK módulos, 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 build procura snapshots pré-criados da lista de versões no prebuilts/vndk. Se o sistema de build localizar todos os snapshots, ele instala esses arquivos de snapshot em cada APEX do VNDK out/target/product/$(TARGET_DEVICE)/system_ext/apex/com.android.vndk.vVER As versões ausentes geram um erro de build.

Os módulos VNDK não se vinculam aos módulos do fornecedor no tempo de compilação, mas podem ser usada no tempo de execução se os módulos do fornecedor na partição do fornecedor exigirem uma das as 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 o VNDK atual. módulos na origem do sistema. O valor é definido automaticamente:

Antes do lançamento, o PLATFORM_VNDK_VERSION é definido como PLATFORM_VERSION_CODENAME.
Na versão, PLATFORM_SDK_VERSION é copiado para PLATFORM_VNDK_VERSION.

Depois que a versão do Android for lançada, as bibliotecas VNDK atuais serão instalado no VNDK APEX (/system/apex/com.android.vndk.vVER), em que VER é a versão armazenada em PLATFORM_VNDK_VERSION

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

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

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

Criação do fornecedor	Versão da placa	Versão do SDK	Versão da plataforma	Propriedade da versão	Instalar diretório
Módulos do VNDK atuais	`current`	Antes	`CODE_NAME`	`CODE_NAME`	`/system/apex/com.android.vndk.vCODE_NAME`
Módulos do VNDK atuais	`current`	Depois	`SDK_VER`	`SDK_VER`	`/system/apex/com.android.vndk.vSDK_VER`
Módulos de snapshot pré-criados	`VNDK_VER` para snapshot	Antes ou depois	`CODE_NAME` ou `SDK_VER`	`VNDK_VER`	`/system_ext/apex/com.android.vndk.vVNDK_VER`

Versão do tabuleiro (BOARD_VNDK_VERSION). VNDK que os módulos do fornecedor exigem para a criação. Defina como current se os módulos do fornecedor podem ser vinculados aos módulos atuais do sistema.
Versão da plataforma (PLATFORM_VNDK_VERSION). Versão do VNDK que os módulos do sistema atuais estão criando. Criado apenas quando BOARD_VNDK_VERSION é igual a atual.
Propriedade da versão (ro.vndk.version). Propriedade que especifica a versão do VNDK que os binários e as bibliotecas emvendor.img exigem para correr. Armazenado no vendor.img em /vendor/default.prop.