Dependencias nativas con el complemento de Android para Gradle

Las bibliotecas AAR pueden contener dependencias nativas que el complemento de Android para Gradle puede consumir. AGP también puede producir AARs que expongan bibliotecas nativas para sus consumidores.

Cómo usar dependencias nativas

A partir de la versión 4.0 del complemento de Android para Gradle, es posible importar dependencias de C/C++ de AAR vinculadas a tu archivo build.gradle. Gradle las habilitará automáticamente para el sistema de compilación nativo, pero este debe estar configurado de manera tal que pueda usar las bibliotecas y los encabezados importados. Dado que las dependencias de C/C++ se distribuyen como AAR, puedes consultar los siguientes vínculos sobre AAR genéricos:

• En Cómo crear una biblioteca de Android, obtén documentación sobre los AAR genéricos y cómo integrarlos a tu proyecto, sobre todo cuando deseas usar AAR como una dependencia C/C++ local.
• En Cómo agregar dependencias de compilación, obtén información para agregar dependencias a tu archivo build.gradle, en especial las remotas.

Este documento se centra en cómo configurar un sistema de compilación nativo y supone que ya agregaste una dependencia C/C++ de AAR al entorno de compilación de Gradle de tu proyecto.

Dependencias nativas en AAR

Las dependencias de AAR de tus módulos de Gradle pueden exponer bibliotecas nativas para que las use tu aplicación. Dentro del archivo AAR, el directorio de prefab contiene un paquete Prefab, que incluye los encabezados y las bibliotecas de la dependencia nativa.

Cada dependencia puede exponer como máximo un paquete Prefab, que comprenda uno o más módulos. Un módulo de Prefab es una biblioteca única, que puede ser una biblioteca compartida, estática o solo de encabezado.

Para poder usar las bibliotecas, los nombres de paquete y módulo deben ser conocidos. Por convención, el nombre del paquete coincidirá con el nombre del artefacto de Maven y el nombre del módulo coincidirá con el de la biblioteca de C/C++, pero esto no es obligatorio. Consulta la documentación de la dependencia para determinar qué nombres usa.

Configuración del sistema de compilación

Complemento de Gradle para Android 4.0 Complemento de Gradle para Android 4.1 y versiones posteriores

La función prefab debe estar habilitada en tu módulo de Gradle para Android.

Para ello, agrega lo siguiente al bloque de android del archivo build.gradle de tu módulo:

buildFeatures {
  prefab = true
}

buildFeatures {
  prefab true
}

De manera opcional, configura una versión en el archivo gradle.properties de tu proyecto:

android.prefabVersion=2.0.0

Por lo general, la versión predeterminada seleccionada en AGP se ajusta a tus necesidades. Solo debes seleccionar una versión diferente si hay un error que debes solucionar o una función nueva que te interesa.

CMake ndk-build

Cada dependencia expone un archivo Android.mk a tu compilación, el cual se importa con el comando import-module. Este comando busca archivos Android.mk con la ruta de acceso determinada dentro de los directorios de importación de la compilación (según lo configurado por import-add-path) y expone los módulos que define para su uso en tu compilación. Por ejemplo, si tu aplicación define libapp.so y usa cURL, tu archivo Android.mk debe incluir lo siguiente:

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)

Ten en cuenta que el elemento import-add-path explícito solo es necesario cuando se usan NDK antes de r21. A partir de la versión r21, NDK_GRADLE_INJECTED_IMPORT_PATH se agregará automáticamente a las rutas de acceso de importación.

app.cpp ahora puede usar #include "curl/curl.h", libapp.so se vinculará automáticamente con libcurl.so cuando se compile, y libcurl.so se incluirá con la app.

Cómo publicar bibliotecas nativas en AAR

La habilidad de crear AAR nativas se agregó por primera vez en AGP 4.1.

Para exportar tus bibliotecas nativas, agrega lo siguiente al bloque android del archivo build.gradle.kts de tu proyecto de 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"
    }
}

En este ejemplo, las bibliotecas mylibrary y myotherlibrary de tu ndk-build o compilación nativa externa de CMake se empaquetarán en el AAR que generó tu compilación, y cada una exportará los encabezados del directorio especificado a sus dependientes.