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

Las dependencias importadas desde un AAR se exponen a CMake mediante CMAKE_FIND_ROOT_PATH. Gradle establecerá automáticamente ese valor cuando se invoque CMake, por lo que, si tu compilación modifica esa variable, asegúrate de adjuntarla en lugar de asignarla.

Cada dependencia expone un paquete de archivo de configuración a tu compilación, el cual se importa con el comando find_package. Ese comando busca paquetes de archivos de configuración que coincidan con el nombre y la versión del paquete específico, y expone los destinos que define para su uso en tu compilación. Por ejemplo, si tu aplicación define libapp.so y usa cURL, tu CMakeLists.txt debe incluir lo siguiente:

add_library(app SHARED app.cpp)

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

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.