Organiza tus páginas con colecciones
Guarda y categoriza el contenido según tus preferencias.
Antes de comenzar
En esta guía, se considera que ya conoces los conceptos inherentes a la programación nativa y al desarrollo de Android.
Introducción
En esta sección, se proporciona una explicación detallada del funcionamiento del NDK. Android NDK es un conjunto de herramientas que te permiten incorporar código C o C++ ("código nativo") a tus apps de Android. La capacidad de usar código nativo en apps de Android puede ser particularmente útil para los desarrolladores que deseen realizar una o varias de las siguientes acciones:
Migrar las apps entre plataformas.
Reutilizar bibliotecas existentes o proporcionar sus propias bibliotecas para reutilizarlas.
Aumentar el rendimiento en ciertos casos, en especial, los de mayor exigencia computacional, como el de los juegos
Cómo funciona
En esta sección, se presentan los componentes principales que se usan en la compilación de una aplicación nativa para Android y se describen los procesos de compilación y empaquetado.
Componentes principales
Debes comprender los siguientes componentes a medida que compilas tu app:
Bibliotecas compartidas nativas: El NDK compila estas bibliotecas, o archivos .so, a partir de tu código fuente de C/C++.
Bibliotecas estáticas nativas: El NDK también puede compilar bibliotecas estáticas, o archivos .a, que puedes vincular con otras bibliotecas.
Interfaz nativa de Java (JNI): Es la interfaz mediante la cual los componentes de Java y C++ se comunican entre sí. En esta guía, se da por sentado que ya conoces la JNI. Para obtener información sobre ella, consulta la Especificación de la interfaz nativa de Java.
Interfaz binaria de la aplicación (ABI): Define exactamente cómo se espera que el código máquina de tu app interactúe con el sistema durante el tiempo de ejecución. El NDK compila archivos .so según estas definiciones. Las diferentes ABI corresponden a las distintas arquitecturas: el NDK incluye compatibilidad con ABI para ARM de 32 bits, AArch64, x86 y x86-64. Para obtener más información, consulta ABI de Android.
Crea un archivo Android.mk que describa la biblioteca nativa y que incluya el nombre, las marcas, las bibliotecas vinculadas y los archivos de origen que se van a compilar en el directorio "JNI".
De manera opcional, puedes crear un archivo Application.mk configurando las ABI de destino, la cadena de herramientas, el modo de lanzamiento o depuración y la STL. Si no se especifica alguno de esos elementos, se usan los siguientes valores predeterminados, respectivamente:
ABI: todas las ABI que no están obsoletas
Modo: Lanzamiento
STL: system
Coloca tu archivo de origen nativo en el directorio jni del proyecto.
Usa ndk-build para compilar las bibliotecas nativas (.so, .a).
Compila el componente Java y crea el archivo .dex ejecutable.
Empaqueta todo en un archivo APK que contenga .so, .dex y todos los demás archivos necesarios para que se ejecute la app.
Aplicaciones y actividades nativas
El SDK de Android proporciona una clase de ayuda, NativeActivity, que te permite escribir una actividad completamente nativa. NativeActivity controla la comunicación entre el framework de Android y tu código nativo, de manera que no tengas que crear una subclase ni llamar a sus métodos. Lo único que debes hacer es declarar que la aplicación es nativa en el archivo AndroidManifest.xml y comenzar a crearla.
Una aplicación para Android que usa NativeActivity aún se ejecuta en su propia máquina virtual, en una zona de pruebas separada de las demás aplicaciones. Por lo tanto, aún puedes acceder a las API del framework de Android mediante la JNI. Sin embargo, en algunos casos (p. ej., con sensores, eventos de entrada y elementos), el NDK proporciona interfaces nativas que puedes usar en lugar de tener que realizar llamadas en toda la JNI. Para obtener más información sobre ese tipo de compatibilidad, consulta API nativas.
Independientemente de que desarrolles una actividad nativa o no, te recomendamos que crees tus proyectos con las herramientas de compilación tradicionales de Android. De esta manera, podrás garantizar que las aplicaciones para Android se compilen y empaqueten con la estructura correcta.
El NDK de Android te ofrece dos opciones para implementar tu actividad nativa:
El encabezado native_activity.h define la versión nativa de la clase NativeActivity. Contiene la interfaz de devolución de llamada y las estructuras de datos necesarias para crear tu actividad nativa. Debido a que el subproceso principal de la aplicación controla las devoluciones de llamada, implementarlas no debe generar bloqueos. Si lo hace, podrías recibir errores ANR (Aplicación no responde), ya que el subproceso principal no responderá hasta que se muestre la devolución de llamada.
El archivo android_native_app_glue.h define una biblioteca estática de ayuda compilada por encima de la interfaz native_activity.h. Genera otro subproceso que controla, por ejemplo, las devoluciones de llamadas o los eventos de entrada en un bucle de eventos. Si mueves estos eventos a un subproceso independiente, evitarás que las devoluciones de llamadas bloqueen tu subproceso principal.
También está disponible la fuente <ndk_root>/sources/android/native_app_glue/android_native_app_glue.c, que te permite modificar la implementación.
A fin de obtener más información para usar esta biblioteca estática, explora la aplicación de muestra de native-activity y su documentación. Puedes leer más acerca de este tema en los comentarios del archivo <ndk_root>/sources/android/native_app_glue/android_native_app_glue.h.
Cómo usar la interfaz native_activity.h
Para implementar una actividad nativa con la interfaz native_activity.h, sigue estos pasos:
Crea un directorio jni/ en el directorio raíz de tu proyecto. Ese directorio almacenará todo el código nativo.
Declara la actividad nativa en el archivo AndroidManifest.xml.
Como tu aplicación no tiene código Java, configura android:hasCode como false.
El atributo android:value de la etiqueta meta-data especifica el nombre de la biblioteca compartida que contiene el punto de entrada a la aplicación (p. ej., main en C/C++), y omite el prefijo lib y el sufijo .so del nombre de la biblioteca.
Crea un archivo para tu actividad nativa e implementa la función nombrada en la variable ANativeActivity_onCreate. La app llama a esta función cuando se inicia la actividad nativa. Esta función, que es análoga a main en C/C++, recibe un puntero para una estructura ANativeActivity, que contiene punteros de función a las distintas implementaciones de devoluciones de llamada que debes escribir. Configura los punteros de la función de devolución de llamada correspondientes en ANativeActivity->callbacks para las implementaciones de las devoluciones de llamada.
Configura el campo ANativeActivity->instance con la dirección de cualquier instancia de datos específicos que quieras usar.
Implementa todas las demás acciones que desees que tu actividad realice al iniciarse.
Implementa el resto de las devoluciones de llamada que configuraste en ANativeActivity->callbacks. Para obtener más información sobre cuándo se deben invocar las devoluciones de llamada, consulta Cómo administrar el ciclo de vida de la actividad.
Desarrolla el resto de tu aplicación.
Crea un Android.mk file en el directorio jni/ de tu proyecto para describir el módulo nativo en el sistema de compilación. Para obtener más información, consulta Android.mk.
Una vez que tengas un archivo Android.mk, compila tu código nativo con el comando ndk-build.
cd<path>/<to>/<project>
$NDK/ndk-build
Compila e instala tu proyecto de Android como lo haces habitualmente. Si tu código nativo se encuentra en el directorio jni/, la secuencia de comandos de compilación empaqueta automáticamente los archivos .so compilados a partir de esta en el APK.
El contenido y las muestras de código que aparecen en esta página están sujetas a las licencias que se describen en la Licencia de Contenido. Java y OpenJDK son marcas registradas de Oracle o sus afiliados.
Última actualización: 2025-07-27 (UTC)
[[["Fácil de comprender","easyToUnderstand","thumb-up"],["Resolvió mi problema","solvedMyProblem","thumb-up"],["Otro","otherUp","thumb-up"]],[["Falta la información que necesito","missingTheInformationINeed","thumb-down"],["Muy complicado o demasiados pasos","tooComplicatedTooManySteps","thumb-down"],["Desactualizado","outOfDate","thumb-down"],["Problema de traducción","translationIssue","thumb-down"],["Problema con las muestras o los códigos","samplesCodeIssue","thumb-down"],["Otro","otherDown","thumb-down"]],["Última actualización: 2025-07-27 (UTC)"],[],[],null,["# Concepts\n\nBefore you begin\n----------------\n\nThis guide assumes that you are already familiar with concepts inherent in\nnative programming and in [Android development](/develop).\n\nIntroduction\n------------\n\nThis section provides a high-level explanation of how the NDK works. The Android NDK is a set of\ntools allowing you to embed C or C++ (\"native code\") into your Android apps. The ability to use\nnative code in Android apps can be particularly useful to developers who wish to do one or more of\nthe following:\n\n- Port their apps between platforms.\n- Reuse existing libraries, or provide their own libraries for reuse.\n- Increase performance in certain cases, particularly computationally intensive ones like games.\n\nHow it works\n------------\n\nThis section introduces the main components used in building a native\napplication for Android, and goes on to describe the process of building and\npackaging.\n\n### Main components\n\nYou should have an understanding of the following components as you build your\napp:\n\n- Native shared libraries: The NDK builds these libraries, or `.so` files, from\n your C/C++ source code.\n\n- Native static libraries: The NDK can also build static libraries, or `.a`\n files, which you can link into other libraries.\n\n- Java Native Interface (JNI): The JNI is the interface via which the Java and\n C++ components talk to one another. This guide assumes knowledge of the JNI;\n for information about it, consult the [Java Native Interface Specification](http://docs.oracle.com/javase/7/docs/technotes/guides/jni/spec/jniTOC.html).\n\n- Application Binary Interface (ABI): The ABI defines exactly how your app's\n machine code is expected to interact with the system at runtime. The NDK\n builds `.so` files against these definitions. Different ABIs correspond to\n different architectures: The NDK includes ABI support for 32-bit ARM, AArch64,\n x86, and x86-64. For more information, see [Android\n ABIs](/ndk/guides/abis).\n\n- Manifest: If you are writing an app with no Java component to it, you must\n declare the [NativeActivity](/reference/android/app/NativeActivity) class in the\n [manifest](/guide/topics/manifest/manifest-intro). See [Use the\n native_activity.h interface](#na) for more detail on how to do this.\n\n### Flow\n\nThe general flow for developing a native app for Android is as follows:\n\n1. Design your app, deciding which parts to implement in Java, and which parts\n to implement as native code.\n\n | **Note:** While it is possible to completely avoid Java, you are likely to find the Android Java framework useful for tasks including controlling the display and UI.\n2. Create an Android app Project as you would for any other Android project.\n\n3. If you are writing a native-only app, declare the [NativeActivity](/reference/android/app/NativeActivity) class in\n `AndroidManifest.xml`. For more information, see the [Native activities and\n applications](#naa).\n\n4. Create an `Android.mk` file describing the native library, including name,\n flags, linked libraries, and source files to be compiled in the \"JNI\"\n directory.\n\n5. Optionally, you can create an `Application.mk` file configuring the target\n ABIs, toolchain, release/debug mode, and STL. For any of these that you do\n not specify, the following default values are used, respectively:\n\n - ABI: all non-deprecated ABIs\n - Mode: Release\n - STL: system\n6. Place your native source under the project's `jni` directory.\n\n7. Use ndk-build to compile the native (`.so`, `.a`) libraries.\n\n8. Build the Java component, producing the executable `.dex` file.\n\n9. Package everything into an APK file, containing `.so`, `.dex`, and other\n files needed for your app to run.\n\nNative activities and applications\n----------------------------------\n\nThe Android SDK provides a helper class, [NativeActivity](/reference/android/app/NativeActivity), that allows you to\nwrite a completely native activity. [NativeActivity](/reference/android/app/NativeActivity) handles the communication\nbetween the Android framework and your native code, so you do not have to\nsubclass it or call its methods. All you need to do is declare your application\nto be native in your `AndroidManifest.xml` file, and begin creating your native\napplication.\n\nAn Android application using [NativeActivity](/reference/android/app/NativeActivity) still runs in its own virtual\nmachine, sandboxed from other applications. You can therefore still access\nAndroid framework APIs through the JNI. In certain cases, such as for sensors,\ninput events, and assets, the NDK provides native interfaces that you can use\ninstead of having to call across the JNI. For more information about such\nsupport, see [Native APIs](/ndk/guides/stable_apis).\n\nRegardless of whether or not you are developing a native activity, we recommend\nthat you create your projects with the traditional Android build tools. Doing so\nhelps ensure building and packaging of Android applications with the correct\nstructure.\n\nThe Android NDK provides you with two choices to implement your native activity:\n\n- The [native_activity.h](/ndk/reference/native__activity_8h) header defines the native version of the [NativeActivity](/reference/android/app/NativeActivity) class. It contains the callback interface and data structures that you need to create your native activity. Because the main thread of your application handles the callbacks, your callback implementations must not be blocking. If they block, you might receive ANR (Application Not Responding) errors because your main thread is unresponsive until the callback returns.\n- The `android_native_app_glue.h` file defines a static helper library built on top of the [native_activity.h](/ndk/reference/native__activity_8h) interface. It spawns another thread, which handles things such as callbacks or input events in an event loop. Moving these events to a separate thread prevents any callbacks from blocking your main thread.\n\nThe `\u003cndk_root\u003e/sources/android/native_app_glue/android_native_app_glue.c`\nsource is also available, allowing you to modify the implementation.\n\nFor more information on how to use this static library, examine the\nnative-activity sample application and its documentation. Further reading is\nalso available in the comments in the\n`\u003cndk_root\u003e/sources/android/native_app_glue/android_native_app_glue.h`\nfile.\n\n### Use the native_activity.h interface\n\nTo implement a native activity with the [native_activity.h](/ndk/reference/native__activity_8h) interface:\n\n1. Create a `jni/` directory in your project's root directory. This directory\n stores all of your native code.\n\n2. Declare your native activity in the `AndroidManifest.xml` file.\n\n Because your application has no Java code, set `android:hasCode` to `false`. \n\n \u003capplication android:label=\"@string/app_name\" android:hasCode=\"false\"\u003e\n\n You must set the `android:name` attribute of the activity tag to\n [NativeActivity](/reference/android/app/NativeActivity). \n\n \u003cactivity android:name=\"android.app.NativeActivity\"\n android:label=\"@string/app_name\"\u003e\n\n | **Note:** You can subclass [NativeActivity](/reference/android/app/NativeActivity). If you do, use the name of the subclass instead of [NativeActivity](/reference/android/app/NativeActivity).\n\n The `android:value` attribute of the `meta-data` tag specifies the name of\n the shared library containing the entry point to the application (such as\n C/C++ `main`), omitting the `lib` prefix and `.so` suffix from the library\n name. \n\n \u003cmanifest\u003e\n \u003capplication\u003e\n \u003cactivity\u003e\n \u003cmeta-data android:name=\"android.app.lib_name\"\n android:value=\"native-activity\" /\u003e\n \u003cintent-filter\u003e\n \u003caction android:name=\"android.intent.action.MAIN\" /\u003e\n \u003ccategory android:name=\"android.intent.category.LAUNCHER\" /\u003e\n \u003c/intent-filter\u003e\n \u003c/activity\u003e\n \u003c/application\u003e\n \u003c/manifest\u003e\n\n3. Create a file for your native activity, and implement the function named in\n the [ANativeActivity_onCreate](/ndk/reference/group___native_activity#ga02791d0d490839055169f39fdc905c5e) variable. The app calls this function when the\n native activity starts. This function, analogous to `main` in C/C++, receives\n a pointer to an [ANativeActivity](/ndk/reference/struct_a_native_activity) structure, which contains function pointers\n to the various callback implementations that you need to write. Set the\n applicable callback function pointers in `ANativeActivity-\u003ecallbacks` to\n the implementations of your callbacks.\n\n4. Set the `ANativeActivity-\u003einstance` field to the address of any instance of\n specific data that you want to use.\n\n5. Implement anything else that you want your activity to do upon starting.\n\n6. Implement the rest of the callbacks that you set in\n `ANativeActivity-\u003ecallbacks`. For more information on when the callbacks are\n called, see [Managing the Activity Lifecycle](/training/basics/activity-lifecycle).\n\n7. Develop the rest of your application.\n\n8. Create an `Android.mk file` in the `jni/` directory of your project to\n describe your native module to the build system. For more information, see\n [Android.mk](/ndk/guides/android_mk).\n\n9. Once you have an [Android.mk](/ndk/guides/android_mk) file, compile your native code using the\n `ndk-build` command.\n\n cd \u003cpath\u003e/\u003cto\u003e/\u003cproject\u003e\n $NDK/ndk-build\n\n10. Build and install your Android project as usual. If your native code is in\n the `jni/` directory, the build script automatically packages the `.so`\n file(s) built from it into the APK.\n\nAdditional sample code\n----------------------\n\nTo download NDK samples, see [NDK Samples](https://github.com/android/ndk-samples)."]]
