Se você não conhece o Bazel, comece com o tutorial Como criar 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 do repositório
android_ndk_repository
.
Pré-requisitos
Confira se você instalou o SDK do Android e o NDK.
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 mais informações sobre a regra android_ndk_repository
, consulte a entrada do Build
Encyclopedia.
Se você estiver usando uma versão recente do Android NDK (r22 e mais recentes), use a
implementação de android_ndk_repository
pelo Starlark.
Siga as instruções no
README dele (em inglês).
Início rápido
Para criar o C++ para Android, basta adicionar dependências cc_library
às regras
android_binary
ou android_library
.
Por exemplo, considerando o seguinte arquivo BUILD
para 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:
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 origens Java, os arquivos de recursos e a
dependência em um destino cc_library
. Neste exemplo, MainActivity.java
carrega
o arquivo de 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 flag --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
os rótulos de platform
alvo, usando valores de restrição padrão para descrever seu dispositivo.
Por exemplo, para um dispositivo Android com um processador ARM de 64 bits, você definiria sua plataforma assim:
platform(
name = "android_arm64",
constraint_values = [
"@platforms//os:android",
"@platforms//cpu:arm64",
],
)
Cada platform
do Android precisa usar a restrição de SO
@platforms//os:android
. Para migrar a restrição de CPU, consulte 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 |
E, claro, para um APK de várias arquiteturas, você transmite vários rótulos, por
exemplo: --android_platforms=//:arm64,//:x86_64
(assumindo que você os definiu no
arquivo BUILD.bazel
de nível superior).
O Bazel não pode 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 anos ou menos | armeabi, armeabi-v7a, arm64-v8a, mips, mips64, x86, x86_64 |
17 anos ou mais | armeabi-v7a, arm64-v8a, x86, x86_64 |
Consulte a documentação do NDK para mais informações sobre essas ABIs.
APKs multiarquiteturas 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 flags a seguir para criar de acordo com um padrão C++:
Padrão C++ | Sinalização |
---|---|
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
autônomo 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 flags 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.