Android NDK Native API

El NDK de Android proporciona un conjunto de archivos de bibliotecas compartidas y encabezados nativos que se ha incrementado gradualmente con los sucesivos lanzamientos de los nuevos niveles API de Android. En esta página, se explican esos encabezados y archivos, y se asignan a niveles específicos de API de Android.

Uso de API nativas

Debes realizar dos pasos básicos para habilitar tu aplicación a fin de que use las bibliotecas que proporciona el NDK:

  1. Incluye en tu código los encabezados asociados con las bibliotecas que desees usar.
  2. Indica al sistema de compilación que tu módulo nativo debe vincularse con las bibliotecas en el momento de la carga.
    • Si usas ndk-build: Agrega la biblioteca nativa a la variable LOCAL_LDLIBS de tu archivo Android.mk. Por ejemplo, para vincular /system/lib/libfoo.so, agrega la siguiente línea:
    •     LOCAL_LDLIBS := -lfoo
          

      Para enumerar varias bibliotecas, usa un espacio como delimitador. Para obtener más información sobre cómo usar la variable LOCAL_LDLIBS, consulta Android.mk.

    • Si usas CMake: Sigue las instrucciones en Cómo agregar código C y C++ a tu proyecto.
Para todos los niveles de API, el sistema de compilación vincula automáticamente las bibliotecas C y C++ estándar. No es necesario incluirlas explícitamente al configurar LOCAL_LDLIBS.

El NDK con frecuencia proporciona bibliotecas y encabezados nuevos para las nuevas versiones de Android. Para ver una lista de las API nativas que se incluyen en la versión de lanzamiento de Android, consulta la Tabla 1 a continuación. Estos archivos se encuentran en el directorio raíz de instalación del NDK, en sysroot/usr/include.

En la siguiente tabla, se muestra la correspondencia entre los niveles de API admitidos por el NDK y las versiones de Android. Para obtener más información sobre los niveles de API de Android, consulta ¿Qué es el nivel de API?

Tabla 1. Resumen de la compatibilidad de API nativa clave que presenta la versión de Android.

Nivel de API admitido por el NDK Versión de la plataforma de Android API nativas clave Incluir
3 1.5 Biblioteca C estándar (libc/libm) #include ...
C++ #include ...
Interfaz nativa Java #include <jni.h>
API de registro Android #include <android/log.h>
Zlib #include <zlib.h>
Vinculador dinámico #include <dlfcn.h>
4 1.6 OpenGL ES 1.x #include <GLES/gl.h>
#include <GLES/glext.h>
5 2.0 - 2.1.x OpenGL ES 2.0 #include <GLES2/gl2.h>
#include <GLES2/gl2ext.h>
8 2.2 Android bitmap API #include <android/bitmap.h>
9 2.3 - 3.0.x EGL #include <EGL/egl.h>
#include <EGL/eglext.h>
#include <EGL/eglplatform.h>
OpenSL ES #include <SLES/OpenSLES.h>
#include <SLES/OpenSLES_Platform.h>
#include <SLES/OpenSLES_Android.h>
#include <SLES/OpenSLES_AndroidConfiguration.h>
API de aplicación nativa Bucle de eventos:
#include <android/looper.h>

Eventos de entrada:
#include <android/input.h>
#include <android/keycodes.h>

Eventos de sensor:
#include <android/sensor.h>

Administración de Window/Surface:
#include <android/rect.h>
#include <android/window.h>
#include <android/native_window.h>
#include <android/native_window_jni.h>

Activos:
#include <android/asset_manager.h>

Configuración:
#include <android/configuration.h>

Archivos OBB:
#include <android/storage_manager.h>

#include <android/obb.h>

Actividad nativa:
#include <android/native_activity.h>
12 3.1.x
13 3.2
14 4.0 - 4.0.2 OpenMAX AL #include <OMXAL/OpenMAXAL.h>
#include <OMXAL/OpenMAXAL_Platform.h>
#include <OMXAL/OpenMAXAL_Android.h>
15 4.0.3, 4.0.4
16 4.1, 4.1.1
17 4.2, 4.2.2
18 4.3 OpenGL ES 3.0 #include <GLES3/gl3.h>
#include <GLES3/gl3ext.h>
19 4.4, 4.4w
21 5.0, 5.1 OpenGL ES 3.1 #include <GLES3/gl31.h>
#include <GLES3/gl3ext.h>
API nativas de medios #include <media/NdkMediaCodec.h>
#include <media/NdkMediaCrypto.h>
#include <media/NdkMediaDrm.h>
#include <media/NdkMediaError.h>
#include <media/NdkMediaExtractor.h>
#include <media/NdkMediaFormat.h>
#include <media/NdkMediaMuxer.h>
23 6.0 API nativa de seguimiento #include <android/trace.h>
24 7.0 - 7.1.1 Vulkan #include <vulkan/vulkan.h>
API de cámara nativa #include <camera/NdkCameraCaptureSession.h>
#include <camera/NdkCameraDevice.h>
#include <camera/NdkCameraError.h>
#include <camera/NdkCameraManager.h>
#include <camera/NdkCameraMetadata.h>
#include <camera/NdkCameraMetadataTags.h>
#include <camera/NdkCaptureRequest.h>
Choreographer API nativa #include <android/choreographer.h>
Multinetwork API nativa #include <android/multinetwork.h>
OpenGL ES 3.2 #include <GLES3/gl32.h>
#include <GLES3/gl3ext.h>
API nativas de medios #include <media/NdkImage.h>
#include <media/NdkImageReader.h>
26 8.0 API de AAudio #include <aaudio/AAudio.h>
API de búfer de hardware #include <android/hardware_buffer.h>
#include <android/hardware_buffer_jni.h>>
API de memoria compartida #include <android/sharedmem.h>
27 8.1 API de Neural Networks #include <android/NeuralNetworks.h>
API de memoria compartida JNI #include <android/hardware_buffer.h>
28 9.0 API de SurfaceTexture #include <android/surface_texture.h>

Características importantes de la API nativa

Nivel 3 de API de Android

Biblioteca C

La biblioteca C estándar incluye encabezados que están disponibles con sus nombres habituales, como <stdlib.h> y <stdio.h>. Ten en cuenta que en Android, a diferencia de Linux, no hay bibliotecas pthread y rt por separado. Esa funcionalidad se incluye en libc. La biblioteca math se encuentra por separado en libm, pero el compilador la agrega automáticamente.

Biblioteca del vinculador dinámico

Puedes acceder a la funcionalidad dlopen(3) y dlsym(3) del vinculador dinámico de Android. También debes vincular con libdl. Por ejemplo:
    LOCAL_LDLIBS := -ldl
    

Biblioteca C++

Hay compatibilidad con C++17. Para obtener más información sobre la compatibilidad con la biblioteca C++, consulta Compatibilidad con la biblioteca C++.

Compatibilidad de registros específicos de Android

<android/log.h> contiene varias funciones que una aplicación puede usar para enviar mensajes de registro a logcat desde el código nativo. Para obtener más información sobre estas definiciones, consulta la documentación de registro. En general, puedes escribir tus propias macros de contenedores para acceder a esta funcionalidad. Si quieres hacer un registro, debes realizar la vinculación con liblog. Por ejemplo:
    LOCAL_LDLIBS := -llog
    

Biblioteca de compresión ZLib

Puedes usar la biblioteca de compresión Zlib si incluyes zlib.h y zconf.h. También debes vincular tu módulo nativo con /system/lib/libz.so incluyendo la siguiente línea en el archivo Android.mk:

    LOCAL_LDLIBS := -lz
    

Nivel 4 de API de Android

El NDK proporciona las siguientes API para desarrollar código nativo que se use en imágenes de sistema de Android 1.6 y versiones posteriores.

Biblioteca OpenGL ES 1.x

Los encabezados estándar de OpenGL ES <GLES/gl.h> y <GLES/glext.h> contienen las declaraciones necesarias para realizar llamadas de procesamiento de OpenGL ES 1.x desde el código nativo.

Para usar estos encabezados, vincula tu módulo nativo con /system/lib/libGLESv1_CM.so mediante la inclusión de la siguiente línea en el archivo Android.mk:

    LOCAL_LDLIBS := -lGLESv1_CM
    

Todos los dispositivos basados en Android admiten OpenGL ES 1.0, ya que Android proporciona un procesador de software compatible con Open GL 1.0 que se puede usar en dispositivos sin GPU.

Solo los dispositivos Android que cuenten con la GPU necesaria admiten plenamente OpenGL ES 1.1. Una aplicación puede consultar la string de versión y la string de extensión de OpenGL ES para determinar si el dispositivo actual admite las funciones que necesita. Para obtener información sobre cómo realizar esta consulta, lee la descripción de glGetString() en la especificación de OpenGL.

Además, debes agregar una etiqueta <uses-feature> al archivo de manifiesto para indicar la versión de OpenGL ES que necesita la aplicación.

Las API EGL solo están disponibles a partir del nivel 9 de API. No obstante, puedes usar la máquina virtual para realizar algunas de las operaciones que podrías llevar a cabo con esas API. Estas operaciones incluyen creación y cambio de superficies. Para ver un ejemplo de cómo usar GLSurfaceView, consulta Presentación de GLSurfaceView.

En aplicación de ejemplo san-angeles, se muestra una manera de realizar estas operaciones procesando cada fotograma en código nativo. Este ejemplo representa un puerto pequeño para Android del excelente programa en modo de demostración San Angeles Observation.

Nivel 5 de API de Android

El NDK proporciona las siguientes API para desarrollar código nativo que se use en imágenes de sistema de Android 2.0 y versiones posteriores.

Biblioteca OpenGL ES 2.0:

Los encabezados estándar de OpenGL ES 2.0 <GLES2/gl2.h> y <GLES2/gl2ext.h> contienen las declaraciones necesarias para realizar llamadas de procesamiento de OpenGL ES 2.0 desde el código nativo. Esas llamadas de procesamiento ofrecen la posibilidad de usar el lenguaje GLSL a fin de definir y emplear sombreadores de vértices y de fragmentos.

Para usar OpenGL ES 2.0, vincula tu módulo nativo con /system/lib/libGLESv2.so mediante la inclusión la siguiente línea en el archivo Android.mk:

    LOCAL_LDLIBS := -lGLESv2
    

No todos los dispositivos son compatibles con OpenGL ES 2.0. Una aplicación puede consultar la string de versión y la string de extensión de OpenGL ES para determinar si el dispositivo actual admite las funciones que necesita. Para obtener información sobre cómo realizar esta consulta, lee la descripción de glGetString() en la especificación de OpenGL.

Además, debes agregar una etiqueta <uses-feature> al archivo de manifiesto para indicar la versión de OpenGL ES que necesita la aplicación. Para obtener más información sobre la configuración de OpenGL ES para <uses-feature>, consulta OpenGL ES.

En el ejemplo de aplicación hello-gl2 se muestra un caso básico de uso de OpenGL ES 2.0 con el NDK.

Las API EGL solo están disponibles a partir del nivel 9 de API. No obstante, puedes usar la máquina virtual para realizar algunas de las operaciones que podrías llevar a cabo con esas API. Estas operaciones incluyen creación y cambio de superficies. Para ver un ejemplo de cómo usar GLSurfaceView, consulta Presentación de GLSurfaceView.

Nivel 8 de API de Android

El NDK proporciona las siguientes API para desarrollar código nativo que se use en imágenes de sistema de Android 2.2 y versiones posteriores.

jnigraphics

La biblioteca jnigraphics expone una interfaz basada en C que permite el acceso confiable de código nativo a los búferes de píxeles de los objetos bitmap de Java. El flujo de trabajo con jnigraphics es el siguiente:

  1. Usa AndroidBitmap_getInfo() para obtener información de JNI, como el ancho y la altura, acerca de un controlador de bitmap determinado.
  2. Usa AndroidBitmap_lockPixels() para bloquear el búfer de píxeles y recuperar un puntero. De este modo, te aseguras de que los píxeles no se muevan hasta que la aplicación llame a AndroidBitmap_unlockPixels().
  3. En el código nativo, modifica el búfer de píxeles según corresponda para su formato de píxeles, su ancho y otras características.
  4. Llama a AndroidBitmap_unlockPixels() para desbloquear el búfer.

Para usar jnigraphics, incluye el encabezado <bitmap.h> en el código fuente y vincula con jnigraphics agregando la siguiente línea en el archivo Android.mk:

    LOCAL_LDLIBS += -ljnigraphics
    

Puedes encontrar información adicional sobre esta función en los comentarios del archivo <android/bitmap.h>.

Nivel 9 de API de Android

El NDK proporciona las siguientes API para desarrollar código nativo que se use en imágenes de sistema de Android 2.3 y versiones posteriores.

EGL

EGL proporciona una interfaz de plataforma nativa para asignar y administrar superficies de OpenGLES. Para obtener más información sobre sus características, consulta Interfaz de plataforma nativa de EGL.

EGL permite realizar las siguientes operaciones a partir de código nativo:

  • Indicar las configuraciones de EGL admitidas.
  • Asignar y liberar superficies OpenGLES.
  • Alternar o cambiar superficies.

Los siguientes encabezados proporcionan funcionalidad EGL:

  • <EGL/egl.h>: Las definiciones de las API EGL principales
  • <EGL/eglext.h>: Las definiciones relacionadas con extensiones de EGL

Para establecer un vínculo con la biblioteca EGL del sistema, agrega la siguiente línea a tu archivo Android.mk:

    LOCAL_LDLIBS += -lEGL
    

OpenSL ES

El manejo de audio nativo de Android se basa en la OpenSL ES API 1.0.1 de Khronos Group.

Los encabezados estándar <SLES/OpenSLES.h> y <SLES/OpenSLES_Platform.h> de OpenSL ES contienen las declaraciones necesarias para realizar operaciones de entrada y salida de audio desde el lado nativo de Android. La distribución del NDK de OpenSL ES también proporciona extensiones específicas para Android. Para obtener información sobre esas extensiones, consulta los comentarios en <SLES/OpenSLES_Android.h> y <SLES/OpenSLES_AndroidConfiguration.h>.

La biblioteca libOpenSLES.so del sistema implementa las funciones de audio nativas públicas. Para establecer un vínculo con ella, agrega la siguiente línea al archivo Android.mk:

    LOCAL_LDLIBS += -lOpenSLES
    

Para obtener más información sobre la OpenSL ES API, consulta OpenSL ES para Android

API de aplicación nativa de Android

A partir del nivel 9 de API, puedes escribir una aplicación completa para Android con código nativo, sin usar Java.

Nota: Escribir tu aplicación en código nativo no es suficiente para que esta pueda ejecutarse en la máquina virtual. Además, la aplicación debe seguir accediendo a la mayoría de las funciones de la plataforma Android a través de JNI.

Esta versión proporciona los siguientes encabezados nativos:

Para obtener más información sobre esos encabezados, consulta la documentación de referencia para NDK API y los comentarios en los encabezados. Además, para obtener más información sobre el tema más amplio relacionado con la escritura de apps nativas, puedes consultar Aplicaciones y actividades nativas.

Cuando incluyes uno o más de esos encabezados, también debes establecer un vínculo con la biblioteca libandroid.so. Para establecer un vínculo con libandroid.so, incluye la siguiente línea en el archivo Android.mk:

    LOCAL_LDLIBS += -landroid
    

Nivel 14 de API de Android

El NDK proporciona las siguientes API para desarrollar código nativo que se use en imágenes de sistema de Android 4.0 y versiones posteriores.

OpenMAX AL

La administración multimedia nativa de Android se basa en la API de OpenMAX AL 1.0.1 de Khronos Group.

Los encabezados estándar de OpenMAX AL <OMXAL/OpenMAXAL.h> y <OMXAL/OpenMAXAL_Platform.h> contienen las declaraciones necesarias para realizar operaciones de salida multimedia desde el lado nativo de Android.

La distribución de OpenMAX AL en el NDK también proporciona extensiones específicas para Android. Para obtener información sobre esas extensiones, consulta los comentarios en <OMXAL/OpenMAXAL_Android.h>.

La biblioteca libOpenMAXAL.so del sistema implementa las funciones multimedia nativas públicas. Para establecer un vínculo con esta biblioteca, incluye la siguiente línea en el archivo Android.mk:

    LOCAL_LDLIBS += -lOpenMAXAL
    

Para obtener más información sobre este tema, consulta $NDK/docs/openmaxal/index.html, donde $NDK es el directorio raíz de tu instalación del NDK.

OpenSL ES

La compatibilidad con OpenSL ES para este nivel deAPI de Android agrega compatibilidad con PCM. Para obtener más información sobre la compatibilidad con OpenSL ES en el NDK, consulta OpenSL ES.

Nivel 18 de API de Android

El NDK proporciona las siguientes API para desarrollar código nativo que se use en imágenes de sistema de Android 4.3 y versiones posteriores.

OpenGL ES 3.0

Los encabezados estándar de OpenGL ES 3.0 <GLES3/gl3.h> y <GLES3/gl3ext.h> contienen las declaraciones necesarias para realizar llamadas de procesamiento de OpenGL ES 3.0 desde el código nativo. Esas llamadas de procesamiento ofrecen la posibilidad de usar el lenguaje GLSL a fin de definir y emplear sombreadores de vértices y de fragmentos.

Para usar OpenGL ES 3.0, vincula tu módulo nativo con /system/lib/libGLESv3.so mediante la inclusión de la siguiente línea en el archivo Android.mk:

    LOCAL_LDLIBS := -lGLESv3
    

No todos los dispositivos son compatibles con OpenGL ES 3.0. Una aplicación puede consultar la string de versión y la string de extensión de OpenGL ES para determinar si el dispositivo actual admite las funciones que necesita. Para obtener información sobre cómo realizar esta consulta, lee la descripción de glGetString() en la especificación de OpenGL.

Además, debes agregar una etiqueta <uses-feature> al archivo de manifiesto para indicar la versión de OpenGL ES que necesita la aplicación. Para obtener más información sobre la configuración de OpenGL ES para <uses-feature>, consulta OpenGL ES.

En el ejemplo de aplicación de gles3jni, se muestra un caso básico de uso de OpenGL ES 3.0 con el NDK.

Nivel 21 de API de Android

El NDK proporciona las siguientes API para desarrollar código nativo que se use en imágenes de sistema de Android 4.3 y versiones posteriores.

OpenGL ES 3.1

Los encabezados estándar de OpenGL ES 3.1 <GLES3/gl31.h> y <GLES3/gl3ext.h> contienen las declaraciones necesarias para realizar llamadas de procesamiento de OpenGL ES 3.1 desde el código nativo. Esas llamadas de procesamiento ofrecen la posibilidad de usar el lenguaje GLSL a fin de definir y emplear sombreadores de vértices y de fragmentos.

Para usar OpenGL ES 3.1, vincula tu módulo nativo con /system/lib/libGLESv3.so incluyendo la siguiente línea en el archivo Android.mk:

    LOCAL_LDLIBS := -lGLESv3
    

No todos los dispositivos son compatibles con OpenGL ES 3.1. Una aplicación puede consultar la string de versión y la string de extensión de OpenGL ES para determinar si el dispositivo actual admite las funciones que necesita. Para obtener información sobre cómo realizar esta consulta, lee la descripción de glGetString() en la especificación de OpenGL.

Además, debes agregar una etiqueta <uses-feature> al archivo de manifiesto para indicar la versión de OpenGL ES que necesita la aplicación. Para obtener más información sobre la configuración de OpenGL ES para <uses-feature>, consulta OpenGL ES.

En el ejemplo de aplicación de gles3jni, se muestra un caso básico de uso de OpenGL ES 3.1 con el NDK.

Nota: El emulador de Android no admite la emulación de OpenGL ES 3.1 asistida por hardware. La ejecución y prueba del código que usa esta API requiere un dispositivo real con hardware que admita OpenGL ES 3.1.

Nivel 23 de API de Android

El NDK proporciona las siguientes API para desarrollar código nativo que se use en imágenes de sistema de Android 6.0 y versiones posteriores.

Seguimiento

La API nativa de seguimiento (<android/trace.h>) ofrece el equivalente nativo de los métodos android.os.trace en el lenguaje de programación Java. Esta API permite hacer un seguimiento de ciertas unidades de trabajo en el código nativo; para ello, se escriben eventos de seguimiento en el búfer de seguimiento del sistema. A continuación, puedes recopilar y analizar los eventos de seguimiento con la herramienta Systrace. Para obtener más información sobre cómo usar esta API, consulta Seguimiento nativo.

Nivel 24 de API de Android

El NDK proporciona las siguientes API para desarrollar código nativo que se use en imágenes de sistema de Android 7.0 y versiones posteriores.

Vulkan

Esta es una API multiplataforma de baja sobrecarga para representación de gráficos 3D de alto rendimiento. Vulkan es un estándar abierto a cargo de Khronos Group. El archivo del encabezado estándar <vulkan/vulkan.h> contiene las declaraciones necesarias para realizar llamadas de procesamiento de Vulkan a partir del código nativo.

Para obtener más información sobre cómo usar Vulkan en aplicaciones de Android, consulta la documentación de la API. También puedes encontrar ejemplos de código en los proyectos vulkan-basic-samples y android-vulkan-tutorials en GitHub.

Cámara

La API de cámara nativa ofrece el equivalente nativo de las clases android.hardware.camera2 en el lenguaje de programación Java. La API de cámara nativa permite capturar y procesar fotos detalladas en tu código nativo. A diferencia de la API Camera2 de Java, la API de cámara nativa no admite implementaciones HAL 1.0 de cámara obsoletas (es decir, en la lista de cámaras disponibles en la API de cámara nativa, no figuran los dispositivos que tienen el nivel de hardware LEGACY).

Coreógrafo

La API de Choreographer nativa (<android/choreographer.h>) es el equivalente nativo de la clase android.view.Choreographer en Java. La API de Choreographer nativa brinda la posibilidad de coordinar la temporización de animaciones, entradas y dibujos en tu código nativo. Esta API es útil para la alternación de fotogramas, ya que proporciona sincronización mediante vsync. Para ver un ejemplo de cómo usar la API de Coreographer, consulta el directorio choreographer-30fps del proyecto de muestra Teapots en GitHub.

Multired

La API de Multinetwork nativa (<android/multinetwork.h>) proporciona acceso de código nativo a la misma funcionalidad que las API de redes múltiples de Java que se agregaron a Android 5.0.

EGL

La compatibilidad de EGL para el Nivel 24 de API de Android incorpora compatibilidad con las siguientes extensiones:

Para obtener más información sobre la compatibilidad con EGL en el NDK, consulta EGL.

OpenGL ES 3.2

Los encabezados estándar de OpenGL ES 3.2 <GLES3/gl32.h> y <GLES3/gl3ext.h> contienen las declaraciones necesarias para realizar llamadas de procesamiento de OpenGL ES 3.2 desde el código nativo.

Para usar OpenGL ES 3.2, vincula tu módulo nativo con /system/lib/libGLESv3.so incluyendo la siguiente línea en el archivo Android.mk:

    LOCAL_LDLIBS := -lGLESv3
    

No todos los dispositivos son compatibles con OpenGL ES 3.2. Una aplicación puede consultar la string de versión y la string de extensión de OpenGL ES para determinar si el dispositivo actual admite las funciones que necesita. Para obtener información sobre cómo realizar esta consulta, lee la descripción de glGetString() en la especificación de OpenGL.

Además, debes agregar una etiqueta <uses-feature> al archivo de manifiesto para indicar la versión de OpenGL ES que necesita la aplicación. Para obtener más información sobre la configuración de OpenGL ES para <uses-feature>, consulta OpenGL ES.

Nivel 26 de API de Android

El NDK proporciona las siguientes API para desarrollar código nativo que se use en imágenes de sistema de Android 8.0 y versiones posteriores.

AAudio

El NDK presenta la API de AAudio (<aaudio/AAudio.h>) para las aplicaciones de audio de alto rendimiento que requieren baja latencia. Las aplicaciones que usan AAudio, leen y escriben datos en transmisiones de audio. AAudio fue pensada como una alternativa más sencilla frente a OpenSL ES. Si deseas obtener más información sobre cómo usar esta API, consulta la guía para desarrolladores de AAudio.

Búfer de hardware

El NDK presenta dos API nativas que permiten crear tus propios canales para la administración de búfer entre procesos.

La API de búfer de hardware nativa (<android/hardware_buffer.h>) permite asignar búferes de forma directa a fin de crear tus propios canales para la administración de búfer entre procesos. Puedes asignar una estructura AHardwareBuffer y usarla para obtener un tipo de recurso EGLClientBuffer a través del a extensión eglGetNativeClientBufferANDROID. Puedes pasar ese búfer a eglCreateImageKHR para crear un tipo de recurso EGLImage, que luego se puede vincular a una textura por medio de glEGLImageTargetTexture2DOES en dispositivos compatibles. Este método puede resultar útil para crear texturas que pueden compartirse entre procesos.

La API de JNI de búfer de hardware nativa (<android/hardware_buffer_jni.h>) te permite obtener un objeto HardwareBuffer, que es un Parcelable y, por lo tanto, puede transportarse entre dos procesos diferentes. De este modo, tu aplicación cuenta con capacidades similares a las de SurfaceFlinger (como la creación de tu propia cola de búferes entre procesos) sin tener que acceder a las API de Android internas.

Memoria compartida

La API de memoria compartida (<android/sharedmem.h>) es un contenedor en torno a la memoria compartida nativa de Android. Puede usarse para la comunicación interna en los procesos. Después de crear memoria compartida, se devuelve un descriptor de archivos como controlador. Puedes acceder al contenido de la memoria compartida después de asignar el descriptor de archivos a un espacio de memoria del proceso mediante mmap(). Para quitar la asignación, llama a munmap(). Los descriptores de archivos pueden intercambiarse con otro proceso mediante sockets de dominio UNIX. El sistema libera memoria compartida asignada una vez que los descriptores de archivos asociados se cierran y que se quitan todas las asignaciones de memoria en la totalidad de los procesos.

Nivel 27 de API de Android

El NDK proporciona las siguientes API para desarrollar código nativo que se use en imágenes de sistema de Android 8.1 y versiones posteriores.

API de Neural Networks

La API de Neural Networks (<android/neuralnetworks.h>) ofrece a las aplicaciones aceleración de hardware para las operaciones de aprendizaje automático en el dispositivo. La API permite crear, compilar y ejecutar modelos en el dispositivo. En general, las aplicaciones no usan NNAPI directamente. En su lugar, a la API deben llamarla bibliotecas, marcos de trabajo y herramientas de aprendizaje automático que permitan a los desarrolladores preparar sus modelos e implementarlos en dispositivos Android. Si deseas obtener más información, consulta la guía para desarrolladores de Neural Networks API y Referencia de API.