android/ndk-samples
Ndk Samples
The Android NDK samples provide a comprehensive collection of code examples demonstrating how to integrate C and C++ native code into Android applications. This repository serves as a practical guide for developers utilizing the Android Native Development Kit to implement performance-critical application components that require direct hardware access and low-level system interaction.
The project highlights the use of the Java Native Interface to bridge managed code with native modules, enabling cross-language function calls and efficient data exchange. It demonstrates how to manage native activity lifecycles, configure build toolchains for multi-architecture compilation, and package native libraries to ensure compatibility across diverse mobile processor instruction sets.
These samples cover a broad capability surface, including high-performance graphics rendering with Vulkan and OpenGL ES, low-latency audio processing, and on-device machine learning inference. The collection also illustrates advanced techniques for memory management, native code debugging, and performance optimization, such as hardware-assisted memory sanitization and CPU-specific instruction set targeting.
Features
- Software Development Kits - Provides a toolset for implementing performance-critical application components in C and C++ with direct hardware access.
- Low-Latency Implementation - Provides high-performance C and C++ APIs for real-time audio synthesis, recording, and playback with minimal hardware delay.
- Android Development - Provides tools and frameworks for building high-performance applications using C and C++ on Android.
- Native C Interoperability - Bridges managed Java or Kotlin code with native C and C++ modules for cross-language function calls and data exchange.
- Native Bridges - Connects managed runtime environments with native code via a standardized mechanism for cross-language function calls.
- On-Device Inference Engines - Executes complex neural network models directly on mobile hardware for fast inference.
- Audio Processing - Implements low-latency audio input and output streams by interfacing with native system-level audio hardware drivers.
- Native API Integration - Provides access to native audio APIs through C and C++ headers for high-performance sound applications.
- Hardware-Accelerated Rendering - Implements high-performance 2D and 3D visuals using low-level graphics APIs.
- Low-Latency Concurrency Patterns - Facilitates real-time sound synthesis, recording, and playback by interacting with low-level audio hardware.
- Graphics Rendering Interfaces - Enables hardware-accelerated rendering using Vulkan and OpenGL ES within native application modules.
- Hardware Acceleration - Runs on-device machine learning models using hardware-accelerated operations to improve processing speeds.
- Android NDK Configurations - Provides a collection of code examples demonstrating native code integration into Android applications.
- Graphics Rendering APIs - Utilizes low-overhead, cross-platform APIs to generate real-time 3D visuals while minimizing CPU usage.
- 3D Graphics Pipelines - Provides low-level interfaces for hardware-accelerated 3D graphics rendering.
- Android Activity Lifecycle Management - Provides native interfaces for managing Android activity lifecycles and input events without managed code.
- Memory Safety Diagnostics - Employs processor-level tagging and instrumentation to detect memory corruption and safety violations in native code.
- Native Compatibility Layers - Android NDK uses preprocessor macros and dynamic linking techniques to conditionally execute code based on the minimum supported OS version and available platform features.
- Instruction Set Targets - Configures the build system to generate native binaries for specific CPU instruction sets.
- Model Inference - Supports applying compiled models to input data using synchronous or asynchronous processing for high-performance inference.
- Native Binary Toolchains - Orchestrates the compilation of C and C++ source code into architecture-specific binaries using integrated build toolchains.
- Performance Optimization - Enables optimization of audio paths to balance latency, power consumption, and hardware effect availability.
- Audio Streaming Engines - Offers low-latency audio playback and recording interfaces for high-performance sound applications.
- Native Activity Bridges - Executes high-performance graphics rendering by bridging Android system lifecycle events directly to native code.
- Hardware Acceleration - Utilizes low-level system drivers and hardware-specific instruction sets to accelerate media and compute workloads.
- Latency Minimizers - Configures recording parameters and hardware usage to reduce the delay between capturing and processing audio.
- Corruption Detectors - Identifies native code errors including buffer overflows, use-after-free, and double-free vulnerabilities by instrumenting memory allocations.
- Memory Leak Detection - Identifies memory corruption and invalid access patterns in native code using high-performance hardware-assisted or software-based sanitization tools.
- Memory Allocation Selectors - Evaluates device memory properties to choose the most efficient allocation strategy for buffers and images.
- Shared Memory Buffers - Shares raw memory regions between managed and native layers to eliminate expensive data copying.
- Audio Playback - Provides configurable audio players for streaming content from URIs or buffer queues with playback control.
- Engine Managers - Initializes and coordinates thread-safe audio engines that support multiple concurrent objects.
- Interactive Synthesis - Allows implementing real-time sound processing and playback logic for responsive musical instruments and games.
- Signal Generation - Enables synthesis and playback of digital audio waveforms using low-latency native interfaces.
- Audio Recording - Captures audio from device hardware using specified data locators and formats for processing or storage.
- Render Pass Consolidators - Consolidates rendering operations to reduce the overhead of starting and ending passes on mobile GPU architectures.
- Runtime Shader Compilers - Provides C and C++ APIs to perform just-in-time compilation of shader source code into SPIR-V modules.
- Multimedia Processing - Provides low-level interfaces for media extraction, codec operations, and multimedia output handling.
- Camera Capture Controllers - Performs fine-grained photo capture and processing using low-level hardware interfaces.
- Native Binary Runtimes - Packages and extracts architecture-optimized binary modules at runtime to ensure cross-platform compatibility.
- Hardware Tagging - Applies hardware memory tags to custom allocators by aligning memory to 16-byte granules and using specific processor instructions.
- Memory Allocation Tracers - Monitors heap usage and intercepts memory allocation calls to diagnose leaks and management issues in native code.
- Audio Buffers - Handles PCM audio data streams for playback and recording using high-performance buffer queues.
- C Function Bindings - Maps native functions to C and C++ implementations explicitly to improve performance and maintainability.
- C++ Runtimes - Links applications against standard C++ library implementations to provide essential language features within native code.
- Multi-Target Compilers - Compiles native code for multiple instruction sets to ensure compatibility across diverse hardware platforms.
- Secure Execution Environments - Defends against memory-based attack vectors using hardware-level protection features on supported processors.
- Vulnerability Mitigation - Enables hardware-based pointer authentication and branch target identification to protect native code execution flow.
- Binary Compatibility Strategies - Manages minimum API levels and NDK versions to ensure native library compatibility.
- Computational Optimizers - Performs parallel data processing using advanced instruction sets to increase execution speed in low-level code.
- API Call Interceptors - Injects custom logic into graphics API calls to monitor and modify rendering behavior at runtime.
- Machine Learning Optimization - Configures and refines mathematical models for specific hardware processors to balance power consumption and processing speed.
- Production Heap Monitors - Samples memory allocations in production environments to identify heap-based corruption issues with minimal performance impact.
- Cross-Compilation Toolchains - Configures build toolchains to compile native code for specific target architectures and platform versions.
- CPU Profilers - Calculates the percentage of CPU cycles consumed by specific shared libraries, functions, or threads to identify performance bottlenecks.
- Runtime Version Queries - Android NDK retrieves the target application SDK version and the current device API level at runtime to adjust native code behavior dynamically.
- Native Stack Unwinders - Translates raw memory addresses in crash logs into human-readable source code file names and line numbers.
- Native Compilation - Integrates C and C++ source files into the application build process to produce executable native libraries.
- Android Packages - Distributes native code within AAR files to simplify integration for downstream developers.
- Validation Layers - Bundles validation binaries within application packages to ensure consistent graphics API verification across target devices.
- Package Distribution - Packages multiple architecture-specific binaries and manages their extraction for target devices.
- Asynchronous Callbacks - Processes audio events using non-blocking handlers that operate on internal system threads.
- Floating-Point Processing - Allows representing audio data using floating-point numbers to increase dynamic range and headroom.
- Latency Measurement - Provides utilities for measuring round-trip audio latency to optimize performance-critical sound applications.
- Data Streamers - Supports transferring audio samples between applications and device hardware using configured streams.
- Stream Configuration - Allows definition of stream parameters like device, sharing mode, and format to balance hardware requirements.
- Context Managers - Allocates and manages rendering surfaces and contexts to bridge native code with graphics hardware.
- Descriptor Binding Groupers - Organizes descriptor sets by update frequency to minimize rebinding overhead and improve efficiency during draw calls.
- Native Image Decoders - Converts encoded image files into raw pixel data directly within native code using various input sources.
- Validation Layers - Utilizes system-provided validation layers to enable diagnostic features dynamically without modifying application binaries.
- MIDI Data Exchange - Enables sending and receiving MIDI messages directly within native code to minimize latency.
- Acceleration Detectors - Identifies whether a graphics device uses hardware or software emulation to ensure the most efficient rendering path.
- Native Library Integrations - Imports existing static or shared binary libraries to accelerate build times and distribute compiled code.
- Native Memory Lifecycle Management - Controls the lifecycle of native references to managed objects to prevent memory leaks.
- Graph Construction Engines - Defines computation sequences of mathematical operations to represent complex machine learning models for runtime evaluation.
- Exception Handling Strategies - Detects and clears exceptions thrown by managed code within native methods to ensure stable execution.
- Library Compatibility Managers - Aligns minimum API levels and build tool versions across native libraries to prevent incompatibilities.
- Code Optimization - Uses runtime execution profiles to guide compiler decisions on code layout and inlining for faster execution.
- Crash Reporters - Captures serialized tombstone data from native crashes to enable post-mortem analysis of application failures.
