Skip to content

Most visited

Recently visited

navigation

Cómo agregar código C y C++ a tu proyecto

Usando Android Studio 2.2 o una versión posterior con el complemento de Android para Gradle 2.2.0 o una versión posterior, puedes agregar el código C y C++ a tu app compilándolo en una biblioteca nativa que Gradle puede empaquetar con tu APK. Tu código Java puede llamar a funciones en tu biblioteca nativa a través de la interfaz nativa de Java (JNI). Si deseas obtener más información sobre el uso del framework de JNI, lee Sugerencias de JNI para Android.

La herramienta de compilación predeterminada de Android Studio para bibliotecas nativas es CMake. Android Studio también es compatible con ndk-build debido al gran número de proyectos existentes que usan el paquete de herramientas de compilación para compilar su código nativo. Si deseas importar una biblioteca existente de ndk-build en tu proyecto Android Studio, consulta la sección de configuración de Gradle para establecer vínculos con tu biblioteca nativa. Sin embargo, si creas una biblioteca nativa nueva, debes usar CMake.

En esta página se brinda la información que necesitas para establecer Android Studio con las herramientas de compilación necesarias, crear o configurar un proyecto para admitir el código nativo en Android, y compilar y ejecutar tu app.

Nota: Si en tu proyecto existente se usa la herramienta obsoleta ndkCompile, debes abrir tu archivo build.properties y eliminar la siguiente línea de código antes de vincular Gradle con tu biblioteca nativa:

// Remove this line
android.useDeprecatedNdk = true

Atención, usuarios experimentales de Gradle: consideren realizar la migración a la versión 2.2.0, o una posterior, del complemento y usar de CMake o ndk-build para compilar sus bibliotecas nativas si algo de lo siguiente se aplica en sus casos: en su proyecto nativo ya se usa CMake o ndk-build; tal vez prefieran usar una versión estable del sistema de compilación de Gradle; o tal vez deseen admitir herramientas de complemento, como CCache. De lo contrario, pueden continuar usando la versión experimental de Gradle y el complemento de Android.

Descargar el NDK y las herramientas de compilación

Para compilar y depurar el código nativo para tu app, necesitas los siguientes componentes:

Puedes instalar estos componentes usando SDK Manager:

  1. Desde un proyecto abierto, selecciona Tools > Android > SDK Manager en la barra de menú.
  2. Haz clic en la pestaña SDK Tools.
  3. Verifica los casilleros junto a LLDB, CMake y NDK, como se muestra en la figura 1.

    Figura 1: Instalación de LLDB, CMake y el NDK desde SDK Manager.

  4. Haz clic en Apply y luego en OK en el diálogo emergente.
  5. Cuando se complete la instalación, haz clic en Finish y luego en OK.

Crear un proyecto nuevo compatible con C y C++

Crear un proyecto nuevo compatible con código nativo es similar a crear cualquier otro proyecto de Android Studio, aunque hay algunos pasos adicionales:

  1. En la sección Configure your new project del asistente, marca la casilla de verificaciónInclude C++ Support.
  2. Haz clic en Next.
  3. Completa los otros campos y las siguientes secciones del asistente como de costumbre.
  4. En la sección Customize C++ Support del asistente, puedes personalizar tu proyecto con las siguientes opciones:
    • C++ Standard: usa la lista desplegable para seleccionar la estandarización de C++ que desees usar. Al seleccionar Toolchain Default, se usará la configuración predeterminada de CMake.
    • Exceptions Support: marca esta casilla si deseas habilitar la compatibilidad con el manejo de excepciones de C++. Si se habilita, Android Studio agrega la marca -fexceptions a cppFlags en tu archivo de nivel de módulo build.gradle, que Gradle pasa a CMake.
    • Runtime Type Information Support: marca esta casilla si deseas admitir RTTI. Si se habilita, Android Studio agrega el indicador -frtti a cppFlags en tu archivo de nivel de módulo build.gradle, que Gradle pasa a CMake.
  5. Haz clic en Finish.

Cuando Android Studio termine de crear tu proyecto nuevo, abre el subpanel Project del lado izquierdo de IDE y selecciona la vista de Android. Como se muestra en la figura 2, Android Studio agrega los grupos cpp y External Build Files:

    Figura 2: Grupos de vistas de Android para tus orígenes nativos y tus secuencias de comandos de compilación externa.

    Nota: La vista no refleja la jerarquía actual de archivos en el disco, pero en ella se agrupan archivos similares para simplificar la navegación de tu proyecto.

  1. En el grupo cpp puedes encontrar todos los archivos de origen nativos, encabezados y bibliotecas compiladas previamente que forman parte de tu proyecto. Para proyectos nuevos, Android Studio crea un ejemplo de archivo de origen de C++, native-lib.cpp y lo ubica en el directorio src/main/cpp/ de tu módulo de app. Este código de ejemplo proporciona una función simple de C++, stringFromJNI(), que muestra la string “Hello from C++”. Puedes aprender a agregar archivos de origen adicionales a tu proyecto en la sección sobre cómo Crear archivos de origen nativo nuevos.
  2. En el grupo External Build Files puedes encontrar secuencias de comandos de compilación para CMake o ndk-build. Así como los archivos build.gradle indican a Gradle la manera de compilar tu app, CMake y ndk-build requieren una secuencia de comandos de compilación para conocer la manera de compilar tu biblioteca nativa. Para proyectos nuevos, Android Studio crea una secuencia de comandos de CMake, CMakeLists.txt y la dispone en el directorio raíz del módulo. Puedes obtener más información sobre los contenidos de esta secuencia de comandos de compilación en la sección sobre cómo Crear una secuencia de comandos de compilación de CMake.

Generar y ejecutar la app de ejemplo

Cuando haces clic en Run ejecutar y luego ejecutar la app desde la barra de menú, Android Studio crea y lanza una app que muestra el texto “Hello from C++” en tu dispositivo o emulador de Android. En la siguiente información general se describen los eventos que tienen lugar para compilar y ejecutar el ejemplo de app:

  1. Gradle llama a tu secuencia de comandos de compilación externa, CMakeLists.txt.
  2. CMake sigue los comandos en la secuencia de comandos de compilación para compilar un archivo de origen de C++, native-lib.cpp, en una biblioteca de objetos compartidos y la llama libnative-lib.so. Luego, Gradle la empaqueta en el APK.
  3. Durante la ejecución, la MainActivity de la app carga la biblioteca nativa usando System.loadLibrary(). La función nativa de la biblioteca, stringFromJNI(), quedará disponible para la app.
  4. MainActivity.onCreate() llama a stringFromJNI(), que muestra “Hello from C++”, y la usa para actualizar la TextView.

Nota: Instant Run no es compatible con proyectos que usan código nativo. Android Studio inhabilita la característica de manera automática.

Si deseas verificar que Gradle empaquete la biblioteca nativa en el APK, puedes usar el analizador de APK:

  1. Selecciona Build > Analyze APK.
  2. Selecciona el APK del directorio app/build/outputs/apk/ y haz clic en OK.
  3. Como se muestra en la figura 3, puedes consultar libnative-lib.so en la ventana del analizador de APK en lib/<ABI>/.

    Figura 3: Ubicación de una biblioteca nativa mediante el Analizador de APK.

Sugerencia: Si deseas experimentar con otras apps de Android que usen código nativo, haz clic en File > New > Import Sample y selecciona un ejemplo de proyecto en la lista de Ndk.

Agregar código C y C++ a un proyecto existente

Si deseas agregar código nativo a un proyecto existente, sigue estos pasos:

  1. Crea archivos de origen nativos nuevos y agrégalos a tu proyecto de Android Studio.
    • Puedes omitir este paso si ya dispones de código nativo o si deseas importar una biblioteca nativa compilada previamente.
  2. Crea una secuencia de comandos de compilación de Cmake para compilar tu código fuente nativo en una biblioteca. También necesitas esta secuencia de comandos de compilación si realizas importaciones y vinculaciones en bibliotecas de plataforma o compiladas previamente.
    • Si dispones de una biblioteca nativa existente que ya tiene una secuencia de comandos de compilación CMakeLists.txt, o usa ndk-build e incluye una secuencia de comandos de compilación Android.mk, puedes omitir este paso.
  3. Vincula Gradle con tu biblioteca nativa proporcionando una ruta de acceso a tu archivo de secuencia de comandos de CMake o ndk-build. Gradle usa la secuencia de comandos para importar el código fuente a tu proyecto de Android Studio y empaquetar tu biblioteca nativa (el archivo SO) en el APK.

Una vez que configuras tu proyecto, puedes acceder a tus funciones nativas desde el código Java usando el framework JNI. Para crear y ejecutar tu app, simplemente haz clic en Run ejecutar y luego ejecutar la app desde la barra de menú. Gradle agrega tu proceso de compilación nativo externo como una dependencia para compilar, generar y empaquetar tu biblioteca nativa con tu APK.

Crear archivos de origen nativos nuevos

Para crear un directorio cpp/ con archivos de origen nativos nuevos en el conjunto de orígenes principal del módulo de tu app, procede de la siguiente manera:

  1. Abre el subpanel Project del lado izquierdo de IDE y selecciona la vista Project del menú desplegable.
  2. Dirígete a your-module > src, haz clic con el botón secundario en el directorio principal y selecciona New > Directory.
  3. Ingresa un nombre para el directorio (como cpp) y haz clic en OK.
  4. Haz clic con el botón secundario en el directorio que acabas de crear y selecciona New > C/C++ Source File.
  5. Ingresa un nombre para tu archivo de origen, como native-lib.
  6. En el menú desplegable Type, selecciona la extensión de archivo para tu archivo de origen, como .cpp.
    • Puedes agregar otros tipos de archivos al menú desplegable, como .cxx o .hxx, haciendo clic en Editar tipo de archivo . En el cuadro de diálogo C/C++ que aparecerá, selecciona otra extensión de archivo desde los menús desplegables de Source Extension y Header Extension y haz clic en OK.
  7. Si también deseas crear un archivo de encabezados, marca la casilla de verificación Create an associated header.
  8. Haz clic en OK.

Crear una secuencia de comandos de compilación de CMake

Si tus fuentes nativas aún no tienen una secuencia de comandos de compilación de CMake, debes crearte una e incluir los comandos correspondientes de CMake. Una secuencia de comandos de compilación de CMake un archivo de texto sin formato que debes llamar CMakeLists.txt. En esta sección se abarcan algunos comandos básicos que debes incluir en tu secuencia de comandos para indicar a CMake las fuentes que debe usar cuando se cree tu biblioteca nativa.

Nota: Si en tu proyecto se usa ndk-build, no debes crear una secuencia de comandos de compilación de CMake. Puedes vincular Gradle con tu biblioteca nativa proporcionando una ruta de acceso a tu archivo Android.mk.

Para crear un texto sin formato que puedas usar como secuencia de comandos de compilación de CMake, procede de la siguiente manera:

  1. Abre el subpanel Project del lado izquierdo de IDE y selecciona la vista Project del menú desplegable.
  2. Haz clic con el botón secundario en el directorio raíz de tu módulo y selecciona New > File.

    Nota: Puedes crear la secuencia de comandos de compilación en cualquier ubicación que desees. Sin embargo, cuando configuras la secuencia de comandos de compilación, las rutas de acceso de tus archivos de origen nativos y bibliotecas se relacionan con la ubicación de la secuencia de comandos de compilación.

  3. Ingresa “CMakeLists.txt” como nombre de archivo y haz clic en OK.

Ahora podrás configurar tu secuencia de comandos de compilación agregando los comandos de CMake. Para indicar a CMake que cree una biblioteca nativa desde el código fuente nativo, agrega los comandos cmake_minimum_required() y add_library() para tu secuencia de comandos de compilación:

# Sets the minimum version of CMake required to build your native library.
# This ensures that a certain set of CMake features is available to
# your build.

cmake_minimum_required(VERSION 3.4.1)

# Specifies a library name, specifies whether the library is STATIC or
# SHARED, and provides relative paths to the source code. You can
# define multiple libraries by adding multiple add.library() commands,
# and CMake builds them for you. When you build your app, Gradle
# automatically packages shared libraries with your APK.

add_library( # Specifies the name of the library.
             native-lib

             # Sets the library as a shared library.
             SHARED

             # Provides a relative path to your source file(s).
             src/main/cpp/native-lib.cpp )

Cuando agregas un archivo o una biblioteca de origen a tu secuencia de comandos de compilación de CMake usando add_library(), Android Studio también muestra archivos de encabezados asociados en la vista Project una vez que sincronizas tu proyecto. Sin embargo, para que CMake ubique tus archivos de encabezados durante el tiempo de compilación, debes agregar el comando include_directories() a tu secuencia de comandos de compilación de CMake y especificar la ruta de acceso para tus encabezados:

add_library(...)

# Specifies a path to native header files.
include_directories(src/main/cpp/include/)

El CMake de convención nombra el archivo de tu biblioteca de la siguiente manera:

liblibrary-name.so

Por ejemplo, si especificas “native-lib” como nombre para tu biblioteca compartida en la secuencia de comandos de compilación, CMake crea un archivo llamado libnative-lib.so. Sin embargo, cuando se cargue esta biblioteca en tu código Java, usa el nombre que especificaste en la secuencia de comandos de compilación de CMake:

static {
    System.loadLibrary(“native-lib”);
}

Nota: Si vuelves a nombrar o eliminar una biblioteca en la secuencia de comandos de tu compilación de CMake, debes limpiar tu proyecto para que Gradle aplique los cambios o elimine la versión anterior de la biblioteca de tu APK. Para limpiar tu proyecto, selecciona Build > Clean Project en la barra de menú.

Android Studio agrega automáticamente los archivos y encabezados de origen al grupo cpp en el subpanel Project. Usando varios comandos add_library(), puedes definir bibliotecas adicionales para CMake a fin de realizar la compilación desde otros archivos de origen.

Agregar API del NDK

El NDK de Android proporciona un conjunto de API y bibliotecas nativas que te pueden resultar útiles. Puedes usar cualquiera de estas API incluyendo las bibliotecas del NDK en el archivo de tu secuencia de comandos de CMakeLists.txt de tu proyecto.

Las bibliotecas del NDK previamente compiladas ya existen en la plataforma de Android, por lo cual no necesitas compilarlas ni empaquetarlas en tu APK. Debido a que las bibliotecas del NDK ya forman parte de la ruta de búsqueda de CMake, ni siquiera debes especificar la ubicación de la biblioteca en tu instalación local del NDK; solo debes proporcionar a CMake el nombre de la biblioteca que desees usar y vincularla con tu propia biblioteca nativa.

Agrega el comando find_library() a tu secuencia de comandos de compilación de CMake para disponer una biblioteca del NDK y almacenar su ruta de acceso como una variable. Esta variable se usa para hacer referencia a la biblioteca del NDK en otras partes de la secuencia de comandos de compilación. En el siguiente ejemplo se ubica la biblioteca de compatibilidad de registro específica de Android y se almacena su ruta en log-lib:

find_library( # Defines the name of the path variable that stores the
              # location of the NDK library.
              log-lib

              # Specifies the name of the NDK library that
              # CMake needs to locate.
              log )

Para que tu biblioteca nativa llame a funciones en la biblioteca de log, debes vincular las bibliotecas usando el comando target_link_libraries() en tu secuencia de comandos de compilación de CMake:

find_library(...)

# Links your native library against one or more other native libraries.
target_link_libraries( # Specifies the target library.
                       native-lib

                       # Links the log library to the target library.
                       ${log-lib} )

El NDK también incluye algunas bibliotecas como código fuente que debes compilar y vincular a tu biblioteca nativa. Puedes compilar el código fuente en una biblioteca nativa usando el comando add_library() en tu secuencia de comandos de compilación de CMake. Para proporcionar un camino a tu biblioteca NDK local, puedes usar la ruta variable ANDROID_NDK, que Android Studio definirá automáticamente.

El siguiente comando indica a CMake que compile android_native_app_glue.c, que administra eventos de ciclo de vida de NativeActivity y la entrada táctil en una biblioteca estática y lo vincula a native-lib:

add_library( app-glue
             STATIC
             ${ANDROID_NDK}/sources/android/native_app_glue/android_native_app_glue.c )

# You need to link static libraries against your shared native library.
target_link_libraries( native-lib app-glue ${log-lib} )

Agregar otras bibliotecas compiladas previamente

El proceso de agregar una biblioteca compilada previamente es similar al de especificar otra biblioteca nativa para que CMake realice la compilación. Sin embargo, debido a que la biblioteca ya está compilada, debes usar el indicador IMPORTED para indicar a CMake que solo deseas importar la biblioteca a tu proyecto:

add_library( imported-lib
             SHARED
             IMPORTED )

Luego debes especificar la ruta de acceso a la biblioteca con el comando set_target_properties(), como se muestra a continuación:

Algunas bibliotecas proporcionan paquetes separados para arquitecturas de CPU específicas, o interfaces binarias de aplicación (ABI), y las organiza en directorios separados. Este enfoque permite que las bibliotecas aprovechen determinadas arquitecturas de CPU y, al mismo tiempo, te permite usar solo las versiones de bibliotecas que desees. Para agregar varias versiones de ABI de una biblioteca a tu secuencia de comandos de compilación de CMake sin necesidad de escribir varios comandos para cada versión de la biblioteca, puedes usar la variable de ruta de acceso ANDROID_ABI. Esta variable usa una lista de las ABI predeterminadas que el NDK admite, o una lista filtrada de ABI que configuras manualmente para que Gradle la use. Por ejemplo:

add_library(...)
set_target_properties( # Specifies the target library.
                       imported-lib

                       # Specifies the parameter you want to define.
                       PROPERTIES IMPORTED_LOCATION

                       # Provides the path to the library you want to import.
                       imported-lib/src/${ANDROID_ABI}/libimported-lib.so )

Para que CMake ubique sus archivos de encabezados durante el tiempo de compilación, debes usar el comando include_directories() e incluir la ruta de acceso a tus archivos de encabezado:

include_directories( imported-lib/include/ )

Nota: Si deseas empaquetar una biblioteca compilada previamente que no sea una dependencia de tiempo de compilación (por ejemplo, al agregar una biblioteca compilada previamente que sea una dependencia de imported-lib), no es necesario que apliques las siguientes instrucciones para vincular la biblioteca.

Para vincular la biblioteca compilada previamente, agrégala al comando target_link_libraries() en tu secuencia de comandos de compilación de CMake:

target_link_libraries( native-lib imported-lib app-glue ${log-lib} )

Cuando compilas tu app, Gradle automáticamente empaqueta la biblioteca importada al APK. Puedes verificar las bibliotecas que Gradle empaqueta en tu APK usando el analizador de APK. Para obtener más información sobre los comandos de CMake, consulta la documentación de CMake.

Para vincular Gradle con tu biblioteca nativa, debes proporcionar una ruta de acceso a tu archivo de secuencia de comandos de CMake o ndk-build. Cuando compilas tu app, Gradle ejecuta CMake o ndk-build como una dependencia y empaqueta bibliotecas compartidas con tu APK. Gradle también usa la secuencia de comandos de compilación a fin de determinar los archivos que se incluirán a tu proyecto de Android Studio, para que puedas acceder a ellos desde la ventana Project. Si no dispones de una secuencia de comandos de compilación para tus fuentes nativas, debes crear una secuencia de comandos de compilación de CMake para proceder.

Una vez que vinculas Gradle con un proyecto nativo, Android Studio actualiza el subpanel Project para mostrar tus archivos de origen y bibliotecas nativas en el grupo cpp y tus secuencias de comandos de compilación externas en el grupo de External Build Files.

Nota: Cuando se realicen cambios en la configuración de Gradle, asegúrate de aplicar tus cambios haciendo clic en Sync Project en la barra de herramientas. Además, cuando se realicen cambios en tu archivo de secuencia de comandos de CMake o ndk-build después de haberlo vinculado con Gradle, debes sincronizar Android Studio con tus cambios seleccionando Build > Refresh Linked C++ Projects en la barra de menú.

Puedes vincular Gradle con un proyecto externo de CMake o ndk-build usando la IU de Android Studio:

  1. Abre el subpanel Project del lado izquierdo de IDE y selecciona la vista de Android.
  2. Haz clic con el botón secundario en el módulo que desees vincular con tu biblioteca nativa (por ejemplo, el módulo de app) y selecciona Link C++ Project with Gradle en el menú. Verás un diálogo similar al que se muestra en la figura 4.
  3. En el menú desplegable, selecciona CMake o ndk-build.
    1. Si seleccionas CMake, usa el campo junto a Project Path para especificar el archivo de secuencia de comandos CMakeLists.txt de tu proyecto de CMake externo.
    2. Si seleccionas ndk-build, usa el campo junto a Project Path para especificar el archivo de secuencia de comandos Android.mk de tu proyecto ndk-build externo. Android Studio también incluye el archivo Application.mk si se encuentra en el mismo directorio que tu archivo Android.mk.

    Figura 4: Vinculación de un proyecto de C++ mediante el diálogo de Android Studio.

  4. Haz clic en OK.

Configurar Gradle manualmente

Para establecer manualmente que Gradle se vincule con tu biblioteca nativa, debes agregar el bloque externalNativeBuild {} a tu archivo de nivel de módulo build.gradle y configurarlo con cmake {} o ndkBuild {}:

android {
  ...
  defaultConfig {...}
  buildTypes {...}

  // Encapsulates your external native build configurations.
  externalNativeBuild {

    // Encapsulates your CMake build configurations.
    cmake {

      // Provides a relative path to your CMake build script.
      path "CMakeLists.txt"
    }
  }
}

Nota: Si deseas vincular Gradle con un proyecto ndk-build existente, usa el bloque ndkBuild {} en lugar de cmake {}, y proporciona una ruta de acceso relativa a tu archivo Android.mk. Gradle también incluye el archivo Application.mk si se encuentra en el mismo directorio que tu archivo Android.mk.

Especificar configuraciones opcionales

Puedes especificar argumentos e indicadores opcionales para CMake o ndk-build configurando otro bloque externalNativeBuild {} dentro del bloque defaultConfig {} de tu archivo de nivel de módulo build.gradle. Como en el caso de otras propiedades del bloque defaultConfig {}, puedes anular estas propiedades para cada clase de producto de tu configuración de compilación.

Por ejemplo, si tu proyecto CMake o ndk-build define varias bibliotecas nativas, puedes usar la propiedad targets para compilar y empaquetar solo un subconjunto de esas bibliotecas para una clase de producto dado. En el siguiente ejemplo de código se describe alguna de las propiedades que puedes configurar:

android {
  ...
  defaultConfig {
    ...
    // This block is different from the one you use to link Gradle
    // to your CMake or ndk-build script.
    externalNativeBuild {

      // For ndk-build, instead use ndkBuild {}
      cmake {

        // Passes optional arguments to CMake.
        arguments "-DANDROID_ARM_NEON=TRUE", "-DANDROID_TOOLCHAIN=clang"

        // Sets optional flags for the C compiler.
        cFlags "-D_EXAMPLE_C_FLAG1", "-D_EXAMPLE_C_FLAG2"

        // Sets a flag to enable format macro constants for the C++ compiler.
        cppFlags "-D__STDC_FORMAT_MACROS"
      }
    }
  }

  buildTypes {...}

  productFlavors {
    ...
    demo {
      ...
      externalNativeBuild {
        cmake {
          ...
          // Specifies which native libraries to build and package for this
          // product flavor. If you don't configure this property, Gradle
          // builds and packages all shared object libraries that you define
          // in your CMake or ndk-build project.
          targets "native-lib-demo"
        }
      }
    }

    paid {
      ...
      externalNativeBuild {
        cmake {
          ...
          targets "native-lib-paid"
        }
      }
    }
  }

  // Use this block to link Gradle to your CMake or ndk-build script.
  externalNativeBuild {
    cmake {...}
    // or ndkBuild {...}
  }
}

Para obtener más información sobre la configuración de clases de productos y variantes de compilación, consulta Configurar variantes de compilación. Para hallar una lista de variables que puedes configurar para CMake con la propiedad arguments, consulta Usar variables de CMake.

Especificar las ABI

De forma predeterminada, Gradle compila tu biblioteca nativa en archivos separados .so para las ABI que el NDK admite y las empaqueta en tu APK. Si deseas que Gradle compile y empaquete solo determinadas configuraciones de ABI de tus bibliotecas nativas, puedes especificarlas con el indicador ndk.abiFilters en tu archivo de nivel de módulo build.gradle, como se muestra a continuación:

android {
  ...
  defaultConfig {
    ...
    externalNativeBuild {
      cmake {...}
      // or ndkBuild {...}
    }

    ndk {
      // Specifies the ABI configurations of your native
      // libraries Gradle should build and package with your APK.
      abiFilters 'x86', 'x86_64', 'armeabi', 'armeabi-v7a',
                   'arm64-v8a'
    }
  }
  buildTypes {...}
  externalNativeBuild {...}
}

En la mayoría de los casos, solo debes especificar abiFilters en el bloque ndk {}, como se muestra arriba, ya que indica a Gradle que debe compilar y empaquetar esas versiones de tus bibliotecas nativas. Sin embargo, si deseas controlar lo que Gradle debe compilar, independientemente de lo que desees que empaquete en tu APK, configura otro indicador abiFilters en el bloque defaultConfig.externalNativeBuild.cmake {} (o el bloque defaultConfig.externalNativeBuild.ndkBuild {}). Gradle compila esas configuraciones de ABI pero solo empaqueta las especificadas en el bloque defaultConfig.ndk{}.

Para reducir aún más el tamaño de tu APK, considera configurar divisiones del APK de ABI; en lugar de crear un APK grande con todas las versiones de tus bibliotecas nativas, Gradle crea un APK separado para cada ABI que desees admitir y solo empaqueta los archivos que necesite cada ABI. Si configuras una división de ABI sin especificar el indicador abiFilters, como se muestra en el ejemplo de código anterior, Gradle compila todas las versiones de ABI compatibles de tus bibliotecas nativas, pero solo empaqueta aquellas que especificaste en tu configuración de división de ABI. Para evitar compilar versiones de tus bibliotecas nativas que no desees, proporciona la misma lista de ABI para el indicador abiFilters y tu configuración de división de ABI.

This site uses cookies to store your preferences for site-specific language and display options.

Get the latest Android developer news and tips that will help you find success on Google Play.

* Required Fields

Hooray!

Browse this site in ?

You requested a page in , but your language preference for this site is .

Would you like to change your language preference and browse this site in ? If you want to change your language preference later, use the language menu at the bottom of each page.

This class requires API level or higher

This doc is hidden because your selected API level for the documentation is . You can change the documentation API level with the selector above the left navigation.

For more information about specifying the API level your app requires, read Supporting Different Platform Versions.

Take a short survey?
Help us improve the Android developer experience.
(Sep 2017 survey)