Android NDK Native API

Android NDK menyediakan satu set header asli dan file pustaka bersama yang secara bertahap meningkat bersama keberhasilan rilis Android API level yang baru. Halaman ini menjelaskan header dan file tersebut, dan memetakannya ke Android API level tertentu.

Menggunakan API asli

Ada dua langkah dasar untuk memungkinkan aplikasi Anda menggunakan pustaka yang disediakan NDK:

  1. Sertakan dalam kode Anda header yang dikaitkan dengan pustaka yang ingin digunakan.
  2. Beri tahu sistem pembangunan bahwa modul asli Anda perlu ditautkan ke pustaka pada waktu pemuatan.
    • Jika Anda menggunakan ndk-build: Tambahkan pustaka asli ke variabel LOCAL_LDLIBS dalam file Android.mk. Misalnya, untuk menautkan ke /system/lib/libfoo.so, tambahkan baris berikut:
    • LOCAL_LDLIBS := -lfoo
      

      Untuk menampilkan daftar beberapa pustaka sekaligus, gunakan spasi sebagai pemisah. Untuk informasi selengkapnya tentang variabel LOCAL_LDLIBS, lihat Android.mk.

    • Jika Anda menggunakan CMake: Ikuti petunjuk dalam Menambahkan Kode C dan C++ ke Proyek Anda.
Untuk semua level API, sistem pembangunan secara otomatis menautkan perpustakaan C dan C++. Anda tidak perlu memasukkannya secara eksplisit saat menyetel LOCAL_LDLIBS.

NDK sering menyediakan header dan pustaka baru untuk rilis baru Android. Untuk daftar API asli yang diperkenalkan versi rilis Android, lihat Tabel 1 di bawah ini. File ini berada dalam akar penginstalan NDK, di sysroot/usr/include.

Tabel berikut menunjukkan hubungan antara level API yang didukung NDK dan rilis platform Android. Untuk informasi selengkapnya tentang level Android API, lihat Apa itu Level API?

Tabel 1. Rangkuman dukungan API asli utama yang diperkenalkan oleh versi Android.

API level yang didukung NDK Rilis Platform Android API Asli Utama Termasuk
3 1.5 Pustaka standar C (libc/libm) #include ...
C++ #include ...
Antarmuka Asli Java #include <jni.h>
API logging Android #include <android/log.h>
Zlib #include <zlib.h>
Penaut dinamis #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 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>
API aplikasi asli Loop kejadian:
#include <android/looper.h>

Kejadian masukan:
#include <android/input.h>
#include <android/keycodes.h>

Kejadian sensor:
#include <android/sensor.h>

Manajemen Jendela/Permukaan:
#include <android/rect.h>
#include <android/window.h>
#include <android/native_window.h>
#include <android/native_window_jni.h>

Aset:
#include <android/asset_manager.h>

Konfigurasi:
#include <android/configuration.h>

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

#include <android/obb.h>

Aktivitas asli:
#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 media asli #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 pelacakan asli #include <android/trace.h>
24 7.0 - 7.1.1 Vulkan #include <vulkan/vulkan.h>
API kamera asli #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 koreografer asli #include <android/choreographer.h>
API multijaringan asli #include <android/multinetwork.h>
OpenGL ES 3.2 #include <GLES3/gl32.h>
#include <GLES3/gl3ext.h>
API media asli #include <media/NdkImage.h>
#include <media/NdkImageReader.h>
26 8.0 AAudio API #include <aaudio/AAudio.h>
API buffer perangkat keras #include <android/hardware_buffer.h>
#include <android/hardware_buffer_jni.h>>
API memori bersama #include <android/sharedmem.h>
27 8.1 Neural networks API #include <android/NeuralNetworks.h>
API JNI memori bersama #include <android/hardware_buffer.h>>

Sorotan API asli

Android API level 3

Pustaka C

Header pustaka C tersedia melalui nama biasa mereka, seperti <stdlib.h> dan <stdio.h>. Perhatikan bahwa Android, tidak seperti Linux, tidak ada pustaka pthread dan rt terpisah. Fungsionalitas itu termasuk dalam libc. Pustaka matematika tetap terpisah dalam libm, tetapi ditambahkan secara otomatis oleh pengompilasi.

Pustaka linker dinamis

Anda bisa mengakses fungsionalitas dlopen(3) dan dlsym(3) penaut dinamis Android. Anda juga harus menautkan ke libdl. Misalnya:
LOCAL_LDLIBS := -ldl

Pustaka C++

Dukungan C++17 tersedia. Untuk informasi selengkapnya mengenai dukungan pustaka C++, lihat Dukungan Pustaka C++.

Dukungan log khusus Android

<android/log.h> berisi beragam fungsi yang bisa digunakan aplikasi untuk mengirim pesan logcat dari kode asli. Untuk informasi selengkapnya tentang definisi ini, lihat dokumentasi logging. Biasanya Anda harus menulis makro pembungkus sendiri untuk mengakses fungsionalitas ini. Jika Anda ingin masuk, tautkan ke liblog. Misalnya:
LOCAL_LDLIBS := -llog

Pustaka kompresi ZLib

Anda bisa menggunakan pustaka kompresi Zlib dengan menyertakan zlib.h dan zconf.h. Anda juga harus menautkan modul asli ke /system/lib/libz.so dengan menyertakan baris berikut dalam file Android.mk:

LOCAL_LDLIBS := -lz

Android API level 4

NDK menyediakan API berikut untuk mengembangkan kode asli yang berjalan di citra sistem Android 1.6 ke atas.

Pustaka OpenGL ES 1.x

Header standar OpenGL ES <GLES/gl.h> dan <GLES/glext.h> berisi deklarasi yang diperlukan untuk melakukan panggilan rendering OpenGL ES 1.x dari kode asli.

Untuk menggunakan header ini, tautkan modul asli Anda ke /system/lib/libGLESv1_CM.so dengan menyertakan baris berikut dalam file Android.mk:

LOCAL_LDLIBS := -lGLESv1_CM

Semua perangkat berbasis Android mendukung OpenGL ES 1.0, karena Android menyediakan renderer perangkat lunak berkemampuan Open GL 1.0 yang bisa digunakan di perangkat yang tidak memiliki GPU.

Hanya perangkat Android dengan GPU yang diperlukan saja yang mendukung penuh OpenGL ES 1.1. Aplikasi bisa membuat kueri string versi OpenGL ES dan string ekstensi untuk menentukan apakah perangkat saat ini mendukung fitur yang dibutuhkannya. Untuk informasi tentang cara melakukan kueri ini, lihat keterangan glGetString() dalam spesifikasi OpenGL.

Selain itu, Anda harus menempatkan sebuah tag <uses-feature> dalam file manifes untuk menunjukkan versi OpenGL ES yang diperlukan oleh aplikasi Anda.

EGL API hanya tersedia mulai API level 9. Akan tetapi, Anda bisa menggunakan VM untuk melakukan sebagian operasi yang ingin didapat dari semua API itu. Operasi ini meliputi pembuatan permukaan dan pembalikan. Untuk contoh cara menggunakan GLSurfaceView, lihat Memperkenalkan GLSurfaceView.

Aplikasi contoh san-angeles menyediakan contoh untuk cara melakukan operasi ini, yang me-render setiap bingkai dalam kode asli. Contoh ini adalah porta kecil Android dari program demo San Angeles Observation yang hebat.

Android API level 5

NDK menyediakan API berikut untuk mengembangkan kode asli yang berjalan di citra sistem Android 2.0 ke atas.

Pustaka OpenGL ES 2.0:

Header standar OpenGL ES 2.0 <GLES2/gl2.h> dan <GLES2/gl2ext.h> berisi deklarasi yang diperlukan untuk melakukan panggilan rendering OpenGL ES 2.0 dari kode asli. Panggilan rendering ini menyediakan kemampuan untuk menggunakan bahasa GLSL guna mendefinisikan dan menggunakan vertex dan fragment-shader.

Untuk menggunakan OpenGL ES 2.0, tautkan modul asli Anda ke /system/lib/libGLESv2.so dengan menyertakan baris berikut dalam file Android.mk:

LOCAL_LDLIBS := -lGLESv2

Tidak semua perangkat mendukung OpenGL ES 2.0. Aplikasi bisa melakukan kueri terhadap string versi OpenGLES dan string ekstensi untuk menentukan apakah perangkat saat ini mendukung fitur yang dibutuhkannya. Untuk informasi tentang cara melakukan kueri ini, lihat keterangan glGetString() dalam spesifikasi OpenGL.

Selain itu, Anda harus menempatkan sebuah tag <uses-feature> dalam file manifes untuk menunjukkan versi OpenGL ES yang diperlukan oleh aplikasi Anda. Untuk informasi selengkapnya tentang setelan OpenGL ES untuk <uses-feature>, lihat OpenGL ES.

Aplikasi contoh hello-gl2 memberikan contoh dasar tentang cara menggunakan OpenGL ES 2.0 bersama NDK.

EGL API hanya tersedia mulai API level 9. Akan tetapi, Anda bisa menggunakan VM untuk melakukan sebagian operasi yang ingin didapat dari semua API itu. Operasi ini meliputi pembuatan permukaan dan pembalikan. Untuk contoh cara menggunakan GLSurfaceView, lihat Memperkenalkan GLSurfaceView.

Android API level 8

NDK menyediakan API berikut untuk mengembangkan kode asli yang berjalan di citra sistem Android 2.2 ke atas.

jnigraphics

Pustaka jnigraphics mengekspos antarmuka berbasis C yang memungkinkan kode asli secara meyakinkan mengakses buffer piksel objek bitmap Java. Alur kerja untuk menggunakan jnigraphics adalah seperti berikut:

  1. Gunakan AndroidBitmap_getInfo() untuk mengambil informasi dari JNI, misalnya lebar dan tinggi, tentang tuas bitmap yang ditentukan.
  2. Gunakan AndroidBitmap_lockPixels() untuk mengunci buffer piksel dan memulihkan penunjuk ke buffer itu. Dengan melakukannya, piksel tidak akan bergerak hingga aplikasi memanggil AndroidBitmap_unlockPixels().
  3. Dalam kode asli, modifikasi buffer piksel sebagaimana mestinya untuk format pikselnya, lebar, dan karakteristik lainnya.
  4. Panggil AndroidBitmap_unlockPixels() untuk membuka kunci buffer.

Untuk menggunakan jnigraphics, sertakan header <bitmap.h> dalam kode sumber, dan tautkan ke jnigraphics dengan menyertakan baris berikut dalam file Android.mk:

LOCAL_LDLIBS += -ljnigraphics

Detail tambahan tentang fitur ini ada dalam komentar file <android/bitmap.h>.

Android API level 9

NDK menyediakan API berikut untuk mengembangkan kode asli yang berjalan di citra sistem Android 2.3 ke atas.

EGL

EGL menyediakan antarmuka platform asli untuk mengalokasikan dan mengelola permukaan OpenGLES. Untuk informasi selengkapnya tentang fiturnya, lihat Antarmuka Platform Asli EGL.

EGL memungkinkan Anda melakukan operasi berikut dari kode asli:

  • Menampilkan daftar konfigurasi EGL yang didukung.
  • Mengalokasikan dan merilis permukaan OpenGL ES.
  • Menukar atau membalik permukaan.

Header berikut menyediakan fungsionalitas EGL:

  • <EGL/egl.h>: definisi EGL API utama.
  • <EGL/eglext.h>: Definisi menyangkut ekstensi EGL.

Untuk menautkan ke pustaka EGL sistem, tambahkan baris berikut ke file Android.mk:

LOCAL_LDLIBS += -lEGL

OpenSL ES

Penanganan audio asli Android berdasarkan pada OpenSL ES 1.0.1 API dari Khronos Group.

Header OpenSL ES standar <SLES/OpenSLES.h> dan <SLES/OpenSLES_Platform.h> berisi deklarasi yang diperlukan untuk melakukan input dan output audio dari sisi asli Android. Distribusi NDK untuk OpenSL ES juga menyediakan ekstensi khusus Android. Untuk informasi tentang semua ekstensi ini, lihat komentar dalam <SLES/OpenSLES_Android.h> dan <SLES/OpenSLES_AndroidConfiguration.h>.

Pustaka sistem libOpenSLES.so menerapkan fungsi audio asli publik. Tautkan ke sana dengan menambahkan baris berikut ke file Android.mk:

LOCAL_LDLIBS += -lOpenSLES

Untuk informasi selengkapnya tentang OpenSL ES API, lihat OpenSL ES untuk Android

API aplikasi asli Android

Dimulai dari API level 9, Anda bisa menulis seluruh aplikasi Android dengan kode asli, tanpa menggunakan Java.

Catatan: Menulis aplikasi Anda dalam kode asli tidaklah, dengan sendirinya, cukup untuk menjalankan aplikasi Anda di VM. Terlebih, aplikasi Anda tetap harus mengakses sebagian besar fitur platform Android lewat JNI.

Rilis ini menyediakan header asli berikut:

Untuk informasi selengkapnya tentang header ini, lihat dokumentasi Referensi NDK API, serta komentar dalam headernya sendiri. Selain itu, untuk informasi selengkapnya tentang topik yang lebih besar mengenai penulisan aplikasi asli, lihat Aplikasi dan Aktivitas Asli.

Bila Anda menyertakan satu atau beberapa header ini, Anda juga harus menautkan ke pustaka libandroid.so. Untuk menautkan ke libandroid.so, sertakan baris berikut dalam file Android.mk:

LOCAL_LDLIBS += -landroid

Android API level 14

NDK menyediakan API berikut untuk mengembangkan kode asli yang berjalan di citra sistem Android 4.0 ke atas.

OpenMAX AL

Penanganan multimedia asli Android berdasarkan OpenMAX AL 1.0.1 API dari Khronos Group.

Header standar OpenMAX AL <OMXAL/OpenMAXAL.h> dan <OMXAL/OpenMAXAL_Platform.h> berisi deklarasi yang diperlukan untuk melakukan keluaran multimedia dari sisi asli Android.

Distribusi NDK untuk OpenMAX AL juga menyediakan ekstensi spesifik Android. Untuk informasi tentang semua ekstensi ini, lihat komentar dalam <OMXAL/OpenMAXAL_Android.h>.

Pustaka sistem libOpenMAXAL.so menerapkan fungsi multimedia asli publik. Untuk menautkan ke pustaka ini, sertakan baris berikut dalam file Android.mk:

    LOCAL_LDLIBS += -lOpenMAXAL

Untuk informasi selengkapnya tentang topik ini, lihat $NDK/docs/openmaxal/index.html, dalam hal ini $NDK adalah direktori akar penginstalan NDK Anda.

OpenSL ES

Dukungan OpenSL ES untuk Android API level ini menambahkan dukungan PCM. Untuk informasi selengkapnya tentang dukungan OpenSL ES di NDK, lihat OpenSL ES.

Android API level 18

NDK menyediakan API berikut untuk mengembangkan kode asli yang berjalan di citra sistem Android 4.3 ke atas.

OpenGL ES 3.0

Header standar OpenGL ES 3.0 <GLES3/gl3.h> dan <GLES3/gl3ext.h> berisi deklarasi yang diperlukan untuk melakukan panggilan rendering OpenGL ES 3.0 dari kode asli. Panggilan rendering ini menyediakan kemampuan untuk menggunakan bahasa GLSL guna mendefinisikan dan menggunakan vertex dan fragment-shader.

Untuk menggunakan OpenGL ES 3.0, tautkan modul asli Anda ke /system/lib/libGLESv3.so dengan menyertakan baris berikut dalam file Android.mk:

LOCAL_LDLIBS := -lGLESv3

Tidak semua perangkat mendukung OpenGL ES 3.0. Aplikasi bisa melakukan kueri terhadap string versi OpenGLES dan string ekstensi untuk menentukan apakah perangkat saat ini mendukung fitur yang dibutuhkannya. Untuk informasi tentang cara melakukan kueri ini, lihat keterangan glGetString() dalam spesifikasi OpenGL.

Selain itu, Anda harus menempatkan sebuah tag <uses-feature> dalam file manifes untuk menunjukkan versi OpenGL ES yang diperlukan oleh aplikasi Anda. Untuk informasi selengkapnya tentang setelan OpenGL ES untuk <uses-feature>, lihat OpenGL ES.

Aplikasi contoh gles3jni memberikan contoh dasar tentang cara menggunakan OpenGL ES 3.0 bersama NDK.

Android API level 21

NDK menyediakan API berikut untuk mengembangkan kode asli yang berjalan di citra sistem Android 4.3 ke atas.

OpenGL ES 3.1

Header standar OpenGL ES 3.1 <GLES3/gl31.h> dan <GLES3/gl3ext.h> berisi deklarasi yang diperlukan untuk melakukan panggilan rendering OpenGL ES 3.1 dari kode asli. Panggilan rendering ini menyediakan kemampuan untuk menggunakan bahasa GLSL guna mendefinisikan dan menggunakan vertex dan fragment-shader.

Untuk menggunakan OpenGL ES 3.1, tautkan modul asli Anda ke /system/lib/libGLESv3.so dengan menyertakan baris berikut dalam file Android.mk:

LOCAL_LDLIBS := -lGLESv3

Tidak semua perangkat mendukung OpenGL ES 3.1. Aplikasi bisa melakukan kueri terhadap string versi OpenGLES dan string ekstensi untuk menentukan apakah perangkat saat ini mendukung fitur yang dibutuhkannya. Untuk informasi tentang cara melakukan kueri ini, lihat keterangan glGetString() dalam spesifikasi OpenGL.

Selain itu, Anda harus menempatkan sebuah tag <uses-feature> dalam file manifes untuk menunjukkan versi OpenGL ES yang diperlukan oleh aplikasi Anda. Untuk informasi selengkapnya tentang setelan OpenGL ES untuk <uses-feature>, lihat OpenGL ES.

Aplikasi contoh gles3jni memberikan contoh dasar tentang cara menggunakan OpenGL ES 3.1 bersama NDK.

Catatan: Android Emulator tidak mendukung emulasi perangkat keras OpenGL ES 3.1. Menjalankan dan menguji kode yang menggunakan API memerlukan perangkat sungguhan dengan perangkat keras yang bisa mendukung OpenGL ES 3.1.

Android API level 23

NDK memperkenalkan API berikut untuk mengembangkan kode asli yang berjalan di citra sistem Android 6.0 ke atas.

Pelacakan

API pelacakan asli (<android/trace.h>) menyediakan padanan asli dari android.os.trace metode dalam bahasa pemrograman Java. Dengan API ini, Anda bisa melacak unit kerja bernama dalam kode asli dengan menulis kejadian pelacakan ke buffer pelacakan sistem. Kemudian Anda bisa mengumpulkan dan menganalisis kejadian pelacakan menggunakan alat Systrace. Untuk informasi selengkapnya tentang API ini, lihat Pelacakan Asli.

Android API level 24

NDK memperkenalkan API berikut untuk mengembangkan kode asli yang berjalan di citra sistem Android 7.0 ke atas.

Vulkan

Vulkan adalah API lintas platform dengan overhead rendah untuk rendering 3D berperforma tinggi. Vulkan adalah standar terbuka yang dipertahankan Khronos Group. File header <vulkan/vulkan.h> berisi deklarasi yang diperlukan untuk melakukan panggilan rendering Vulkan dari kode asli Anda.

Untuk mengetahui selengkapnya tentang Vulkan di aplikasi Android, lihat dokumentasi API. Untuk contoh kode, lihat proyek vulkan-basic-samples dan android-vulkan-tutorials di GitHub.

Kamera

API kamera asli menyediakan padanan asli dari android.hardware.camera2 kelas dalam bahasa pemrograman Java. Dengan API kamera asli, Anda bisa melakukan pengambilan foto dan pemrosesan berbutir halus dalam kode asli. Tidak seperti Java camera2 API, API kamera asli tidak menggunakan penerapan HAL 1.0 kamera yang tidak digunakan lagi (yaitu, daftar kamera yang tersedia di API kamera yang tersedia tidak akan mencantumkan perangkat kamera yang memiliki level perangkat keras LEGACY).

Koreografer

API koreografer asli (<android/choreographer.h>) adalah padanan asli dari kelas android.view.Choreographer di Java. API koreografer asli memberi Anda kemampuan untuk mengoordinasikan timing animasi, input, gambar dalam kode asli. API ini berguna untuk pengaturan kecepatan bingkai dengan menyediakan sinkronisasi dengan vsync. Misalnya cara menggunakan API koreografer, lihat direktori choreographer-30fps di contoh proyek Teapots di GitHub.

Multijaringan

API multijaringan asli (<android/multinetwork.h>) memberi akses kode asli ke fungsionalitas yang sama seperti API multijaringan Java yang ditambahkan di Android 5.0.

EGL

Dukungan EGL untuk Android API level 24 menambahkan dukungan untuk ekstensi berikut:

Untuk informasi selengkapnya tentang dukungan EGL di NDK, lihat EGL.

OpenGL ES 3.2

Header OpenGL ES 3.2 standar <GLES3/gl32.h> and <GLES3/gl3ext.h> berisi deklarasi yang diperlukan untuk melakukan panggilan rendering OpenGL ES 3.2 dari kode asli.

Untuk menggunakan OpenGL ES 3.2, tautkan modul asli ke /system/lib/libGLESv3.so dengan menyertakan baris berikut dalam file Android.mk:

LOCAL_LDLIBS := -lGLESv3

Tidak semua perangkat mendukung OpenGL ES 3.2. Aplikasi bisa melakukan kueri terhadap string versi OpenGLES dan string ekstensi untuk menentukan apakah perangkat saat ini mendukung fitur yang dibutuhkannya. Untuk informasi tentang cara melakukan kueri ini, lihat keterangan glGetString() dalam spesifikasi OpenGL.

Selain itu, Anda harus menempatkan sebuah tag <uses-feature> dalam file manifes untuk menunjukkan versi OpenGL ES yang diperlukan oleh aplikasi Anda. Untuk informasi selengkapnya tentang setelan OpenGL ES untuk <uses-feature>, lihat OpenGL ES.

Android API level 26

NDK memperkenalkan API berikut untuk mengembangkan kode asli yang berjalan di citra sistem Android 8.0 ke atas.

AAudio

NDK memperkenalkan AAudio API (<aaudio/AAudio.h>) untuk aplikasi audio kinerja tinggi yang memerlukan latensi rendah. Aplikasi yang menggunakan data baca dan tulis AAudio ke streaming audio. AAudio dimaksudkan untuk menjadi alternatif lebih mudah daripada menggunakan OpenSL ES. Untuk informasi selengkapnya tentang API ini, lihat panduan developer AAudio.

Buffer Perangkat Keras

NDK memperkenalkan dua API asli yang memungkinkan Anda membuat pipeline sendiri untuk manajemen buffer lintas proses.

API buffer perangkat keras asli (<android/hardware_buffer.h>) memungkinkan Anda mengalokasikan langsung buffer untuk membuat pipeline sendiri untuk manajemen buffer lintas proses. Anda bisa mengalokasikan struct AHardwareBuffer dan menggunakannya untuk memperoleh tipe sumber daya EGLClientBuffer melalui ekstensi eglGetNativeClientBufferANDROID. Anda bisa meneruskan buffer itu ke eglCreateImageKHR untuk membuat tipe sumber daya EGLImage, yang kemudian dapat diikat ke tekstur via glEGLImageTargetTexture2DOES di perangkat yang didukung. Ini bisa bermanfaat untuk membuat tekstur yang mungkin berupa lintas proses bersama.

JNI API buffer perangkat keras (<android/hardware_buffer_jni.h>) memungkinkan Anda memperoleh benda HardwareBuffer, yang berupa Parcelable dan dengan demikian dapat diangkut antara dua proses yang berbeda. Ini memberi Anda kemampuan yang sama seperti SurfaceFlinger (seperti membuat buffer antrean sendiri antarproses) tanpa mengakses API Android internal.

Memori Bersama

API memori bersama (<android/sharedmem.h>) adalah pembungkus sekitar memori bersama asli Android. API ini bisa digunakan untuk komunikasi antarproses. Setelah membuat memori bersama, pendeskripsi file dikembalikan sebagai pengendali. Anda bisa mengakses konten dalam memori bersama setelah memetakan pendeskripsi file ke memori proses menggunakan mmap(). Untuk menghapus pemetaan, panggil munmap(). Pendeskripsi file bisa ditukar dengan proses lain melalui soket domain UNIX. Sistem merilis memori bersama yang dialokasikan setelah pendekripsi file terkait ditutup dan semua peta memori tidak dipetakan dalam semua proses.

Android API level 27

NDK memperkenalkan API berikut untuk mengembangkan kode asli yang berjalan di citra sistem Android 8.1 ke atas.

Neural Networks API

Neural Networks API (<android/neuralnetworks.h>) menyediakan aplikasi dengan akselerasi perangkat keras untuk operasi pembelajaran mesin di perangkat. API didukung di pembuatan, kompilasi, dan eksekusi model di perangkat. Aplikasi biasanya tidak menggunakan NNAPI langsung; justru API dimaksudkan untuk dipanggil pustaka, framework, dan alat pembelajaran mesin yang memungkinkan developer melatih modelnya dan menerapkannya di perangkat Android. Untuk mempelajari lebih lanjut, lihat Neural Networks API panduan developer dan referensi API.