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

Cada dependência expõe um arquivo Android.mk ao build. Eles são importados com o comando import-module (link em inglês). Esse comando pesquisa arquivos Android.mk com o caminho fornecido nos diretórios de importação do build (conforme configurado por import-add-path) e expõe os módulos definidos para serem usados no build. Por exemplo, caso o aplicativo defina libapp.so e use cURL, seu arquivo Android.mk deverá incluir o seguinte:

include $(CLEAR_VARS)
LOCAL_MODULE := libapp
LOCAL_SRC_FILES := app.cpp
LOCAL_SHARED_LIBRARIES := curl
include $(BUILD_SHARED_LIBRARY)

# If you don't need your project to build with NDKs older than r21, you can omit
# this block.
ifneq ($(call ndk-major-at-least,21),true)
    $(call import-add-path,$(NDK_GRADLE_INJECTED_IMPORT_PATH))
endif

$(call import-module,prefab/curl)

O import-add-path explícito só é necessário ao usar NDKs anteriores a r21. Na versão r21 e mais recentes, o NDK_GRADLE_INJECTED_IMPORT_PATH vai ser adicionado automaticamente aos caminhos de importação.

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.