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 da API do Android. Esta página explica esses cabeçalhos e arquivos e os mapeia em níveis da API do Android específicos.

Como usar APIs nativas

Há duas etapas básicas para habilitar o app para usar as bibliotecas que o NDK fornece:

  1. Inclua no seu código os cabeçalhos associados às bibliotecas que você quer usar.
  2. Informe o sistema de compilação de que seu módulo nativo precisa se vincular às bibliotecas em tempo de carregamento.
    • Se você estiver 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 linha a seguir:
    •     LOCAL_LDLIBS := -lfoo
          

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

    • Se você estiver 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 da versão vincula automaticamente as bibliotecas C e C++ padrão. 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 ver uma lista das APIs nativas introduzidas pela versão de lançamento do Android, consulte a Tabela 1 abaixo. Esses arquivos ficam localizados na raiz de instalação do NDK, em sysroot/usr/include.

A tabela a seguir mostra a correspondência entre níveis de API compatíveis com NDK e as versões da plataforma Android. Para saber mais sobre os níveis de API do Android, consulte O que é nível de API?

Tabela 1. Resumo da compatibilidade com API nativa principal introduzida pela versão do Android.

Nível da API compatível com NDK Versão da plataforma Android APIs nativas principais Include
3 1.5 Biblioteca padrão C (libc/libm) #include ...
C++ #include ...
Interface Java nativa #include <jni.h>
API de registro 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 aplicativos nativos Loop de evento:
#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 buffer de hardware #include <android/hardware_buffer.h>
#include <android/hardware_buffer_jni.h>>
API de memória compartilhada #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>
28 9.0 API SurfaceTexture #include <android/surface_texture.h>

Destaques da API nativa

API do Android de nível 3

Biblioteca C

Os cabeçalhos da biblioteca C padrão estão disponíveis por meio dos 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 em libc. A biblioteca math permanece separada em libm, mas é 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. Exemplo:
    LOCAL_LDLIBS := -ldl
    

Biblioteca C++

A compatibilidade com C++17 está disponível. Para saber mais 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 funções que um app pode usar para enviar mensagens de registro ao logcat a partir do código nativo. Para saber mais sobre essas definições, consulte a documentação de geração de registros. Normalmente, você precisa gravar seus próprios macros de wrapper para acessar essa funcionalidade. Caso queira fazer um registro, vincule a liblog. Exemplo:
    LOCAL_LDLIBS := -llog
    

Biblioteca de compressão ZLib

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

    LOCAL_LDLIBS := -lz
    

API do Android 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 versões 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 incluindo a seguinte linha no seu arquivo Android.mk:

    LOCAL_LDLIBS := -lGLESv1_CM
    

Todos os dispositivos baseados em Android são compatíveis com OpenGL ES 1.0. Isso 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 a GPU necessária oferecem compatibilidade integral com OpenGL ES 1.1. Um app 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 app precisa. Para saber mais sobre como realizar essa consulta, veja a descrição de glGetString() na especificação do OpenGL.

Além disso, você precisa colocar uma tag <uses-feature> no arquivo de manifesto para indicar qual versão do OpenGL ES seu app 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 você conseguiria com essas APIs. Essas operações incluem a criação e a inversão de superfícies. Para ver um exemplo de como usar GLSurfaceView, consulte Introdução ao GLSurfaceView.

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

API do Android 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 versões posteriores.

Biblioteca do OpenGL ES 2.0:

Os cabeçalhos padrão <GLES2/gl2.h> e <GLES2/gl2ext.h> 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 utilizar o OpenGL ES 2.0, vincule seu módulo nativo a /system/lib/libGLESv2.so incluindo a seguinte linha no seu arquivo Android.mk:

    LOCAL_LDLIBS := -lGLESv2
    

Nem todos os dispositivos são compatíveis com OpenGL ES 2.0. Um app pode consultar a string de versão e de extensão do OpenGL ES para determinar se o dispositivo atual é compatível com os recursos de que o app precisa. Para saber mais sobre como realizar essa consulta, veja a descrição de glGetString() na especificação OpenGL.

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

O app de amostra hello-gl2 fornece uma demonstração básica de como usar o OpenGL ES 2.0 com o NDK.

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 você conseguiria com essas APIs. Essas operações incluem a criação e a inversão de superfícies. Para ver um exemplo de como usar GLSurfaceView, consulte Introdução ao GLSurfaceView.

API do Android de nível 8

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

jnigraphics

A biblioteca jnigraphics expõe uma interface baseada em C que permite que o código nativo acesse os buffers de pixel de objetos bitmap 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 um determinado identificador de bitmap.
  2. Use AndroidBitmap_lockPixels() para bloquear o buffer de pixels e recuperar um ponteiro para ele. Fazer isso garante que os pixels não se movam até que o app chame AndroidBitmap_unlockPixels().
  3. No código nativo, modifique o buffer de pixel conforme a necessidade quanto ao formato, à largura e outras características do pixel.
  4. Chame AndroidBitmap_unlockPixels() para desbloquear o buffer.

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

    LOCAL_LDLIBS += -ljnigraphics
    

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

API do Android de nível 9

O NDK fornece as seguintes APIs para desenvolver código nativo executado em imagens do sistema Android 2.3 e versões 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 (em inglês).

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 as funcionalidades do EGL:

  • <EGL/egl.h>: as principais definições da API do EGL.
  • <EGL/eglext.h>: definições relacionadas à extensão do 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 OpenSL ES 1.0.1 do Khronos Group.

Os cabeçalhos padrão do OpenSL ES <SLES/OpenSLES.h> e <SLES/OpenSLES_Platform.h> contêm as declarações necessárias para realizar a 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, consulte 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 um vínculo com ela adicionando a seguinte linha ao arquivo Android.mk:

    LOCAL_LDLIBS += -lOpenSLES
    

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

APIs de aplicativo nativo do Android

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

Observação: programar o app com código nativo não é, em si, suficiente para que o app seja executado na VM. Além disso, o app 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 API NDK, além dos comentários nos cabeçalhos. Além disso, para ver mais informações sobre o abrangente assunto de programar apps nativos, consulte Aplicativos e atividades nativas.

Ao incluir um ou mais desses cabeçalhos, você também precisa vinculá-los à biblioteca libandroid.so. Para vincular a libandroid.so, inclua a seguinte linha no arquivo Android.mk:

    LOCAL_LDLIBS += -landroid
    

API do Android de nível 14

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

OpenMAX AL

O gerenciamento nativo de multimídia do Android se baseia na API 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 realizar a 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 saber mais sobre essas extensões, consulte os comentários em <OMXAL/OpenMAXAL_Android.h>.

A biblioteca libOpenMAXAL.so do sistema implementa as funções públicas nativas de áudio. 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 sua instalação do NDK.

OpenSL ES

A compatibilidade com OpenSL ES para esse nível da API do Android acrescenta compatibilidade com PCM. Para saber mais sobre a compatibilidade com OpenSL ES no NDK, consulte OpenSL ES.

API do Android de nível 18

O NDK fornece as seguintes APIs para desenvolver código nativo executado em imagens do sistema Android 4.3 e versões 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 OpenGL ES 3.0, vincule seu módulo nativo a /system/lib/libGLESv3.so, incluindo a seguinte linha no seu arquivo Android.mk:

    LOCAL_LDLIBS := -lGLESv3
    

Nem todos os dispositivos são compatíveis com o OpenGL ES 3.0. Um app pode consultar a string de versão e de extensão do OpenGL ES para determinar se o dispositivo atual é compatível com os recursos de que o app precisa. Para saber mais sobre como realizar essa consulta, veja a descrição de glGetString() na especificação OpenGL.

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

O app de amostra gles3jni fornece uma demonstração básica de como usar o OpenGL ES 3.0 com o NDK.

API do Android de nível 21

O NDK fornece as seguintes APIs para desenvolver código nativo executado em imagens do sistema Android 4.3 e versões 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 OpenGL ES 3.1, vincule seu módulo nativo a /system/lib/libGLESv3.so, incluindo a seguinte linha no seu arquivo Android.mk:

    LOCAL_LDLIBS := -lGLESv3
    

Nem todos os dispositivos são compatíveis com o OpenGL ES 3.1. Um app pode consultar a string de versão e de extensão do OpenGL ES para determinar se o dispositivo atual é compatível com os recursos de que o app precisa. Para saber mais sobre como realizar essa consulta, veja a descrição de glGetString() na especificação OpenGL.

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

O app de amostra gles3jni fornece uma demonstração básica de como usar o OpenGL ES 3.1 com o NDK.

Observação: o Android Emulator não é compatível com a emulação de hardware do OpenGL ES 3.1. A execução e o teste de código que usa essa API exige um dispositivo real com hardware que seja compatível com o OpenGL ES 3.1.

API do Android de nível 23

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

Rastreamento

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

API do Android 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 versões posteriores.

Vulkan

O Vulkan é uma API multiplataforma de baixa sobrecarga para renderizar gráficos 3D de alto desempenho. Vulkan é um padrão aberto mantido pelo Khronos Group. O arquivo de cabeçalho <vulkan/vulkan.h> padrão 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 apps Android, acesse a documentação de API. Para códigos de amostra, acesse os projetos vulkan-basic-samples e android-vulkan-tutorials no GitHub.

Câmera

A API nativa da câmera oferece o equivalente nativo das classes android.hardware.camera2 na linguagem de programação Java. A API nativa da câmera permite realizar captura e processamento de fotos refinadas no seu código nativo. Diferentemente da API Java camera2, a API nativa de câmera não é compatível com as implementações obsoletas HAL 1.0 de câmera. Ou seja, a lista de câmeras disponíveis na API nativa da câmera não incluirá dispositivos de câmera que tenham o nível de hardware LEGACY.

Choreographer

A API nativa choreographer (<android/choreographer.h>) é a equivalente nativa da classe android.view.Choreographer no Java. Com a API nativa choreographer, você pode coordenar o tempo de animações, a entrada e o desenho no seu código nativo. Essa API é útil para o controle de frames, fornecendo sincronização com vsync. Para ver um exemplo de como usar a API choreographer, consulte o diretório choreographer-30fps no projeto de amostra 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 foram adicionadas no Android 5.0.

EGL

A compatibilidade do EGL para API do Android de nível 24 acrescenta suporte para as seguintes extensões:

Para saber mais sobre a compatibilidade com o EGL no NDK, consulte 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 OpenGL ES 3.2, vincule seu módulo nativo a /system/lib/libGLESv3.so, incluindo a seguinte linha no arquivo Android.mk:

    LOCAL_LDLIBS := -lGLESv3
    

Nem todos os dispositivos são compatíveis com o OpenGL ES 3.2. Um app pode consultar a string de versão e de extensão do OpenGL ES para determinar se o dispositivo atual é compatível com os recursos de que o app precisa. Para saber mais sobre como realizar essa consulta, veja a descrição de glGetString() na especificação do OpenGL.

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

API do Android de nível 26

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

AAudio

O NDK fornece a API AAudio (<aaudio/AAudio.h>) para apps de áudio de alto desempenho que exigem baixa latência. Os apps que usam AAudio leem e gravam dados para streams de áudio. A AAudio foi criada para ser uma alternativa mais fácil do que usar o OpenSL ES. Para saber mais sobre o uso dessa API, consulte o guia do desenvolvedor sobre AAudio.

Buffer de hardware

O NDK fornece duas APIs nativas que permitem que você crie 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 buffers diretamente para criar seus próprios canais 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 com o objetivo de criar um tipo de recurso EGLImage, que pode ser vinculado a uma textura por meio de glEGLImageTargetTexture2DOES nos dispositivos compatíveis. Isso pode ser útil para criar texturas que possam 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, possa ser transportado entre dois processos diferentes. Isso dá ao app capacidades semelhantes a 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 em torno da memória compartilhada nativa do Android. Ela pode ser usada para comunicação entre processos. 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 usando 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 deixarem de ser mapeados em todos os processos.

API do Android de nível 27

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

API Neural Networks

A API Neural Networks (<android/neuralnetworks.h>) fornece aos apps aceleração de hardware para operações de machine learning no dispositivo. A API é compatível com o modelo de criação, compilação e execução no dispositivo. Os apps normalmente não usam essa diretamente. Em vez disso, ela precisa ser chamada por bibliotecas de machine learning, frameworks e ferramentas que permitam que os desenvolvedores treinem modelos e os implantem em dispositivos Android. Para saber mais, consulte o guia dos desenvolvedores sobre API Neutral Networks e a referência da API.