Como usar o kit de desenvolvimento nativo do Android com o Bazel

<ph-0-0>

Se você não tem experiência com o Bazel, comece com o tutorial Como criar para o Android com o Bazel.

Visão geral

Ele pode ser executado em várias configurações de build diferentes, incluindo várias que usam o conjunto de ferramentas do Native Development Kit (NDK). Isso significa que as regras cc_library e cc_binary normais podem ser compiladas para Android diretamente no Bazel. O Bazel faz isso usando a regra de repositório android_ndk_repository.

Pré-requisitos

Verifique se você instalou o SDK e o NDK do Android.

Para configurar o SDK e o NDK, adicione o seguinte snippet ao WORKSPACE:

android_sdk_repository(
    name = "androidsdk", # Required. Name *must* be "androidsdk".
    path = "/path/to/sdk", # Optional. Can be omitted if `ANDROID_HOME` environment variable is set.
)

android_ndk_repository(
    name = "androidndk", # Required. Name *must* be "androidndk".
    path = "/path/to/ndk", # Optional. Can be omitted if `ANDROID_NDK_HOME` environment variable is set.
)

Para saber mais sobre a regra android_ndk_repository, consulte a entrada Build Encyclopedia.

Se você estiver usando uma versão recente do Android NDK (r22 e mais recentes), use a implementação do Starlark de android_ndk_repository. Siga as instruções no README dele (em inglês).

Início rápido

Para criar C++ para Android, basta adicionar dependências cc_library às suas regras android_binary ou android_library.

Por exemplo, considerando o seguinte arquivo BUILD de um app Android:

# In <project>/app/src/main/BUILD.bazel

cc_library(
    name = "jni_lib",
    srcs = ["cpp/native-lib.cpp"],
)

android_library(
    name = "lib",
    srcs = ["java/com/example/android/bazel/MainActivity.java"],
    resource_files = glob(["res/**/*"]),
    custom_package = "com.example.android.bazel",
    manifest = "LibraryManifest.xml",
    deps = [":jni_lib"],
)

android_binary(
    name = "app",
    deps = [":lib"],
    manifest = "AndroidManifest.xml",
)

Esse arquivo BUILD resulta no seguinte gráfico de destino:

Resultados de exemplo

Figura 1. Gráfico de build do projeto Android com dependências da cc_library.

Para criar o app, basta executar:

bazel build //app/src/main:app

O comando bazel build compila os arquivos Java, os arquivos de recursos do Android e as regras cc_library e empacota tudo em um APK:

$ zipinfo -1 bazel-bin/app/src/main/app.apk
nativedeps
lib/armeabi-v7a/libapp.so
classes.dex
AndroidManifest.xml
...
res/...
...
META-INF/CERT.SF
META-INF/CERT.RSA
META-INF/MANIFEST.MF

O Bazel compila todas as cc_libraries em um único arquivo de objeto compartilhado (.so), direcionado à ABI armeabi-v7a por padrão. Para mudar isso ou criar para várias ABIs ao mesmo tempo, consulte a seção sobre como configurar a ABI de destino.

Exemplo de configuração

Este exemplo está disponível no repositório de exemplos do Bazel.

No arquivo BUILD.bazel, três destinos são definidos com as regras android_binary, android_library e cc_library.

O destino de nível superior android_binary cria o APK.

O destino cc_library contém um único arquivo de origem C++ com uma implementação de função JNI:

#include <jni.h>
#include <string>

extern "C"
JNIEXPORT jstring

JNICALL
Java_com_example_android_bazel_MainActivity_stringFromJNI(
        JNIEnv *env,
        jobject /* this */) {
    std::string hello = "Hello from C++";
    return env->NewStringUTF(hello.c_str());
}

O destino android_library especifica as fontes Java, os arquivos de recursos e a dependência de um destino cc_library. Neste exemplo, MainActivity.java carrega o arquivo do objeto compartilhado libapp.so e define a assinatura do método para a função JNI:

public class MainActivity extends AppCompatActivity {

    static {
        System.loadLibrary("app");
    }

    @Override
    protected void onCreate(Bundle savedInstanceState) {
       // ...
    }

    public native String stringFromJNI();

}

Como configurar a ABI de destino

Para configurar a ABI de destino, use a sinalização --android_platforms da seguinte maneira:

bazel build //:app --android_platforms=comma-separated list of platforms

Assim como a flag --platforms, os valores transmitidos para --android_platforms são as etiquetas dos destinos platform, usando valores de restrição padrão para descrever o dispositivo.

Por exemplo, para um dispositivo Android com um processador ARM de 64 bits, você definiria sua plataforma da seguinte maneira:

platform(
    name = "android_arm64",
    constraint_values = [
        "@platforms//os:android",
        "@platforms//cpu:arm64",
    ],
)

Cada platform do Android precisa usar a restrição @platforms//os:android do SO. Para migrar a restrição de CPU, confira este gráfico:

Valor da CPU Plataforma
armeabi-v7a @platforms//cpu:armv7
arm64-v8a @platforms//cpu:arm64
x86 @platforms//cpu:x86_32
x86_64 @platforms//cpu:x86_64

Além disso, é claro, para um APK de várias arquiteturas, você passa vários rótulos, por exemplo: --android_platforms=//:arm64,//:x86_64 (supondo que você os tenha definido no arquivo BUILD.bazel de nível superior).

O Bazel não consegue selecionar uma plataforma Android padrão, então ela precisa ser definida e especificada com --android_platforms.

Dependendo da revisão do NDK e do nível da API do Android, as seguintes ABIs estão disponíveis:

Revisão do NDK Interfaces binárias de aplicativo (ABIs, na sigla em inglês)
16 e inferior armeabi, armeabi-v7a, arm64-v8a, mips, mips64, x86, x86_64
A partir de 17 anos armeabi-v7a, arm64-v8a, x86, x86_64

Consulte a documentação do NDK para mais informações sobre essas ABIs.

Os APKs multi-ABI não são recomendados para builds de lançamento porque aumentam o tamanho do APK, mas podem ser úteis para builds de desenvolvimento e controle de qualidade.

Como selecionar um padrão C++

Use as seguintes flags para criar de acordo com um padrão C++:

C++ padrão Flag
C++98 Padrão, sem necessidade de sinalização
C++11 --cxxopt=-std=c++11
C++14 --cxxopt=-std=c++14
C++17 --cxxopt=-std=c++17

Exemplo:

bazel build //:app --cxxopt=-std=c++11

Leia mais sobre como transmitir flags do compilador e do vinculador com --cxxopt, --copt e --linkopt no Manual do usuário.

As flags do compilador e do vinculador também podem ser especificadas como atributos em cc_library usando copts e linkopts. Exemplo:

cc_library(
    name = "jni_lib",
    srcs = ["cpp/native-lib.cpp"],
    copts = ["-std=c++11"],
    linkopts = ["-ldl"], # link against libdl
)

Como criar um cc_library para Android sem usar android_binary

Para criar um cc_binary ou cc_library independente para Android sem usar um android_binary, use a flag --platforms.

Por exemplo, supondo que você tenha definido plataformas Android em my/platforms/BUILD:

bazel build //my/cc/jni:target \
      --platforms=//my/platforms:x86_64

Com essa abordagem, toda a árvore de build é afetada.

Essas sinalizações podem ser colocadas em uma configuração bazelrc (uma para cada ABI), em project/.bazelrc:

common:android_x86 --platforms=//my/platforms:x86

common:android_armeabi-v7a --platforms=//my/platforms:armeabi-v7a

# In general
common:android_<abi> --platforms=//my/platforms:<abi>

Em seguida, para criar um cc_library para x86, por exemplo, execute:

bazel build //my/cc/jni:target --config=android_x86

Em geral, use esse método para destinos de baixo nível (como cc_library) ou quando você sabe exatamente o que está criando. Conte com as transições de configuração automáticas de android_binary para destinos de alto nível em que você espera criar vários destinos que não controla.