Google se compromete a impulsar la igualdad racial para las comunidades afrodescendientes. Obtén información al respecto.

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

Puedes agregar código C y C++ a tu proyecto de Android si colocas el código en un directorio cpp en el módulo del proyecto. Cuando creas el proyecto, este código se compila en una biblioteca nativa que Gradle puede empaquetar con el APK. El código Java o Kotlin puede llamar a funciones de la biblioteca nativa a través de la interfaz nativa de Java (JNI). Para obtener más información sobre el uso del framework de JNI, consulta las sugerencias de JNI para Android.

Android Studio es compatible con CMake, que es muy útil para proyectos multiplataforma, y con ndk-build, que puede ser más rápido que CMake, aunque solo es compatible con Android. Actualmente, no es posible usar CMake y ndk-build en el mismo módulo.

Si deseas importar una biblioteca ndk-build existente al proyecto de Android Studio, obtén información para vincular Gradle al proyecto de biblioteca nativa.

En esta página, se muestra cómo configurar Android Studio con las herramientas de compilación necesarias, crear un proyecto nuevo compatible con C/C++ y agregar archivos C/C++ nuevos al proyecto.

Si, en cambio, deseas agregar código nativo a un proyecto existente, debes seguir estos pasos:

  1. Crea nuevos archivos de origen nativos y agrégalos a tu proyecto de Android Studio.
    • Puedes omitir este paso si ya tienes código nativo o si deseas importar una biblioteca nativa ya compilada.
  2. Configura 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 ya compiladas.
    • 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. Configura Gradle proporcionando una ruta de acceso al archivo de secuencia de comandos CMake o ndk-build. Gradle usa la secuencia de comandos de compilación para importar el código fuente en el proyecto de Android Studio y a fin de empaquetar la biblioteca nativa (el archivo del SO) en el APK.

Una vez que hayas configurado el proyecto, podrás acceder a las funciones nativas desde el código Java o Kotlin usando el framework de JNI. Para compilar y ejecutar la app, haz clic en Run ejecutar y luego ejecutar la app desde la barra de menú.

Nota: Si el proyecto existente utiliza la herramienta obsoleta ndkCompile, debes migrar a CMake o ndk-build. Para obtener más información, accede a la sección correspondiente en Cómo migrar desde ndkCompile.

Atención si eres usuario experimental de Gradle: Considera realizar la migración a la versión 2.2.0 del complemento o a una versión posterior, y usar CMake o ndk-build para compilar las bibliotecas nativas si se cumple alguna de las siguientes declaraciones: el proyecto nativo ya usa CMake o ndk-build; prefieres usar una versión estable del sistema de compilación de Gradle; o deseas tener compatibilidad con herramientas del complemento, como CCache. De lo contrario, puedes seguir usando la versión experimental de Gradle y el complemento para Android.

Cómo descargar el NDK y las herramientas de compilación

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

  • Kit de desarrollo nativo (NDK) de Android: Es un conjunto de herramientas que te permite usar código C y C++ con Android y que proporciona bibliotecas de plataforma que te permiten administrar actividades nativas y acceder a componentes de dispositivos físicos, como sensores y entradas táctiles.
  • CMake: Es una herramienta de compilación externa que funciona junto con Gradle para compilar tu biblioteca nativa. No necesitas este componente si solo planeas usar ndk-build.
  • LLDB: Es el depurador que usa Android Studio para depurar código nativo.

Si quieres obtener información para instalar estos componentes, consulta Cómo instalar y configurar el NDK, CMake y LLDB.

Cómo crear un nuevo proyecto compatible con C y C++

Crear un nuevo proyecto compatible para código nativo es similar a crear cualquier otro proyecto de Android Studio, aunque hay un paso adicional:

  1. En la sección Choose your project del asistente, selecciona el tipo de proyecto Native C++.
  2. Haz clic en Next.
  3. Completa todos los demás campos en la siguiente sección del asistente.
  4. Haz clic en Next.
  5. En la sección Customize C++ Support del asistente, puedes personalizar el proyecto en el campo C++ Standard. Usa la lista desplegable para seleccionar qué estandarización de C++ deseas usar. Si seleccionas Toolchain Default, se usará la configuración predeterminada de CMake.
  6. Haz clic en Finish.

Después de que Android Studio haya terminado de crear el proyecto nuevo, abre el panel Project del lateral izquierdo del IDE y selecciona la vista Android. Como se muestra en la Figura 2, Android Studio agrega el grupo cpp:

Figura 2: Grupos de vistas de Android para fuentes nativas y secuencias de comandos de compilación externa

Nota: Esta vista no refleja la jerarquía real del archivo en el disco, sino que agrupa archivos similares para simplificar la navegación por el proyecto.

El grupo cpp es el lugar en el que puedes encontrar todos los archivos de origen nativos, los encabezados, las secuencias de comandos de compilación para CMake o ndk-build y las bibliotecas ya compiladas que son parte del proyecto. Para proyectos nuevos, Android Studio crea un archivo de origen C++ de muestra, native-lib.cpp, y lo ubica en el directorio src/main/cpp/ del módulo de la app. Este código de muestra proporciona una función C++ simple, stringFromJNI(), que muestra la string "Hello from C++". Para obtener información sobre cómo agregar archivos de origen adicionales al proyecto en la sección correspondiente de Cómo crear nuevos archivos de origen nativos.

Así como los archivos build.gradle indican a Gradle cómo compilar la app, CMake y ndk-build requieren una secuencia de comandos de compilación para saber cómo compilar la biblioteca nativa. Para proyectos nuevos, Android Studio crea una secuencia de comandos de compilación de CMake, CMakeLists.txt, y la ubica en el directorio raíz del módulo. Para obtener más información sobre el contenido de esta secuencia de comandos de compilación, consulta Cómo configurar CMake.

Cómo compilar y ejecutar la app de muestra

Cuando haces clic en Run ejecutar y luego ejecutar la app desde la barra de menú, Android Studio compila e inicia una app que muestra el texto "Hello from C++" en el dispositivo o emulador de Android. En la siguiente descripción general, se detallan los eventos que tienen lugar para compilar y ejecutar la app de muestra:

  1. Gradle llama a la secuencia de compilación externa CMakeLists.txt.
  2. CMake sigue los comandos de la secuencia de comandos de compilación para compilar un archivo de origen C++, native-lib.cpp, en una biblioteca de objeto compartida y le asigna el nombre libnative-lib.so, que Gradle luego empaquetará en el APK.
  3. Durante el tiempo de ejecución, el objeto MainActivity de la app carga la biblioteca nativa mediante System.loadLibrary(). La función nativa de la biblioteca, stringFromJNI(), ahora está disponible para la app.
  4. El objeto MainActivity.onCreate() llama a stringFromJNI(), que muestra "Hello from C++", y lo usa para actualizar TextView.

Nota: Instant Run no es compatible con los componentes del proyecto escrito en el código nativo.

Para verificar si Gradle empaqueta la biblioteca nativa en el APK, puedes usar el Analizador de APK:

  1. Selecciona Build > Build Bundles(s) / APK(s) > Build APK(s).
  2. Elige Build > Analyze APK.
  3. Selecciona el APK del directorio app/build/outputs/apk/ y haz clic en OK.
  4. Como se muestra en la Figura 3, puedes ver libnative-lib.so en la ventana del Analizador de APK, en lib/<ABI>/.

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

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

Cómo crear archivos fuente C/C++ nuevos

Para agregar nuevos archivos fuente C/C++ a un proyecto existente, sigue estos pasos:

  1. Si aún no tienes un directorio cpp/ en el conjunto de fuentes principal de la app, crea uno de la siguiente manera:
    1. Abre el panel Project del lateral izquierdo del IDE y selecciona la vista Project del menú desplegable.
    2. Navega hasta your-module > src, haz clic con el botón derecho en el directorio main y selecciona New > Directory.
    3. Ingresa cpp como nombre del directorio y haz clic en OK.

  2. Haz clic con el botón derecho en el directorio cpp/ y selecciona New > C/C++ Source File.
  3. Ingresa un nombre para el archivo de origen, como native-lib.
  4. En el menú desplegable Type, selecciona la extensión de archivo del archivo de origen, como .cpp.
    • Puedes agregar otros tipos de archivos al menú desplegable, como .cxx o .hxx. Para ello, haz clic en Edit File Types . En el cuadro de diálogo C/C++ que aparece, selecciona otra extensión de archivo de los menús desplegables Source Extension y Header Extension, y haz clic en OK.
  5. Si también deseas crear un archivo de encabezado, selecciona la casilla de verificación Create an associated header.
  6. Haz clic en OK.

Después de agregar archivos C/C++ nuevos al proyecto, deberás configurar CMake para incluirlos en la biblioteca nativa.

Recursos adicionales

Para obtener más información sobre la compatibilidad con el código C/C++ en la app, prueba el siguiente recurso.

Codelabs