APIs nativas do Android NDK

O Android NDK oferece um conjunto de cabeçalhos nativos e arquivos de biblioteca compartilhada que cresceram gradualmente com os sucessivos lançamentos de novos níveis para a Android API. Esta página explica esses cabeçalhos e arquivos e mapeia-os a níveis específicos da Android API.

Como usar APIs nativas

Há duas etapas básicas para se habilitar o aplicativo a usar as bibliotecas que o NDK oferece:

  1. Inclua no seu código os cabeçalhos associados às bibliotecas que quer usar.
  2. Informe o sistema de compilação de que seu módulo nativo precisa se vincular às bibliotecas em tempo de carregamento.
    • Caso você esteja usando o ndk-build: Adicione a biblioteca nativa à variável LOCAL_LDLIBS no arquivo Android.mk. Por exemplo, para vincular a /system/lib/libfoo.so, adicione a seguinte linha:
    • LOCAL_LDLIBS := -lfoo
      

      Para listar diversas bibliotecas, use um espaço como delimitador. Para saber mais como usar a variável LOCAL_LDLIBS, consulte Android.mk.

    • Caso você esteja usando o CMake: Siga as instruções em Adicione código C e C++ ao seu projeto.
Para todos os níveis de API, o sistema de compilação vincula automaticamente as bibliotecas de padrão C e C++. Não é necessário incluí-las de forma explicita ao definir LOCAL_LDLIBS.

Muitas vezes, o NDK oferece novos cabeçalhos e bibliotecas para novas versões do Android. Para uma lista de APIs nativas apresentadas pela versão de lançamento do Android, acesse Tabela 1 abaixo. Esses arquivos residem na sua raiz de instalação NDK, abaixo do sysroot/usr/include.

A tabela a seguir mostra a correspondência entre níveis API compatíveis com o NDK e as plataformas de lançamento do Android. Para maiores informações sobre os níveis da Android API, consulte O que é um nível de API?.

Tabela 1. Resumo da chave compatível com API nativa apresentada pela versão Android.

Nível da API suportado pelo NDK Plataforma de lançamento Android Chaves de APIs nativas Inclui
3 1.5 Biblioteca padrão C(libc/libm) #include ...
C++ #include ...
Interface Java nativa #include <jni.h>
API geração de registros do 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 bitmap do Android #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>
APIs de aplicativo nativo Loop de Event:
#include <android/looper.h>

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

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

Gerenciamento de janela/superfície
#include <android/rect.h>
#include <android/window.h>
#include <android/native_window.h>
#include <android/native_window_jni.h>

Ativos:
#include <android/asset_manager.h>

Configuração:
#include <android/configuration.h>

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

#include <android/obb.h>

Atividade 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>
APIs nativas de mídia #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 rastreamento #include <android/trace.h>
24 7.0 - 7.1.1 Vulkan #include <vulkan/vulkan.h>
APIs nativas de câmera #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 choreographer #include <android/choreographer.h>
API nativa multirrede #include <android/multinetwork.h>
OpenGL ES 3.2 #include <GLES3/gl32.h>
#include <GLES3/gl3ext.h>
APIs nativas de mídia #include <media/NdkImage.h>
#include <media/NdkImageReader.h>
26 8.0 API AAudio #include <aaudio/AAudio.h>
APIs de hardware buffer #include <android/hardware_buffer.h>
#include <android/hardware_buffer_jni.h>>
API Shared Memory #include <android/sharedmem.h>
27 8.1 API Neural Networks: #include <android/NeuralNetworks.h>
API de memória compartilhada JNI #include <android/hardware_buffer.h>>

Destaques da API nativa

Android API de nível 3

Biblioteca C

Os cabeçalhos da biblioteca padrão C estão disponíveis por meio de seus nomes comuns, como <stdlib.h> e <stdio.h>. Observe que o Android, diferente do Linux, não tem bibliotecas pthread e rt separadas. Essa funcionalidade está inclusa na libc. A biblioteca math permanece separada na libm, mas está automaticamente adicionada pelo compilador.

Biblioteca do vinculador dinâmico

Você pode acessar as funcionalidades dlopen(3) e dlsym(3) do vinculador dinâmico do Android. Você também precisa vincular a libdl. Por exemplo:
LOCAL_LDLIBS := -ldl

Biblioteca C++

A compatibilidade C++17 está disponível. Para maiores informações sobre a compatibilidade com a biblioteca C++, consulte Compatibilidade com a biblioteca C++.

Compatibilidade com registros específicos do Android

O <android/log.h> contém diversas definições que um aplicativo pode usar para enviar mensagens de registro ao logcat a partir do código nativo. Para maiores informações sobre essas definições, veja a documentação da geração de registros. Normalmente, você deve gravar macros de invólucro próprios para acessar esse recurso. Caso queira fazer um registro, vincule a liblog. Por exemplo:
LOCAL_LDLIBS := -llog

Biblioteca de compressão ZLib

Você pode usar a biblioteca de compressão ZLib inclusive zlib.h e zconf.h. Além disso, você precisa vincular seu módulo nativo a /system/lib/libz.so inclusive a seguinte linha no arquivo Android.mk:

LOCAL_LDLIBS := -lz

Android API de nível 4

O NDK fornece as seguintes APIs para desenvolver código nativo executado em imagens do sistema do Android 1.6 e em posteriores.

Biblioteca do OpenGL ES 1.x

Os cabeçalhos <GLES/gl.h> e <GLES/glext.h> padrão do OpenGL ES contêm as declarações necessárias para realizar as chamadas de renderização do OpenGL ES 1.x a partir do código nativo.

Para usá-los, vincule seu módulo nativo a /system/lib/libGLESv1_CM.so inclusive a seguinte linha ao arquivo Android.mk:

LOCAL_LDLIBS := -lGLESv1_CM

Todos os dispositivos baseados em Android são compatíveis com OpenGL ES 1.0, porque o Android fornece um renderizador de software preparado para Open GL 1.0 que pode ser usado em dispositivos sem GPUs.

Somente dispositivos Android que têm o GPU necessário oferecem compatibilidade integral com OpenGL ES 1.1. Um aplicativo pode consultar a string de versão e a de extensão do OpenGL ES para determinar se o dispositivo atual aceita os recursos que o aplicativo precisa. Para informações sobre como realizar essa consulta, consulte a descrição de glGetString() na especificação do OpenGL.

Além disso, você deve colocar uma tag <uses-feature> no seu arquivo de manifesto para indicar a versão do OpenGL ES de que seu aplicativo precisa.

As APIs EGL só estão disponíveis a partir da API de nível 9. No entanto, é possível usar a VM para realizar algumas das operações que se obteria com essas APIs. Essas operações abrangem a criação e inversão de superfícies. Para ver um exemplo de como usar GLSurfaceView, consulte Introdução ao GLSurfaceView.

O exemplo de aplicativo san-angeles fornece uma demonstração de como realizar essas operações, renderizando cada quadro no código nativo. Esse exemplo é uma pequena porta do Android do excelente programa de demonstração San Angeles Observation.

Android API de nível 5

O NDK fornece as seguintes APIs para desenvolver código nativo executado em imagens do sistema do Android 2.0 e em posteriores.

Biblioteca do OpenGL ES 2.0:

Os cabeçalhos <GLES2/gl2.h> e <GLES2/gl2ext.h> padrão do OpenGL ES 2.0 contêm as declarações necessárias para realizar as chamadas de renderização do OpenGL ES 2.0 a partir do código nativo. Essas chamadas de renderização fornecem a capacidade de usar a linguagem GLSL para definir e usar sombreadores de vértice e fragmento.

Para usar o OpenGL ES 2.0, vincule seu módulo nativo a /system/lib/libGLESv2.so inclusive a seguinte linha ao arquivo Android.mk:

LOCAL_LDLIBS := -lGLESv2

Nem todos os dispositivos oferecem compatibilidade com o OpenGL ES 2.0. Um aplicativo pode consultar a string de versão e a de extensão do OpenGL ES para determinar se o dispositivo atual é compatível com os recursos que o aplicativo precisa. Para informações sobre como realizar essa consulta, consulte a descrição de glGetString() na especificação do OpenGL.

Além disso, você deve colocar uma tag <uses-feature> no seu arquivo de manifesto para indicar que versão do OpenGL ESo seu aplicativo precisa. Para saber mais sobre as configurações do OpenGL ES para <uses-feature>, consulte OpenGL ES.

O exemplo de aplicativo hello-gl2 fornece uma demonstração básica de como usar o OpenGL ES 2.0 com oNDK.

As APIs EGL só estão disponíveis a partir da API de nível 9. No entanto, é possível usar a VM para realizar algumas das operações que se obteria com essas APIs. Essas operações abrangem a criação e inversão de superfícies. Para ver um exemplo de como usar GLSurfaceView, consulte Introdução ao GLSurfaceView.

Android API de nível 8

O NDK fornece as seguintes APIs para desenvolver código nativo executado em imagens do sistema do Android 2.2 e em posteriores.

jnigraphics

A biblioteca jnigraphics expõe uma interface baseada em C que permite que o código nativo acesse os buffers de pixel dos objetos bitmap do Java de forma segura. O fluxo de trabalho para usar jnigraphics é o seguinte:

  1. Use AndroidBitmap_getInfo() para recuperar informações do JNI, como largura e altura, sobre determinado identificador de bitmap.
  2. Use AndroidBitmap_lockPixels() para bloquear o buffer de pixel e recuperar um ponteiro para ele. Fazer isso garante que os pixels não se movam até que o aplicativo chame AndroidBitmap_unlockPixels().
  3. No código nativo, modifique o buffer de pixel conforme a necessidade quanto ao formato, à largura e a outras características do pixel.
  4. Chame AndroidBitmap_unlockPixels() para desbloquear o buffer.

Para usar jnigraphics, inclua o cabeçalho <bitmap.h> no código-fonte e vincule-o a jnigraphics, inclusive a linha a seguir ao arquivo Android.mk:

LOCAL_LDLIBS += -ljnigraphics

Você pode encontrar mais detalhes sobre esse recurso nos comentários do arquivo <android/bitmap.h>.

Android API de nível 9

O NDK fornece as seguintes APIs para desenvolver código nativo que seja executado em imagens do sistema do Android 2.3 e posteriores.

EGL

O EGL fornece uma interface de plataforma nativa para alocar e gerenciar superfícies do OpenGL ES. Para saber mais sobre seus recursos, consulte Interface de plataforma nativa do EGL.

O EGL permite realizar as seguintes operações a partir do código nativo:

  • Listar configurações de EGL compatíveis.
  • Alocar e lançar superfícies do OpenGL ES.
  • Trocar ou inverter superfícies.

Os cabeçalhos a seguir fornecem os recursos do EGL:

  • <EGL/egl.h>: as principais definições da API EGL.
  • <EGL/eglext.h>: definições relacionadas à extensão de EGL.

Para criar vínculo com a biblioteca EGL do sistema, adicione a seguinte linha ao arquivo Android.mk:

LOCAL_LDLIBS += -lEGL

OpenSL ES

O gerenciamento de áudio nativo do Android se baseia na API do Open SL ES 1.0.1 do Khronos Group.

Os cabeçalhos <SLES/OpenSLES.h> e <SLES/OpenSLES_Platform.h> padrão do OpenSL contêm as declarações necessárias para se realizar entrada e saída de áudio no lado nativo do Android. A distribuição do OpenSL ES do NDK também fornece extensões específicas do Android. Para saber mais sobre essas extensões, leia os comentários em <SLES/OpenSLES_Android.h> e <SLES/OpenSLES_AndroidConfiguration.h>.

A biblioteca libOpenSLES.so do sistema implementa as funções públicas de áudio nativo. Estabeleça vínculo com ela adicionando a seguinte linha ao arquivo Android.mk:

LOCAL_LDLIBS += -lOpenSLES

Para saber mais sobre a API do OpenSL ES, consulte OpenSL ES para Android

APIs de aplicativo nativo Android

A partir da API de nível 9, é possível programar um aplicativo Android somente com código nativo, sem usar Java.

Observação: Programar o aplicativo com código nativo não é, em si, suficiente para que o aplicativo seja executado na VM. Além disso, o aplicativo ainda precisa acessar a maioria dos recursos da plataforma Android via JNI.

Essa versão fornece os seguintes cabeçalhos nativos:

Para saber mais sobre esses cabeçalhos, consulte a documentação de referência da NDK API, além dos comentários nos próprios cabeçalhos. Além disso, para obter mais detalhes sobre o abrangente assunto de programar aplicativos nativos, consulte Atividades e aplicativos nativos.

Ao incluir um ou mais desses cabeçalhos, você também deve vinculá-lo(s) à biblioteca libandroid.so. Para vincular a libandroid.so, inclua a seguinte linha ao arquivo Android.mk:

LOCAL_LDLIBS += -landroid

Android API de nível 14

O NDK fornece as seguintes APIs para desenvolver código nativo que seja executado em imagens do sistema do Android 4.0 e posteriores.

OpenMAX AL

O gerenciamento de multimídia nativa do Android baseia-se na API do OpenMAX AL 1.0.1 do Khronos Group.

Os cabeçalhos <OMXAL/OpenMAXAL.h> e <OMXAL/OpenMAXAL_Platform.h> padrão do OpenMAX AL contêm as declarações necessárias para se realizar saída multimídia do lado nativo do Android.

A distribuição do OpenMAX AL do NDK também fornece extensões específicas do Android. Para informações sobre essas extensões, leia os comentários em <OMXAL/OpenMAXAL_Android.h>.

A biblioteca libOpenMAXAL.so do sistema implementa as funções públicas de áudio nativo. Para vincular a essa biblioteca, inclua a seguinte linha no arquivo Android.mk:

    LOCAL_LDLIBS += -lOpenMAXAL

Para saber mais sobre esse assunto, consulte $NDK/docs/openmaxal/index.html,em que $NDK é o diretório raiz da instalação do NDK.

OpenSL ES

O OpenSL ES oferece compatibilidade para esse nível da Android API adicionar suporte a PCM. Para saber mais sobre a compatibilidade com OpenSL ES do NDK, consulte OpenSL ES.

Android API de nível 18

O NDK fornece as seguintes APIs para desenvolver código nativo que seja executado em imagens do sistema do Android 4.3 e posteriores.

OpenGL ES 3.0

Os cabeçalhos <GLES3/gl3.h> e <GLES3/gl3ext.h> padrão do OpenGL ES 3.0 contêm as declarações necessárias para realizar as chamadas de renderização do OpenGL ES 3.0 a partir do código nativo. Essas chamadas de renderização fornecem a capacidade de usar a linguagem GLSL para definir e usar sombreadores de vértice e fragmento.

Para usar o OpenGL ES 3.0, vincule seu módulo nativo a /system/lib/libGLESv3.so inclusive a seguinte linha ao arquivo Android.mk:

LOCAL_LDLIBS := -lGLESv3

Nem todos os dispositivos oferecem compatibilidade com o OpenGL ES 3.0. Um aplicativo pode consultar a string de versão e a de extensão do OpenGL ES para determinar se o dispositivo atual é compatível com os recursos que o aplicativo precisa. Para informações sobre como realizar essa consulta, consulte a descrição de glGetString() na especificação do OpenGL.

Além disso, você deve colocar uma tag <uses-feature> no seu arquivo de manifesto para indicar que versão do OpenGL ESo seu aplicativo precisa. Para saber mais sobre as configurações do OpenGL ES para <uses-feature>, consulte OpenGL ES.

O exemplo de aplicativo gles3jni fornece uma demonstração básica de como usar o OpenGL ES 3.0 com oNDK.

Android API de nível 21

O NDK fornece as seguintes APIs para desenvolver código nativo que seja executado em imagens do sistema do Android 4.3 e posteriores.

OpenGL ES 3.1

Os cabeçalhos <GLES3/gl31.h> e <GLES3/gl3ext.h> padrão do OpenGL ES 3.1 contêm as declarações necessárias para realizar as chamadas de renderização do OpenGL ES 3.1 a partir do código nativo. Essas chamadas de renderização fornecem a capacidade de usar a linguagem GLSL para definir e usar sombreadores de vértice e fragmento.

Para usar o OpenGL ES 3.1, vincule seu módulo nativo a /system/lib/libGLESv3.so inclusive a seguinte linha ao arquivo Android.mk:

LOCAL_LDLIBS := -lGLESv3

Nem todos os dispositivos oferecem compatibilidade com o OpenGL ES 3.1. Um aplicativo pode consultar a string de versão e a de extensão do OpenGL ES para determinar se o dispositivo atual é compatível com os recursos que o aplicativo precisa. Para informações sobre como realizar essa consulta, consulte a descrição de glGetString() na especificação do OpenGL.

Além disso, você deve colocar uma tag <uses-feature> no seu arquivo de manifesto para indicar que versão do OpenGL ESo seu aplicativo precisa. Para saber mais sobre as configurações do OpenGL ES para <uses-feature>, consulte OpenGL ES.

O exemplo de aplicativo gles3jni fornece uma demonstração básica de como usar o OpenGL ES 3.1 com oNDK.

Observação: O emulador Android não é compatível com a emulação de hardware do OpenGL ES 3.1. Executar e testar código que usa essa API exige um dispositivo real com hardware que possa suportar o OpenGL ES 3.1.

Android API de nível 23

O NDK fornece as seguintes APIs para desenvolver código nativo que seja executado em imagens do sistema do Android 6.0 e posteriores.

Rastreamento

A API de rastreamento nativa (<android/trace.h>) oferece o equivalente nativo dos métodos android.os.trace na linguagem de programação Java. Essa API permite que você rastreie unidades nomeadas de trabalho no seu código nativo programando eventos de rastreamento ao buffer de rastreamento do sistema. Você pode então coletar e analisar os eventos de rastreamento usando a ferramenta Systrace. Para maiores informações sobre o uso dessa API, acesse Rastreamento nativo.

Android API de nível 24

O NDK fornece as seguintes APIs para desenvolver código nativo que seja executado em imagens do sistema do Android 7.0 e posteriores.

Vulkan

O Vulkan é uma API multiplataforma de baixa sobrecarga para gráficos 3D de alto desempenho. O Vulkan é um padrão aberto mantido pelo grupo Khronos. O arquivo de cabeçalho padrão <vulkan/vulkan.h> contém as declarações necessárias para realizar chamadas de renderização Vulkan a partir do seu código nativo.

Para saber mais sobre o uso do Vulkan nos aplicativos Android, acesse a documentação API. Para exemplos de código, acesse os projetos no GitHub: exemplos básicos do Vulkan e tutoriais do Android Vulkan.

Câmera

A API nativa de câmera oferece o equivalente nativo dos métodos android.hardware.camera2 na linguagem de programação Java. A API da câmera nativa permite realizar captura e processamento de fotos refinadas em seu código nativo. Diferente da API Java camera2, a API nativa de câmera não é compatível com as obsoletas implementações HAL 1.0 de câmera (ou seja, a lista de câmera disponível na API nativa de câmera não lista dispositivos de câmera que têm o nível de hardware LEGACY).

Choreographer

A API nativa choreographer (<android/choreographer.h>) é a nativa equivalente da classe android.view.Choreographer no Java. Com a API nativa choreographer, você pode coordenar o tempo de animações, a entrada, bem como desenhar no seu código nativo. Essa API é útil para o controle de frames, fornecendo sincronização com o vsync. Para um exemplo de como usar a API choreographer, veja o diretório choreographer-30fps no projeto de exemplo Teapots no GitHub.

Multirrede

A API nativa multirrede (<android/multinetwork.h>) fornece acesso de código nativo para a mesma funcionalidade das APIs multirrede Java, que foramadicionadas no Android 5.0.

EGL

A compatibilidade para Android API de nível 24 contém suporte para as seguintes extensões:

Para mais informações sobre compatibilidade EGL no NDK, acesse EGL.

OpenGL ES 3.2

Os cabeçalhos <GLES3/gl32.h> e <GLES3/gl3ext.h> padrão do OpenGL ES 3.2 contêm as declarações necessárias para realizar as chamadas de renderização do OpenGL ES 3.2 a partir do código nativo.

Para usar o OpenGL ES 3.2, vincule seu módulo nativo a /system/lib/libGLESv3.so inclusive a seguinte linha ao arquivo Android.mk:

LOCAL_LDLIBS := -lGLESv3

Nem todos os dispositivos oferecem compatibilidade com o OpenGL ES 3.2. Um aplicativo pode consultar a string de versão e a de extensão do OpenGL ES para determinar se o dispositivo atual é compatível com os recursos que o aplicativo precisa. Para informações sobre como realizar essa consulta, consulte a descrição de glGetString() na especificação do OpenGL.

Além disso, você deve colocar uma tag <uses-feature> no seu arquivo de manifesto para indicar que versão do OpenGL ESo seu aplicativo precisa. Para saber mais sobre as configurações do OpenGL ES para <uses-feature>, consulte OpenGL ES.

Android API de nível 26

O NDK fornece as seguintes APIs para desenvolver código nativo que seja executado em imagens do sistema do Android 8.0 e posteriores.

AAudio

O NDK fornece a API AAudio (<aaudio/AAudio.h>) para aplicativos de áudio de alto desempenho que exigem latência baixa. Os aplicativos que usam AAudio leem e escrevem dados para stream de áudio. O AAudio destina-se a ser uma alternativa mais fácil que usar o OpenSL ES. Para mais informações sobre o uso dessa API, acesse o Guia do desenvolvedor AAudio.

Buffer de hardware

O NDK fornece duas APIs nativas que permitem a criação de seus próprios canais para gerenciamento de buffer em processo cruzado.

A API nativa de buffer de hardware (<android/hardware_buffer.h>) permite que você aloque diretamente buffers para criar seu próprio canal para gerenciamento de buffer em processo cruzado. Você pode alocar uma estrutura AHardwareBuffer e usá-la para conseguir um tipo de recurso EGLClientBuffer por meio da extensão eglGetNativeClientBufferANDROID. Você pode passar esse buffer para eglCreateImageKHR, criando assim um tipo de recurso EGLImage, que pode então ser vinculado à uma textura por meio de glEGLImageTargetTexture2DOES nos dispositivos compatíveis. Isso pode ser útil para criar texturas que podem ser compartilhadas em processo cruzado.

A API nativa de buffer de hardware JNI ( <android/hardware_buffer_jni.h>) permite que você tenha um objeto HardwareBuffer, que é um Parcelable e assim pode ser transportado entre dois processos diferentes. Isso dá ao aplicativo capacidades semelhantes ao SurfaceFlinger (como criar sua própria fila de buffers entre processos) sem acessar APIs internas do Android.

Memória compartilhada

A API de memória compartilhada (<android/sharedmem.h>) é um wrapper entre a memória compartilhada nativa do Android. Ela pode ser usada para comunicação de processos internos. Na criação da memória compartilhada, um descritor de arquivo é retornado como o identificador. Você pode acessar o conteúdo da memória compartilhada após mapear o descritor de arquivos no espaço de memória do processo ao usar mmap(). Para remover o mapeamento, chame munmap(). Os descritores de arquivos podem ser trocados com outro processo por meio de soquetes de domínio UNIX. O sistema libera a memória compartilhada alocada após os descritores de arquivos associados serem fechados e todos os mapas de memória serem desmapeados em todos os processos.

Android API de nível 27

O NDK fornece as seguintes APIs para desenvolver código nativo que seja executado em imagens do sistema do Android 8.1 e posteriores.

API Neural Networks

A API Neural Networks (<android/neuralnetworks.h>) fornece aplicativos com aceleração de hardware para operações de aprendizado de máquina no dispositivo. A API é compatível com o modelo de criação, compilação e execução no dispositivo. Os aplicativos normalmente não usam a NNAPi diretamente. Ao invés disso, ela deve ser chamada por bibliotecas de aprendizado de máquina, bibliotecas e ferramentas que permitam que os desenvolvedores treinem seus modelos fora do dispositivo e implantem-nos em dispositivos Android. Para saber mais, acesse o guia do desenvolvedor da API Neural Networks e a referência de API.