NDK APIs

Exploring Core NDK APIs

The Android NDK provides a rich set of stable C/C++ APIs, enabling developers to build high-performance applications, particularly games, audio engines, and multimedia processing pipelines, directly interacting with system services without JNI overhead.

Core System APIs: Assets, Looper, and Input

The NDK exposes several core Android OS constructs directly to C++.

• AAssetManager: Allows native code to read raw asset files bundled within the APK (/assets folder). This is essential for loading game textures, audio files, or configuration data without copying them to internal storage.

  // Reading an asset from native code
  AAsset* asset = AAssetManager_open(assetManager, "config.json", AASSET_MODE_BUFFER);
  off_t length = AAsset_getLength(asset);
  const void* buffer = AAsset_getBuffer(asset);
  // Process buffer...
  AAsset_close(asset);
  

  Copy
• ALooper: The native equivalent of Android's Java Looper. It allows native threads to run event loops, polling for file descriptor events or custom messages.
• AInputQueue: Allows native applications to directly receive and process hardware input events (touch, keyboard, gamepad) bypassing the Java view hierarchy for minimal latency.

Graphics Processing: OpenGL ES

OpenGL ES (GLES) has been the standard graphics API on Android for years. The NDK provides full access to GLES.

To use GLES, native code must interface with EGL, the interface between Khronos rendering APIs and the underlying native platform window system.

1. Use EGL to create an EGLDisplay and EGLContext.
2. Bind the context to a native window surface (typically obtained from a Java SurfaceView passed down via JNI).
3. Execute standard GLES rendering commands (e.g., glClear, glDrawArrays).

High-Performance Graphics: Vulkan

Vulkan is a low-overhead, explicit, cross-platform 3D graphics and computing API. It is the modern alternative to OpenGL ES on Android.

Vulkan is exposed via the NDK. Unlike OpenGL, Vulkan requires developers to manually manage memory, synchronization, and command buffers. This vastly increases complexity but allows for significantly higher performance and reduced CPU overhead, making it the preferred API for modern AAA mobile games.

The NDK provides the libvulkan.so loader, which routes Vulkan calls to the specific hardware driver on the device.

Audio Pipelines: AAudio and Oboe

Low-latency audio is critical for rhythm games, synthesizers, and VoIP applications. Historically, OpenSL ES was used, but it was notoriously difficult to work with.

• AAudio: Introduced in Android 8.0 (API 26), AAudio is a lightweight, low-latency C API designed specifically for Android. It uses direct memory-mapped buffers to communicate with the audio hardware, bypassing the traditional AudioFlinger mixing paths when possible.
• Oboe: While AAudio is the underlying system API, Google maintains Oboe, an open-source C++ wrapper library. Oboe provides a unified API that intelligently falls back to OpenSL ES on older devices, ensuring maximum compatibility while leveraging AAudio's ultra-low latency on modern hardware.

// Basic AAudio stream builder setup
AAudioStreamBuilder *builder;
AAudio_createStreamBuilder(&builder);
AAudioStreamBuilder_setFormat(builder, AAUDIO_FORMAT_PCM_FLOAT);
AAudioStreamBuilder_setChannelCount(builder, 2);
AAudioStreamBuilder_setPerformanceMode(builder, AAUDIO_PERFORMANCE_MODE_LOW_LATENCY);