# Android Native Development Kit (NDK)

The Android Native Development Kit (NDK) is a toolset that enables developers to integrate native C/C++ code into Android applications through the Java Native Interface (JNI). This allows performance-critical components to be written in native code while maintaining integration with the Java/Kotlin application layer. The NDK compiles native code into JNI shared libraries that can be packaged with Android applications.

The NDK supports multiple build systems including ndk-build and CMake, provides Android-specific APIs for graphics (Vulkan), audio, and neural networks, and includes the bionic C library optimized for Android. It releases on a quarterly basis with Long Term Support (LTS) versions receiving backports until the next LTS release. Current supported versions include NDK r27d (2024 LTS) and NDK r29, with packages available for Windows, macOS, and Linux platforms.

## APIs and Key Functions

### Loading Native Libraries

Load compiled native code into your Android application using the standard library loading mechanism. Libraries are loaded from shared object files (.so) with automatic platform-specific naming.

```java
public class MainActivity extends AppCompatActivity {
    // Load native library in static initializer
    static {
        System.loadLibrary("mynativelib");  // Loads libmynativelib.so
    }

    // Declare native method
    public native String getMessageFromNative();

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        try {
            String message = getMessageFromNative();
            Log.d("MainActivity", "Native message: " + message);
        } catch (UnsatisfiedLinkError e) {
            Log.e("MainActivity", "Failed to load native library", e);
        }
    }
}
```

### Declaring and Implementing Native Methods

Define native method signatures in Java/Kotlin and implement them in C/C++ using JNI naming conventions or explicit registration.

```java
// Java side - MainActivity.java
package com.example.myapp;

public class MainActivity {
    static {
        System.loadLibrary("native-lib");
    }

    // Native method declarations
    public native int calculateSum(int a, int b);
    public native String processData(String input);
    public native void performAction();
}
```

```cpp
// C++ side - native-lib.cpp
#include <jni.h>
#include <string>

extern "C" JNIEXPORT jint JNICALL
Java_com_example_myapp_MainActivity_calculateSum(
    JNIEnv* env,
    jobject /* this */,
    jint a,
    jint b) {
    return a + b;
}

extern "C" JNIEXPORT jstring JNICALL
Java_com_example_myapp_MainActivity_processData(
    JNIEnv* env,
    jobject /* this */,
    jstring input) {

    const char* nativeString = env->GetStringUTFChars(input, nullptr);
    if (nativeString == nullptr) {
        return nullptr;  // Out of memory error thrown
    }

    std::string result = "Processed: ";
    result += nativeString;

    env->ReleaseStringUTFChars(input, nativeString);

    return env->NewStringUTF(result.c_str());
}

extern "C" JNIEXPORT void JNICALL
Java_com_example_myapp_MainActivity_performAction(
    JNIEnv* env,
    jobject /* this */) {
    // Perform native operations
}
```

### JNI_OnLoad - Explicit Method Registration

Register native methods explicitly during library loading for better performance and earlier error detection. This approach enables smaller libraries with hidden symbols.

```cpp
#include <jni.h>
#include <android/log.h>

#define LOG_TAG "NativeLib"
#define LOGI(...) __android_log_print(ANDROID_LOG_INFO, LOG_TAG, __VA_ARGS__)
#define LOGE(...) __android_log_print(ANDROID_LOG_ERROR, LOG_TAG, __VA_ARGS__)

// Native function implementations
static jstring nativeGetMessage(JNIEnv* env, jobject /* this */) {
    return env->NewStringUTF("Hello from registered native method!");
}

static jint nativeMultiply(JNIEnv* env, jobject /* this */, jint a, jint b) {
    return a * b;
}

static jboolean nativeValidate(JNIEnv* env, jobject /* this */,
                                jstring data, jint threshold) {
    const char* str = env->GetStringUTFChars(data, nullptr);
    jboolean result = (strlen(str) > threshold) ? JNI_TRUE : JNI_FALSE;
    env->ReleaseStringUTFChars(data, str);
    return result;
}

// Registration function called when library loads
extern "C" JNIEXPORT jint JNI_OnLoad(JavaVM* vm, void* reserved) {
    JNIEnv* env;
    if (vm->GetEnv(reinterpret_cast<void**>(&env), JNI_VERSION_1_6) != JNI_OK) {
        LOGE("Failed to get JNIEnv");
        return JNI_ERR;
    }

    // Find the Java class
    jclass c = env->FindClass("com/example/myapp/NativeInterface");
    if (c == nullptr) {
        LOGE("Failed to find class");
        return JNI_ERR;
    }

    // Define native method mappings
    static const JNINativeMethod methods[] = {
        {"getMessage", "()Ljava/lang/String;", reinterpret_cast<void*>(nativeGetMessage)},
        {"multiply", "(II)I", reinterpret_cast<void*>(nativeMultiply)},
        {"validate", "(Ljava/lang/String;I)Z", reinterpret_cast<void*>(nativeValidate)},
    };

    // Register methods
    int rc = env->RegisterNatives(c, methods, sizeof(methods)/sizeof(JNINativeMethod));
    if (rc != JNI_OK) {
        LOGE("Failed to register native methods");
        return rc;
    }

    LOGI("Native methods registered successfully");
    return JNI_VERSION_1_6;
}
```

### String Operations in JNI

Handle string conversion between Java and C/C++ with proper memory management. Support both UTF-16 and Modified UTF-8 encodings.

```cpp
#include <jni.h>
#include <string>
#include <vector>

extern "C" JNIEXPORT jstring JNICALL
Java_com_example_StringOps_concatenateStrings(
    JNIEnv* env,
    jobject /* this */,
    jstring str1,
    jstring str2) {

    // Get UTF-8 strings from Java
    const char* cStr1 = env->GetStringUTFChars(str1, nullptr);
    const char* cStr2 = env->GetStringUTFChars(str2, nullptr);

    if (cStr1 == nullptr || cStr2 == nullptr) {
        // Out of memory - exception already thrown
        if (cStr1) env->ReleaseStringUTFChars(str1, cStr1);
        if (cStr2) env->ReleaseStringUTFChars(str2, cStr2);
        return nullptr;
    }

    // Perform string operations
    std::string result = std::string(cStr1) + " " + std::string(cStr2);

    // Release the UTF-8 strings
    env->ReleaseStringUTFChars(str1, cStr1);
    env->ReleaseStringUTFChars(str2, cStr2);

    // Create and return new Java string
    return env->NewStringUTF(result.c_str());
}

extern "C" JNIEXPORT jint JNICALL
Java_com_example_StringOps_getStringLength(
    JNIEnv* env,
    jobject /* this */,
    jstring str) {

    // Get string length directly
    jsize length = env->GetStringUTFLength(str);
    return static_cast<jint>(length);
}

extern "C" JNIEXPORT jstring JNICALL
Java_com_example_StringOps_processStringRegion(
    JNIEnv* env,
    jobject /* this */,
    jstring str,
    jint start,
    jint length) {

    // Extract substring using region copy
    std::vector<char> buffer(length + 1);
    env->GetStringUTFRegion(str, start, length, buffer.data());
    buffer[length] = '\0';

    // Check for exception after region copy
    if (env->ExceptionCheck()) {
        return nullptr;
    }

    return env->NewStringUTF(buffer.data());
}
```

### Array Operations in JNI

Access and manipulate primitive arrays efficiently with proper resource management and error handling.

```cpp
#include <jni.h>
#include <vector>
#include <algorithm>

extern "C" JNIEXPORT jintArray JNICALL
Java_com_example_ArrayOps_processIntArray(
    JNIEnv* env,
    jobject /* this */,
    jintArray inputArray) {

    // Get array length
    jsize length = env->GetArrayLength(inputArray);

    // Get array elements (may copy)
    jint* elements = env->GetIntArrayElements(inputArray, nullptr);
    if (elements == nullptr) {
        return nullptr;  // Exception thrown
    }

    // Process array data
    std::vector<jint> result(length);
    for (jsize i = 0; i < length; i++) {
        result[i] = elements[i] * 2;  // Double each element
    }

    // Release input array (JNI_ABORT - don't copy changes back)
    env->ReleaseIntArrayElements(inputArray, elements, JNI_ABORT);

    // Create new array for result
    jintArray outputArray = env->NewIntArray(length);
    if (outputArray == nullptr) {
        return nullptr;  // Out of memory
    }

    // Set array region (direct copy, no pinning needed)
    env->SetIntArrayRegion(outputArray, 0, length, result.data());

    return outputArray;
}

extern "C" JNIEXPORT jdouble JNICALL
Java_com_example_ArrayOps_calculateAverage(
    JNIEnv* env,
    jobject /* this */,
    jdoubleArray values) {

    jsize length = env->GetArrayLength(values);
    if (length == 0) {
        return 0.0;
    }

    // Use region copy for read-only access
    std::vector<jdouble> buffer(length);
    env->GetDoubleArrayRegion(values, 0, length, buffer.data());

    if (env->ExceptionCheck()) {
        return 0.0;
    }

    double sum = 0.0;
    for (jdouble val : buffer) {
        sum += val;
    }

    return sum / length;
}

extern "C" JNIEXPORT void JNICALL
Java_com_example_ArrayOps_fillArray(
    JNIEnv* env,
    jobject /* this */,
    jbyteArray array,
    jbyte value) {

    jsize length = env->GetArrayLength(array);
    std::vector<jbyte> buffer(length, value);

    // Fill entire array with value
    env->SetByteArrayRegion(array, 0, length, buffer.data());
}
```

### Thread Management and JNIEnv

Attach native threads to the Java VM and manage thread-specific JNIEnv pointers correctly.

```cpp
#include <jni.h>
#include <pthread.h>
#include <android/log.h>

#define LOG_TAG "ThreadExample"
#define LOGI(...) __android_log_print(ANDROID_LOG_INFO, LOG_TAG, __VA_ARGS__)

// Global JavaVM pointer (can be shared across threads)
static JavaVM* g_jvm = nullptr;

// Store JavaVM in JNI_OnLoad
extern "C" JNIEXPORT jint JNI_OnLoad(JavaVM* vm, void* reserved) {
    g_jvm = vm;
    return JNI_VERSION_1_6;
}

// Thread cleanup callback
static void detachThreadOnExit(void* env) {
    if (env != nullptr && g_jvm != nullptr) {
        g_jvm->DetachCurrentThread();
        LOGI("Thread detached from JVM");
    }
}

// Worker thread function
void* workerThread(void* arg) {
    LOGI("Worker thread started");

    // Attach thread to get JNIEnv
    JNIEnv* env;
    int status = g_jvm->AttachCurrentThread(&env, nullptr);
    if (status != JNI_OK) {
        LOGI("Failed to attach thread");
        return nullptr;
    }

    // Setup thread-local storage for automatic cleanup
    static pthread_key_t key;
    static bool key_created = false;
    if (!key_created) {
        pthread_key_create(&key, detachThreadOnExit);
        key_created = true;
    }
    pthread_setspecific(key, env);

    // Find class and method
    jclass callbackClass = env->FindClass("com/example/myapp/NativeCallback");
    if (callbackClass == nullptr) {
        LOGI("Failed to find callback class");
        return nullptr;
    }

    jmethodID callbackMethod = env->GetStaticMethodID(
        callbackClass, "onNativeEvent", "(Ljava/lang/String;)V");
    if (callbackMethod == nullptr) {
        LOGI("Failed to find callback method");
        return nullptr;
    }

    // Call Java method from native thread
    for (int i = 0; i < 5; i++) {
        jstring message = env->NewStringUTF("Event from worker thread");
        env->CallStaticVoidMethod(callbackClass, callbackMethod, message);

        // Check for exceptions
        if (env->ExceptionCheck()) {
            env->ExceptionDescribe();
            env->ExceptionClear();
        }

        env->DeleteLocalRef(message);
        sleep(1);
    }

    LOGI("Worker thread completed");
    // DetachCurrentThread called automatically via pthread cleanup
    return nullptr;
}

extern "C" JNIEXPORT void JNICALL
Java_com_example_ThreadOps_startNativeThread(
    JNIEnv* env,
    jobject /* this */) {

    pthread_t thread;
    int result = pthread_create(&thread, nullptr, workerThread, nullptr);

    if (result != 0) {
        jclass exClass = env->FindClass("java/lang/RuntimeException");
        env->ThrowNew(exClass, "Failed to create native thread");
        return;
    }

    pthread_detach(thread);
    LOGI("Native thread created");
}
```

### Global and Local Reference Management

Manage object lifetimes across JNI boundaries using local, global, and weak references with proper cleanup.

```cpp
#include <jni.h>
#include <map>
#include <mutex>

// Cache for global references
static std::map<int, jobject> g_objectCache;
static std::mutex g_cacheMutex;
static int g_nextId = 1;

extern "C" JNIEXPORT jint JNICALL
Java_com_example_RefManager_cacheObject(
    JNIEnv* env,
    jobject /* this */,
    jobject obj) {

    if (obj == nullptr) {
        return -1;
    }

    // Create global reference (survives beyond native method return)
    jobject globalRef = env->NewGlobalRef(obj);
    if (globalRef == nullptr) {
        return -1;  // Out of memory
    }

    // Store in cache
    std::lock_guard<std::mutex> lock(g_cacheMutex);
    int id = g_nextId++;
    g_objectCache[id] = globalRef;

    return id;
}

extern "C" JNIEXPORT jobject JNICALL
Java_com_example_RefManager_getCachedObject(
    JNIEnv* env,
    jobject /* this */,
    jint id) {

    std::lock_guard<std::mutex> lock(g_cacheMutex);

    auto it = g_objectCache.find(id);
    if (it == g_objectCache.end()) {
        return nullptr;
    }

    // Create local reference from global reference
    return env->NewLocalRef(it->second);
}

extern "C" JNIEXPORT void JNICALL
Java_com_example_RefManager_removeCachedObject(
    JNIEnv* env,
    jobject /* this */,
    jint id) {

    jobject globalRef = nullptr;

    {
        std::lock_guard<std::mutex> lock(g_cacheMutex);
        auto it = g_objectCache.find(id);
        if (it != g_objectCache.end()) {
            globalRef = it->second;
            g_objectCache.erase(it);
        }
    }

    // Delete global reference to allow garbage collection
    if (globalRef != nullptr) {
        env->DeleteGlobalRef(globalRef);
    }
}

extern "C" JNIEXPORT void JNICALL
Java_com_example_RefManager_processLargeArray(
    JNIEnv* env,
    jobject /* this */,
    jobjectArray objects) {

    jsize length = env->GetArrayLength(objects);

    // Ensure capacity for local references
    if (env->EnsureLocalCapacity(length) != JNI_OK) {
        return;  // Out of memory exception thrown
    }

    for (jsize i = 0; i < length; i++) {
        jobject obj = env->GetObjectArrayElement(objects, i);

        if (obj != nullptr) {
            // Process object...

            // Delete local ref to avoid accumulation
            env->DeleteLocalRef(obj);
        }
    }
}

extern "C" JNIEXPORT void JNICALL
Java_com_example_RefManager_clearAllCached(
    JNIEnv* env,
    jobject /* this */) {

    std::map<int, jobject> toDelete;

    {
        std::lock_guard<std::mutex> lock(g_cacheMutex);
        toDelete = g_objectCache;
        g_objectCache.clear();
    }

    // Delete all global references
    for (auto& pair : toDelete) {
        env->DeleteGlobalRef(pair.second);
    }
}
```

### Exception Handling in JNI

Detect, handle, and throw exceptions properly in native code with appropriate cleanup.

```cpp
#include <jni.h>
#include <android/log.h>

#define LOG_TAG "ExceptionExample"
#define LOGE(...) __android_log_print(ANDROID_LOG_ERROR, LOG_TAG, __VA_ARGS__)

extern "C" JNIEXPORT jint JNICALL
Java_com_example_ExceptionOps_divideNumbers(
    JNIEnv* env,
    jobject /* this */,
    jint numerator,
    jint denominator) {

    if (denominator == 0) {
        // Throw Java exception from native code
        jclass exClass = env->FindClass("java/lang/ArithmeticException");
        if (exClass != nullptr) {
            env->ThrowNew(exClass, "Division by zero in native code");
        }
        return 0;
    }

    return numerator / denominator;
}

extern "C" JNIEXPORT jstring JNICALL
Java_com_example_ExceptionOps_safeProcessing(
    JNIEnv* env,
    jobject /* this */,
    jstring input) {

    // Call Java method that might throw exception
    jclass stringClass = env->FindClass("java/lang/String");
    jmethodID toLowerMethod = env->GetMethodID(
        stringClass, "toLowerCase", "()Ljava/lang/String;");

    jobject result = env->CallObjectMethod(input, toLowerMethod);

    // Check if exception occurred
    if (env->ExceptionCheck()) {
        LOGE("Exception occurred during Java method call");

        // Get exception object for logging
        jthrowable exception = env->ExceptionOccurred();
        if (exception != nullptr) {
            env->ExceptionDescribe();  // Print to logcat

            // Get exception message
            jclass throwableClass = env->FindClass("java/lang/Throwable");
            jmethodID getMessageMethod = env->GetMethodID(
                throwableClass, "getMessage", "()Ljava/lang/String;");

            jstring message = (jstring)env->CallObjectMethod(
                exception, getMessageMethod);

            if (message != nullptr) {
                const char* msgChars = env->GetStringUTFChars(message, nullptr);
                LOGE("Exception message: %s", msgChars);
                env->ReleaseStringUTFChars(message, msgChars);
            }
        }

        // Clear exception to continue or re-throw
        env->ExceptionClear();

        // Return safe default value
        return env->NewStringUTF("Error occurred");
    }

    return (jstring)result;
}

extern "C" JNIEXPORT void JNICALL
Java_com_example_ExceptionOps_validateAndProcess(
    JNIEnv* env,
    jobject /* this */,
    jobjectArray items) {

    if (items == nullptr) {
        jclass exClass = env->FindClass("java/lang/NullPointerException");
        env->ThrowNew(exClass, "Input array cannot be null");
        return;
    }

    jsize length = env->GetArrayLength(items);
    if (length == 0) {
        jclass exClass = env->FindClass("java/lang/IllegalArgumentException");
        env->ThrowNew(exClass, "Array must not be empty");
        return;
    }

    // Process array elements
    for (jsize i = 0; i < length; i++) {
        jobject item = env->GetObjectArrayElement(items, i);

        // Check for exceptions after array access
        if (env->ExceptionCheck()) {
            // Cleanup and propagate
            if (item != nullptr) {
                env->DeleteLocalRef(item);
            }
            return;
        }

        // Process item...

        env->DeleteLocalRef(item);
    }
}
```

### Calling Java Methods from Native Code

Invoke Java instance and static methods from C++ with proper method signature lookup.

```cpp
#include <jni.h>
#include <string>

extern "C" JNIEXPORT void JNICALL
Java_com_example_MethodCaller_triggerJavaCallback(
    JNIEnv* env,
    jobject /* this */,
    jobject listener,
    jint eventType,
    jstring message) {

    // Get the listener class
    jclass listenerClass = env->GetObjectClass(listener);

    // Find the callback method
    // Signature: void onEvent(int type, String message)
    jmethodID callbackMethod = env->GetMethodID(
        listenerClass,
        "onEvent",
        "(ILjava/lang/String;)V"
    );

    if (callbackMethod == nullptr) {
        // Method not found - exception thrown by GetMethodID
        return;
    }

    // Call the Java method
    env->CallVoidMethod(listener, callbackMethod, eventType, message);

    // Check for exceptions thrown by Java method
    if (env->ExceptionCheck()) {
        env->ExceptionDescribe();
        env->ExceptionClear();
    }
}

extern "C" JNIEXPORT jobject JNICALL
Java_com_example_MethodCaller_createJavaObject(
    JNIEnv* env,
    jobject /* this */,
    jstring name,
    jint value) {

    // Find the target class
    jclass dataClass = env->FindClass("com/example/myapp/DataObject");
    if (dataClass == nullptr) {
        return nullptr;
    }

    // Get constructor method ID
    // Constructor signature: DataObject(String name, int value)
    jmethodID constructor = env->GetMethodID(
        dataClass,
        "<init>",
        "(Ljava/lang/String;I)V"
    );

    if (constructor == nullptr) {
        return nullptr;
    }

    // Create new instance
    jobject newObject = env->NewObject(dataClass, constructor, name, value);

    return newObject;
}

extern "C" JNIEXPORT jstring JNICALL
Java_com_example_MethodCaller_callStaticMethod(
    JNIEnv* env,
    jobject /* this */) {

    // Find utility class
    jclass utilClass = env->FindClass("com/example/myapp/Util");
    if (utilClass == nullptr) {
        return env->NewStringUTF("Error: class not found");
    }

    // Get static method ID
    // Static method signature: static String formatMessage()
    jmethodID formatMethod = env->GetStaticMethodID(
        utilClass,
        "formatMessage",
        "()Ljava/lang/String;"
    );

    if (formatMethod == nullptr) {
        return env->NewStringUTF("Error: method not found");
    }

    // Call static method
    jstring result = (jstring)env->CallStaticObjectMethod(
        utilClass, formatMethod);

    if (env->ExceptionCheck()) {
        env->ExceptionClear();
        return env->NewStringUTF("Error: exception occurred");
    }

    return result;
}
```

### Field Access from Native Code

Read and modify Java object fields directly from native code.

```cpp
#include <jni.h>

extern "C" JNIEXPORT void JNICALL
Java_com_example_FieldAccess_updateObjectFields(
    JNIEnv* env,
    jobject /* this */,
    jobject targetObject) {

    // Get object's class
    jclass objectClass = env->GetObjectClass(targetObject);

    // Get field IDs for instance fields
    jfieldID nameField = env->GetFieldID(
        objectClass, "name", "Ljava/lang/String;");
    jfieldID countField = env->GetFieldID(
        objectClass, "count", "I");
    jfieldID activeField = env->GetFieldID(
        objectClass, "active", "Z");

    if (nameField == nullptr || countField == nullptr || activeField == nullptr) {
        return;  // Field not found
    }

    // Read current values
    jstring currentName = (jstring)env->GetObjectField(targetObject, nameField);
    jint currentCount = env->GetIntField(targetObject, countField);
    jboolean isActive = env->GetBooleanField(targetObject, activeField);

    // Modify values
    jstring newName = env->NewStringUTF("Updated from native");
    env->SetObjectField(targetObject, nameField, newName);
    env->SetIntField(targetObject, countField, currentCount + 10);
    env->SetBooleanField(targetObject, activeField, JNI_TRUE);

    // Cleanup
    if (currentName != nullptr) {
        env->DeleteLocalRef(currentName);
    }
    env->DeleteLocalRef(newName);
}

extern "C" JNIEXPORT jint JNICALL
Java_com_example_FieldAccess_getStaticCounter(
    JNIEnv* env,
    jclass clazz) {

    // Access static field
    jfieldID counterField = env->GetStaticFieldID(
        clazz, "globalCounter", "I");

    if (counterField == nullptr) {
        return -1;
    }

    return env->GetStaticIntField(clazz, counterField);
}

extern "C" JNIEXPORT void JNICALL
Java_com_example_FieldAccess_incrementStaticCounter(
    JNIEnv* env,
    jclass clazz) {

    jfieldID counterField = env->GetStaticFieldID(
        clazz, "globalCounter", "I");

    if (counterField == nullptr) {
        return;
    }

    jint current = env->GetStaticIntField(clazz, counterField);
    env->SetStaticIntField(clazz, counterField, current + 1);
}
```

### Gradle NDK Configuration

Configure NDK version and build settings in Android Gradle build files for proper native code compilation and packaging.

```gradle
// app/build.gradle
android {
    // Specify NDK version
    ndkVersion "27.3.13750724"

    compileSdk 34

    defaultConfig {
        applicationId "com.example.ndkapp"
        minSdk 21
        targetSdk 34

        // Configure native build
        ndk {
            // Specify ABIs to build
            abiFilters 'armeabi-v7a', 'arm64-v8a', 'x86', 'x86_64'
        }

        externalNativeBuild {
            cmake {
                // CMake arguments
                arguments "-DANDROID_STL=c++_shared",
                          "-DANDROID_ARM_NEON=TRUE"
                cppFlags "-std=c++17", "-frtti", "-fexceptions"
            }
        }
    }

    externalNativeBuild {
        cmake {
            // Path to CMakeLists.txt
            path file('src/main/cpp/CMakeLists.txt')
            version "3.22.1"
        }
    }

    buildTypes {
        release {
            minifyEnabled true
            proguardFiles getDefaultProguardFile('proguard-android-optimize.txt'),
                         'proguard-rules.pro'

            // Keep native methods from being stripped
            proguardFiles 'proguard-native.pro'
        }
    }
}

dependencies {
    implementation 'androidx.core:core-ktx:1.12.0'
}
```

```cmake
# CMakeLists.txt
cmake_minimum_required(VERSION 3.22.1)

project("mynativelib")

# Create shared library
add_library(mynativelib SHARED
    native-lib.cpp
    utils.cpp
    processor.cpp
)

# Find Android log library
find_library(log-lib log)

# Link libraries
target_link_libraries(mynativelib
    ${log-lib}
    android
)

# Set C++ standard
set_target_properties(mynativelib PROPERTIES
    CXX_STANDARD 17
    CXX_STANDARD_REQUIRED ON
)

# Add include directories
target_include_directories(mynativelib PRIVATE
    ${CMAKE_CURRENT_SOURCE_DIR}/include
)
```

## Summary and Integration

The Android NDK serves two primary use cases: performance optimization and code reuse. For performance-critical operations such as signal processing, image manipulation, physics simulations, and real-time audio/video processing, native C/C++ code can significantly outperform Java/Kotlin implementations. Additionally, the NDK enables integration of existing C/C++ libraries and codebases into Android applications without requiring complete rewrites, making it valuable for cross-platform development and leveraging mature native libraries.

Integration follows a standard pattern: native code is compiled into shared libraries (.so files) for each target architecture (ARM, ARM64, x86, x86_64), loaded via System.loadLibrary(), and invoked through JNI method declarations. The NDK build system (CMake or ndk-build) handles cross-compilation, the bionic C library provides Android-specific implementations, and Android Studio offers debugging support for both Java and native code. Critical considerations include proper memory management across the JNI boundary, thread safety when accessing JNIEnv from multiple threads, exception handling between native and managed code, and minimizing JNI marshalling overhead for optimal performance.