Dependências nativas com o Plug-in do Android para Gradle

As bibliotecas AAR podem conter dependências nativas que o Plug-in do Android para Gradle pode consumir. O AGP também é capaz de produzir AARs que expõem bibliotecas nativas aos consumidores.

Como usar dependências nativas

No Plug-in do Android para Gradle 4.0 e versões mais recentes, as dependências C/C++ podem ser importadas de AARs vinculados ao arquivo build.gradle. O Gradle disponibiliza essas opções automaticamente para o sistema de build nativo, mas esse sistema precisa ser configurado para usar as bibliotecas e os cabeçalhos importados. Como as dependências C/C++ são distribuídas como AARs, os links a seguir sobre AARs genéricos podem ser úteis:

• Como criar uma biblioteca do Android, para conferir uma documentação genérica de AAR e aprender a integrá-lo ao projeto, principalmente quando você quiser usar o AAR como uma dependência local de C/C++.
• Adicionar dependências de build, para ler informações sobre como adicionar dependências ao arquivo build.gradle, principalmente no caso de dependências remotas.

Este documento ensina como configurar o sistema de build nativo e supõe que você já adicionou um AAR de dependência C/C++ ao ambiente de build Gradle do seu projeto.

Dependências nativas em AARs

As dependências de AAR dos módulos do Gradle podem expor bibliotecas nativas para uso pelo seu aplicativo. Dentro do AAR, o diretório prefab contém um pacote Prefab, que inclui os cabeçalhos e bibliotecas da dependência nativa.

Cada dependência pode expor, no máximo, um pacote Prefab, que compreende um ou mais módulos. Um módulo Prefab é uma única biblioteca, que pode ser compartilhada, estática ou apenas de cabeçalho.

Os nomes do pacote e do módulo precisam ser conhecidos para que você possa usar as bibliotecas. Por convenção, o nome do pacote corresponderá ao do artefato Maven, e o nome do módulo corresponderá ao da biblioteca C/C++, mas isso não é obrigatório. Consulte a documentação da dependência para determinar quais nomes são usados.

Configuração do sistema de build

Plug-in do Android para Gradle 4.0 Plug-in do Android para Gradle 4.1 ou mais recente

O recurso prefab precisa estar ativado para seu módulo do Gradle para Android.

Para fazer isso, adicione o código abaixo ao bloco android do arquivo build.gradle do módulo:

buildFeatures {
  prefab = true
}

buildFeatures {
  prefab true
}

Como opção, configure uma versão no arquivo gradle.properties do projeto:

android.prefabVersion=2.0.0

Normalmente, a versão padrão selecionada do AGP atende às suas necessidades. Você só selecionará uma versão diferente se houver um bug que precise ser resolvido ou um novo recurso que você queira.

CMake ndk-build

As dependências importadas de um AAR são expostas ao CMake por CMAKE_FIND_ROOT_PATH (link em inglês). Esse valor será definido automaticamente pelo Gradle quando o CMake for invocado. Portanto, se o build modificar essa variável, anexe-a em vez de atribuí-la.

Cada dependência expõe um pacote config-file ao build (link em inglês). Elas são importadas com o comando find_package (link em inglês). Esse comando procura por pacotes config-file que correspondam ao nome do pacote e à versão fornecidos e expõe os destinos que ele define para serem usados no build. Por exemplo, caso o aplicativo defina libapp.so e use cURL, CMakeLists.txt precisará incluir o seguinte:

add_library(app SHARED app.cpp)

# Add these two lines.
find_package(curl REQUIRED CONFIG)
target_link_libraries(app curl::curl)

app.cpp agora pode #include "curl/curl.h", libapp.so. Portanto, ele é automaticamente vinculado ao libcurl.so durante a criação, e o libcurl.so é incluído no app.

Como publicar bibliotecas nativas em AARs

A capacidade de criar AARs nativos foi adicionada inicialmente no AGP 4.1.

Para exportar suas bibliotecas nativas, adicione o seguinte ao bloco android do arquivo build.gradle.kts do projeto da biblioteca:

buildFeatures {
    prefabPublishing = true
}

prefab {
    create("mylibrary") {
      headers = "src/main/cpp/mylibrary/include"
    }

    create("myotherlibrary") {
        headers = "src/main/cpp/myotherlibrary/include"
    }
}

buildFeatures {
    prefabPublishing true
}

prefab {
    mylibrary {
      headers "src/main/cpp/mylibrary/include"
    }

    myotherlibrary {
        headers "src/main/cpp/myotherlibrary/include"
    }
}

Neste exemplo, as bibliotecas mylibrary e myotherlibrary do ndk-build ou do build nativo externo do CMake vão ser empacotadas no AAR produzido pelo build, e cada uma exportará os cabeçalhos do diretório especificado para os dependentes.