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

A partir do Plug-in do Android para Gradle 4.0, 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 compilação nativo, mas seu sistema de compilação 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 ver uma documentação genérica de AAR e como integrá-la ao projeto, especialmente quando você quer usar o AAR como uma dependência local C/C++.
  • Adicionar dependências de build para ver informações sobre como adicionar dependências ao arquivo build.gradle, especialmente para dependências remotas.

Este documento se concentra em como configurar o sistema de compilação nativo e supõe que você já adicionou um AAR de dependência C/C++ ao ambiente de build do 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 compilação

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

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

Groovy

buildFeatures {
  prefab true
}

Kotlin

buildFeatures {
  prefab = true
}

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, o arquivo 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 será automaticamente vinculado ao libcurl.so durante a criação e o libcurl.so será 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 código a seguir ao bloco android do arquivo build.gradle do projeto da biblioteca:

Groovy


buildFeatures {
    prefabPublishing true
}

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

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

Kotlin


buildFeatures {
    prefabPublishing = true
}

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

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

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