NDK Android: यह क्या है, नेटिव डेवलपमेंट किट और C++ के लिए JNI

NDK क्या है

NDK (नेटिव डेवलपमेंट किट) C और C++ कोड को Android के लिए निष्पादन योग्य लाइब्रेरीज़ में क्रॉस-कंपाइल करने के लिए उपकरणों का एक सेट है। NDK में Clang कंपाइलर, libc++ मानक लाइब्रेरी, Android API हेडर फ़ाइलें और बिल्ड उपयोगिताएँ शामिल हैं। डेवलपर C या C++ में नेटिव कोड लिखता है, इसे .so फ़ाइलों (शेयर्ड ऑब्जेक्ट्स) में कंपाइल करता है और JNI के माध्यम से एप्लिकेशन से जोड़ता है।

NDK Android SDK को प्रतिस्थापित नहीं करता, बल्कि इसे पूरक करता है। सभी UI, लाइफसाइकिल और सिस्टम सेवाएँ Kotlin या Java में रहती हैं। नेटिव कोड विशिष्ट कार्यों को हल करता है: गणितीय गणनाएँ, क्रिप्टोग्राफी, कोडेक्स, गेम्स में भौतिकी। Google अनुशंसा करता है कि NDK का उपयोग केवल तब करें जब SDK आवश्यक प्रदर्शन या हार्डवेयर क्षमताओं तक पहुँच प्रदान नहीं करता।

NDK का इतिहास 2009 (NDK r1) से शुरू होता है। इस समय में, टूलकिट प्रयोगात्मक स्क्रिप्ट्स के सेट से CMake, LLDB डिबगिंग और प्रोफाइलिंग के समर्थन वाली परिपक्व प्रणाली तक विकसित हुआ है। 2026 तक, वर्तमान संस्करण NDK r27 है जिसमें Clang 19, C++20 का पूर्ण समर्थन और libc++ एकमात्र मानक लाइब्रेरी के रूप में है।

NDK की प्रमुख क्षमताएँ

NDK डेवलपर को नेटिव API के माध्यम से Android की निम्न-स्तरीय क्षमताओं तक पहुँच प्रदान करता है। मुख्य उपयोग के मामलों में शामिल हैं: 3D ग्राफ़िक्स के लिए OpenGL ES और Vulkan के साथ काम करना, Oboe के माध्यम से ऑडियो प्रोसेसिंग, BoringSSL के माध्यम से क्रिप्टोग्राफ़िक संचालन और ARM के लिए NEON ऑप्टिमाइज़ेशन। ये सभी API C/C++ से उपलब्ध हैं और कंपाइलेशन के लिए NDK की आवश्यकता होती है।

इसके अलावा, NDK मौजूदा C/C++ लाइब्रेरीज़ को Kotlin में पुनर्लेखन किए बिना पुन: उपयोग करने की अनुमति देता है। यह विशेष रूप से C++ में लंबे इतिहास वाली परियोजनाओं के लिए प्रासंगिक है — गेम इंजन (Unity, Unreal Engine), कंप्यूटर विज़न लाइब्रेरीज़ (OpenCV) या क्रिप्टोग्राफ़िक पैकेज (OpenSSL)। ऐसे मामलों में, NDK वर्षों का विकास समय बचाता है।

NDK बनाम SDK: नेटिव कोड कब चाहिए

NDK और शुद्ध SDK के बीच चुनाव कार्य पर निर्भर करता है। Android SDK 90% परिदृश्यों के लिए तैयार Java/Kotlin API प्रदान करता है — नेटवर्किंग, फ़ाइलें, सूचनाएँ, कैमरा। NDK का उपयोग तब किया जाता है जब ये API आवश्यक प्रदर्शन या कार्यक्षमता प्रदान नहीं करते। उदाहरण के लिए, SDK के माध्यम से रीयल-टाइम ऑडियो प्रोसेसिंग संभव है लेकिन 50–200 मिलीसेकंड विलंबता के साथ, जबकि Oboe के माध्यम से नेटिव लाइब्रेरी विलंबता को 5–15 मिलीसेकंड तक कम कर देती है।

APK आकार एक अन्य कारक है। NDK जोड़ने से एप्लिकेशन का आकार बढ़ जाता है क्योंकि प्रत्येक ABI आर्किटेक्चर को एक अलग .so लाइब्रेरी की आवश्यकता होती है। हालाँकि, Android App Bundle (AAB) का उपयोग समस्या को कम करता है: Google Play उपयोगकर्ता को केवल उसके आर्किटेक्चर के लिए लाइब्रेरी भेजता है। एक विशिष्ट नेटिव प्रोजेक्ट प्रति डिवाइस स्थापना आकार में 1–10 MB जोड़ता है।

मानदंडों के अनुसार SDK और NDK की तुलना

NDK आर्किटेक्चर: उपकरण और लाइब्रेरीज़

NDK SDK Manager के माध्यम से Android SDK से अलग स्थापित किया जाता है। NDK निर्देशिका के अंदर टूलचेन (कंपाइलर), प्लेटफ़ॉर्म लाइब्रेरीज़, हेडर फ़ाइलें और उपयोगिताएँ होती हैं। NDK टूलचेन में सभी लक्ष्य ABI: arm64-v8a, armeabi-v7a, x86_64 और x86 के लिए क्रॉस-कंपाइलेशन हेतु Clang शामिल है। कंपाइलर CMake या ndk-build फ़्लैग्स के आधार पर स्वचालित रूप से आवश्यक आर्किटेक्चर का चयन करता है।

नेटिव कोड के लिए Android API हेडर फ़ाइलों द्वारा sysroot/usr/include निर्देशिका में प्रदान किए जाते हैं। वहाँ नेटिव कोड में उपलब्ध सभी API की घोषणाएँ होती हैं: native_activity.h Activity लाइफसाइकिल के लिए, input.h इनपुट इवेंट्स के लिए, sensor.h सेंसर के लिए। इन हेडर्स को शामिल करने से JNI परत के बिना हार्डवेयर क्षमताओं तक पहुँच मिलती है।

NDK निर्देशिका संरचना

ndk/
  toolchains/
    llvm/prebuilt/windows-x86_64/
      bin/        // Clang, ld, llvm-profdata
      sysroot/    // Android API हेडर फ़ाइलें
  platforms/
    android-26/  // API 26 के लिए libc, libm, libdl
    android-34/
  sources/
    cxx-stl/     // libc++ हेडर
  build/
    cmake/       // CMake टूलचेन फ़ाइल

नेटिव Android API

NDK के माध्यम से निम्नलिखित नेटिव API समूह उपलब्ध हैं: Native App Glue (C से Activity लाइफसाइकिल प्रबंधन), OpenGL ES 3.2 और Vulkan 1.3 (ग्राफ़िक्स), Oboe (कम-विलंबता ऑडियो), Neural Networks API (डिवाइस पर मशीन लर्निंग)। प्रत्येक API के पास NDK के भाग के रूप में एक हेडर फ़ाइल और स्थैतिक/गतिशील लाइब्रेरी है।

नेटिव API के साथ काम करने के लिए JNI की आवश्यकता नहीं है — फ़ंक्शन सीधे C/C++ कोड से कॉल किए जाते हैं। हालाँकि, Kotlin में UI के साथ इंटरैक्शन के लिए अभी भी JNI की आवश्यकता है। यह हाइब्रिड आर्किटेक्चर गेम इंजन में आम है: C++ में ग्राफ़िक्स और भौतिकी (Vulkan के माध्यम से), Kotlin में मेनू और UI (Jetpack Compose के माध्यम से)।

JNI: Kotlin C++ को कैसे कॉल करता है

JNI (जावा नेटिव इंटरफ़ेस) Java/Kotlin वर्चुअल मशीन से नेटिव कोड को कॉल करने का मानक तंत्र है। डेवलपर Kotlin में external कीवर्ड के साथ एक बाहरी फ़ंक्शन घोषित करता है और System.loadLibrary के माध्यम से .so लाइब्रेरी लोड करता है। C++ पक्ष पर, फ़ंक्शन JNI नामकरण परंपरा का उपयोग करके घोषित किया जाता है, जो पैकेज और वर्ग नाम को एन्कोड करता है।

Kotlin में नेटिव फ़ंक्शन घोषित करना

class NativeBridge {
    companion object {
        init {
            System.loadLibrary("native-lib")
        }
    }

    external fun stringFromJNI(): String
    external fun fibonacci(n: Int): Long
    external fun processBuffer(data: ByteArray): ByteArray
}

// कोड में उपयोग
val bridge = NativeBridge()
println(bridge.stringFromJNI())  // "Hello from C++"

C++ में JNI फ़ंक्शन कार्यान्वयन

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

extern "C" JNIEXPORT jstring JNICALL
Java_com_example_app_NativeBridge_stringFromJNI(
    JNIEnv* env, jobject /* this */) {
    std::string hello = "Hello from C++ NDK";
    return env->NewStringUTF(hello.c_str());
}

extern "C" JNIEXPORT jlong JNICALL
Java_com_example_app_NativeBridge_fibonacci(
    JNIEnv* env, jobject /* this */, jint n) {
    if (n <= 1) return n;
    jlong a = 0, b = 1;
    for (int i = 2; i <= n; i++) {
        jlong temp = a + b;
        a = b;
        b = temp;
    }
    return b;
}

NDK के लिए CMakeLists.txt सेटअप करना

CMake NDK के लिए प्राथमिक बिल्ड सिस्टम है, जिसने पुराने ndk-build को बदल दिया है। CMakeLists.txt फ़ाइल स्रोत फ़ाइलों, लाइब्रेरीज़ और कंपाइलेशन फ़्लैग्स का वर्णन करती है। Android Studio प्रोजेक्ट बनाते समय स्वचालित रूप से CMake को कॉल करता है यदि build.gradle में externalNativeBuild कॉन्फ़िगर किया गया है। CMake प्रत्येक लक्ष्य ABI के लिए मेकफ़ाइल्स जनरेट करता है और नेटिव कोड को समानांतर में कंपाइल करता है।

नेटिव लाइब्रेरी के लिए CMakeLists.txt उदाहरण

cmake_minimum_required(VERSION 3.22.1)
project("nativelib")

# हेडर फ़ाइलें शामिल करें
include_directories(src/main/cpp/include)

# नेटिव लाइब्रेरी बनाएँ
add_library(
    native-lib
    SHARED
    src/main/cpp/native-lib.cpp
    src/main/cpp/math_utils.cpp
    src/main/cpp/audio_processor.cpp
)

# Android सिस्टम लाइब्रेरीज़ को लिंक करें
target_link_libraries(
    native-lib
    android
    log
    OpenSLES
    # libc++ स्वचालित रूप से लिंक होती है
)

# ऑप्टिमाइज़ेशन फ़्लैग्स
target_compile_options(native-lib PRIVATE -O3 -Wall -Wextra)

NDK के लिए build.gradle कॉन्फ़िगरेशन

android {
    defaultConfig {
        ndk {
            // बिल्ड के लिए लक्ष्य ABI
            abiFilters "arm64-v8a", "armeabi-v7a", "x86_64"
        }
    }
    externalNativeBuild {
        cmake {
            path "CMakeLists.txt"
            version "3.22.1"
        }
    }
    buildTypes {
        release {
            externalNativeBuild {
                cmake {
                    arguments "-DCMAKE_BUILD_TYPE=Release"
                }
            }
        }
    }
}

ABI और मल्टी-प्लेटफ़ॉर्म बिल्ड

ABI (एप्लिकेशन बाइनरी इंटरफ़ेस) मशीन कोड का प्रारूप है जो डिवाइस के प्रोसेसर के साथ संगतता निर्धारित करता है। प्रत्येक ARM या x86 आर्किटेक्चर का अपना ABI होता है। NDK नेटिव कोड को प्रत्येक निर्दिष्ट ABI के लिए अलग-अलग कंपाइल करता है। 2026 तक सबसे आम ABI: arm64-v8a (99% आधुनिक उपकरण), armeabi-v7a (पुराने 32-बिट उपकरण), x86_64 (एमुलेटर और Chromebook)।

build.gradle में abiFilters निर्दिष्ट करना बिल्ड को केवल आवश्यक आर्किटेक्चर तक सीमित करता है, जिससे कंपाइलेशन समय कम होता है। Google Play के लिए, लाइब्रेरी द्वारा समर्थित सभी ABI शामिल करने की अनुशंसा की जाती है — यह सभी उपकरणों पर काम करने की गारंटी देता है। Google Play Console App Bundle के माध्यम से ABI-विशिष्ट APK वितरण कॉन्फ़िगर करने की अनुमति देता है।

नेटिव कोड में डिवाइस ABI निर्धारित करना

#include <jni.h>
#include <android/api-level.h>

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

    #if defined(__arm__)
        #if defined(__ARM_ARCH_7A__)
            return env->NewStringUTF("armeabi-v7a");
        #endif
    #elif defined(__aarch64__)
        return env->NewStringUTF("arm64-v8a");
    #elif defined(__x86_64__)
        return env->NewStringUTF("x86_64");
    #elif defined(__i386__)
        return env->NewStringUTF("x86");
    #endif

    return env->NewStringUTF("unknown");
}

C++ में नेटिव कोड के उदाहरण

आइए एक व्यावहारिक उदाहरण देखें: फ़्लोटिंग-पॉइंट संख्याओं के साथ काम करने के लिए एक गणितीय लाइब्रेरी। C++ में नेटिव कोड ARM NEON निर्देशों तक सीधी पहुँच और रनटाइम पर ऐरे बाउंड्स जाँच की अनुपस्थिति के कारण Kotlin की तुलना में अधिक कुशलता से गणना करता है। यह उदाहरण NDK उपयोग के एक विशिष्ट पैटर्न को प्रदर्शित करता है — भारी गणनाओं को नेटिव परत में स्थानांतरित करना।

नेटिव कोड में गणितीय संचालन

#include <jni.h>
#include <cmath>
#include <vector>

extern "C" JNIEXPORT jfloatArray JNICALL
Java_com_example_app_NativeBridge_normalizeArray(
    JNIEnv* env, jobject, jfloatArray input) {

    jsize len = env->GetArrayLength(input);
    jfloat* elements = env->GetFloatArrayElements(input, nullptr);

    // माध्य और मानक विचलन की गणना करें
    float sum = 0.0f, sumSq = 0.0f;
    for (jsize i = 0; i < len; i++) {
        sum += elements[i];
        sumSq += elements[i] * elements[i];
    }
    float mean = sum / len;
    float stddev = std::sqrt(sumSq / len - mean * mean);

    // सामान्यीकरण: (x - mean) / stddev
    jfloat* result = new jfloat[len];
    for (jsize i = 0; i < len; i++) {
        result[i] = (elements[i] - mean) / stddev;
    }

    env->ReleaseFloatArrayElements(input, elements, JNI_ABORT);
    jfloatArray output = env->NewFloatArray(len);
    env->SetFloatArrayRegion(output, 0, len, result);
    delete[] result;
    return output;
}

नेटिव कोड से लॉगिंग

नेटिव कोड डीबग करने के लिए, android/log.h लाइब्रेरी से __android_log_print मैक्रो का उपयोग करें। संदेश Java/Kotlin लॉग के साथ Logcat में दिखाई देते हैं। लॉगिंग स्तर (ANDROID_LOG_DEBUG, ANDROID_LOG_ERROR) संदेशों को फ़िल्टर करने में मदद करता है।

#include <android/log.h>
#define LOG_TAG "NativeLib"
#define LOGD(...) __android_log_print(ANDROID_LOG_DEBUG, LOG_TAG, __VA_ARGS__)

extern "C" JNIEXPORT void JNICALL
Java_com_example_app_NativeBridge_processData(
    JNIEnv* env, jobject, jint count) {

    LOGD("Processing %d items", count);

    for (int i = 0; i < count; i++) {
        // भारी प्रसंस्करण
        LOGD("Item %d processed", i);
    }

    LOGD("Processing complete");
}