API nativas del NDK de Android

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 de API de Android. En esta página, se explican esos encabezados y archivos, y se asignan a niveles de API de Android específicos.

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 en el archivo Android.mk. Por ejemplo, para vincular con /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 el uso de 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 Incluye
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 API de Android bitmap #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 nativas de cámara #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>
API nativa de Choreographer #include <android/choreographer.h>
API nativa de Multinetwork #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 Shared Memory #include <android/sharedmem.h>
27 8.1 API de Neural Networks #include <android/NeuralNetworks.h>
JNI API de memoria compartida #include <android/hardware_buffer.h>>

Aspectos importantes de la API nativa

Nivel 3 de la 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 vínculo 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 compatibilidad con bibliotecas C++, consulta Compatibilidad de la biblioteca C++.

Compatibilidad de registros específicos de Android

<android/log.h> contiene varias definiciones que una app puede usar para enviar mensaje sde registro al kernel a partir de 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 registrarte, debes hacer la vinculación con liblog. Por ejemplo:
LOCAL_LDLIBS := -llog

Biblioteca de compresión ZLib

Puedes usar la biblioteca de compresión Zlib incluyendo 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 la 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 <GLES/gl.h> y <GLES/glext.h> estándares de OpenGL ES contienen las declaraciones necesarias para realizar llamadas de representación de OpenGL ES 1.x a partir de código nativo.

Para usar estos encabezados, vincula tu módulo nativo con /system/lib/libGLESv1_CM.so incluyendo 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 representador 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 las cadenas de versión y 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 disponer una etiqueta <uses-feature> en el archivo de manifiesto para indicar la versión de OpenGL ES que necesita la aplicación.

Las API de 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. Esas operaciones incluyen creación y cambio de superficie. Para acceder a un ejemplo de uso de GLSurfaceView, consulta Presentación de GLSurfaceView.

En el ejemplo de aplicación san-angeles, se muestra una manera de realizar estas operaciones representando 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 la 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 <GLES2/gl2.h> y <GLES2/gl2ext.h> estándar de OpenGL ES 2.0 contienen las declaraciones necesarias para realizar llamadas de representación de OpenGL ES 2.0 a partir de código nativo. Esas llamadas de representación proporcionan la capacidad para usar el lenguaje GLSL a fin de definir y usar sombreadores Vertex y de fragmentos.

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

LOCAL_LDLIBS := -lGLESv2

No todos los dispositivos admiten OpenGL ES 2.0. Una aplicación puede consultar las cadenas de versión y 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 disponer una etiqueta <uses-feature> en el 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 de 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. Esas operaciones incluyen creación y cambio de superficie. Para acceder a un ejemplo de uso de GLSurfaceView, consulta Presentación de GLSurfaceView.

Nivel 8 de la 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 para usar 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 tu código fuente y vincúlalo con jnigraphics incluyendo 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 la 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 te 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 principales API de EGL.
  • <EGL/eglext.h>: Definiciones relacionadas con la extensión 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 API de OpenSL ES 1.0.1 de Khronos Group.

Los encabezados estándares <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 también proporciona extensiones específicas para 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. Establece un vínculo con ella agregando la siguiente línea a tu archivo Android.mk:

LOCAL_LDLIBS += -lOpenSLES

Para obtener más información sobre la API de OpenSL ES, 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 la API de NDK 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 aplicaciones 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 la 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ándares <OMXAL/OpenMAXAL.h> y <OMXAL/OpenMAXAL_Platform.h> de OpenMAX AL 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 de Android API 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 la 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 <GLES3/gl3.h> y <GLES3/gl3ext.h> estándar de OpenGL ES 3.0 contienen las declaraciones necesarias para realizar llamadas de representación de OpenGL ES 3.0 a partir de código nativo. Esas llamadas de representación proporcionan la capacidad para usar el lenguaje GLSL a fin de definir y usar sombreadores Vertex y de fragmentos.

Para usar OpenGL ES 3.0, 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 admiten OpenGL ES 3.0. Una aplicación puede consultar las cadenas de versión y 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 disponer una etiqueta <uses-feature> en el 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 la 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 <GLES3/gl31.h> y <GLES3/gl3ext.h> estándar de OpenGL ES 3.1 contienen las declaraciones necesarias para realizar llamadas de representación de OpenGL ES 3.1 a partir de código nativo. Esas llamadas de representación proporcionan la capacidad para usar el lenguaje GLSL a fin de definir y usar sombreadores Vertex 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 admiten OpenGL ES 3.1. Una aplicación puede consultar las cadenas de versión y 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 disponer una etiqueta <uses-feature> en el 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 la 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>) proporciona 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 el uso de esta API, consulta Seguimiento nativo.

Nivel 24 de la 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 que sostiene Khronos Group. El archivo del encabezado estándar <vulkan/vulkan.h> contiene las declaraciones necesarias para realizar llamadas de representación de Vulkan a partir del código nativo.

Para obtener más información sobre el uso de Vulkan en aplicaciones de Android, consulta la documentación de la API. Para ver ejemplos de código, consulta los proyectos vulkan-basic-samples y android-vulkan-tutorials en GitHub.

Cámara

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

Coreógrafo

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

Redes múltiples

La API nativa de Multinetwork (<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 la API de Android incorpora compatibilidad con las siguientes extensiones:

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

OpenGL ES 3.2

Los encabezados <GLES3/gl32.h> y <GLES3/gl3ext.h> estándar de OpenGL ES 3.2 contienen las declaraciones necesarias para realizar llamadas de representación de OpenGL ES 3.2 a partir de 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 admiten OpenGL ES 3.2. Una aplicación puede consultar las cadenas de versión y 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 disponer una etiqueta <uses-feature> en el 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 la 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 flujos de audio. AAudio fue pensada como una alternativa más sencilla frente a OpenSL ES. Para obtener más información sobre el uso de 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 flujos de procesamiento para la administración de búfer entre procesos.

La API nativa de búfer de hardware (<android/hardware_buffer.h>) permite asignar búferes de forma directa a fin de crear tus propios flujos de procesamiento 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 el búfer a eglCreateImageKHR para crear un tipo de recurso EGLImage; este, a su vez, puede vincularse a una textura a través de glEGLImageTargetTexture2DOES en los dispositivos compatibles. Este método puede resultar útil para crear texturas que pueden compartirse entre procesos.

La JNI API nativa de búfer de hardware (<android/hardware_buffer_jni.h>) 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 las mismas capacidades que SurfaceFlinger (como la creación de tu propia cola de búferes entre procesos) sin tener que acceder a las API internas de Android.

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 la 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 admite la creación, compilación y ejecución de modelos en el dispositivo. En general, las aplicaciones no usan NNAPI directamente. En cambio, la API debe ser llamada por bibliotecas, marcos de trabajo y herramientas de aprendizaje automático que permitan a los desarrolladores preparar sus modelos e implementarlos en dispositivos Android. Para obtener más información, consulta la guía para desarrolladores de la API de Neural Networks y la referencia sobre API.