NDK Android: bu nima, Native Development Kit va C++ uchun JNI

NDK nima

NDK (Native Development Kit) — C va C++ kodini Android uchun bajariladigan kutubxonalarga o'zaro kompilatsiya qilish vositalari to'plami. NDK tarkibiga Clang kompilyatori, libc++ standart kutubxonasi, Android API sarlavha fayllari va qurilish yordamchi dasturlari kiradi. Dasturchi C yoki C++ tilida native kod yozadi, uni .so fayllariga (shared objects) kompilatsiya qiladi va JNI orqali ilovaga ulaydi.

NDK Android SDK ni almashtirmaydi, balki uni to'ldiradi. Barcha UI, lifecycle va tizim xizmatlari Kotlin yoki Java tilida qoladi. Native kod tor vazifalarni hal qiladi: matematik hisoblashlar, kriptografiya, kodeklar, o'yinlarda fizika. Google tavsiya qiladi NDK dan faqat SDK kerakli samaradorlikni yoki apparat imkoniyatlariga kirishni ta'minlamaganda foydalanishni.

NDK tarixi 2009 yildan (NDK r1) boshlanadi. Bu vaqt ichida vositalar eksperimental skriptlar to'plamidan CMake, LLDB tuzatish va profilashni qo'llab-quvvatlaydigan yetuk tizimgacha rivojlandi. 2026 yilga kelib joriy versiya — NDK r27 Clang 19, C++20 ni to'liq qo'llab-quvvatlash va yagona standart kutubxona sifatida libc++ bilan.

NDK ning asosiy imkoniyatlari

NDK dasturchiga Androidning past darajadagi imkoniyatlariga native API'lar orqali kirishni beradi. Asosiy foydalanish stsenariylariga kiradi: 3D grafika uchun OpenGL ES va Vulkan bilan ishlash, Oboe orqali audio qayta ishlash, BoringSSL orqali kriptografik operatsiyalar va ARM uchun NEON optimallashtirishlari. Bu API'larning barchasi C/C++ dan mavjud va kompilatsiya uchun NDK talab qiladi.

Bundan tashqari, NDK mavjud C/C++ kutubxonalarini Kotlin ga qayta yozmasdan qayta ishlatish imkonini beradi. Bu ayniqsa C++ da uzoq yillik tarixga ega loyihalar uchun muhim — o'yin dvigatellari (Unity, Unreal Engine), kompyuter ko'rish kutubxonalari (OpenCV) yoki kriptografik paketlar (OpenSSL). Bunday hollarda NDK yillar davomidagi ishlanma vaqtini tejaydi.

NDK vs SDK: native kod qachon kerak

NDK va toza SDK o'rtasidagi tanlov vazifaga bog'liq. Android SDK stsenariylarning 90% i uchun tayyor Java/Kotlin API'larini ta'minlaydi — tarmoq, fayllar, bildirishnomalar, kamera bilan ishlash. NDK bu API'lar kerakli samaradorlik yoki funksionallikni ta'minlamaganda ulanadi. Masalan, real vaqtda audio qayta ishlash SDK orqali mumkin, lekin 50–200 ms kechikish bilan, holbuki Oboe orqali native kutubxona kechikishni 5–15 ms gacha kamaytiradi.

APK hajmi — yana bir omil. NDK qo'shish ilova hajmini oshiradi, chunki har bir ABI arxitekturasi alohida .so kutubxonasini talab qiladi. Biroq Android App Bundle (AAB) dan foydalanish muammoni yumshatadi: Google Play foydalanuvchiga faqat uning arxitekturasi uchun kutubxonani yetkazib beradi. Oddiy native loyiha qurilmada o'rnatish hajmiga 1–10 MB qo'shadi.

SDK va NDK ni mezonlar bo'yicha taqqoslash

NDK arxitekturasi: vositalar va kutubxonalar

NDK Android SDK dan alohida SDK Manager orqali o'rnatiladi. NDK katalogi ichida toolchain (kompilyatorlar), platforma kutubxonalari, sarlavha fayllari va yordamchi dasturlar joylashgan. NDK Toolchain barcha maqsadli ABI'lar uchun o'zaro kompilatsiya uchun Clang ni o'z ichiga oladi: arm64-v8a, armeabi-v7a, x86_64 va x86. Kompilyator CMake yoki ndk-build bayroqlari asosida avtomatik ravishda kerakli arxitektirani tanlaydi.

Native kod uchun Android API'lari sysroot/usr/include katalogidagi sarlavha fayllari bilan ifodalanadi. U yerda native kodda mavjud bo'lgan barcha API'larning deklaratsiyalari joylashgan: Activity lifecycle uchun native_activity.h, kiritish hodisalari uchun input.h, sensorlar uchun sensor.h. Bu sarlavhalarni ulash JNI qatlamisiz apparat imkoniyatlariga kirishni beradi.

NDK katalog tuzilishi

ndk/
  toolchains/
    llvm/prebuilt/windows-x86_64/
      bin/        // Clang, ld, llvm-profdata
      sysroot/    // Android API sarlavha fayllari
  platforms/
    android-26/  // libc, libm, libdl API 26 uchun
    android-34/
  sources/
    cxx-stl/     // libc++ sarlavhalari
  build/
    cmake/       // CMake toolchain fayli

Android native API'lari

NDK orqali quyidagi native API guruhlari mavjud: Native App Glue (C dan Activity lifecycle boshqaruvi), OpenGL ES 3.2 va Vulkan 1.3 (grafika), Oboe (past kechikishli audio), Neural Networks API (qurilmada mashina o'rganish). Har bir API NDK tarkibida sarlavha fayli va statik/dinamik kutubxonaga ega.

Native API'lar bilan ishlash uchun JNI kerak emas — funksiyalar to'g'ridan-to'g'ri C/C++ kodidan chaqiriladi. Biroq Kotlin da UI bilan o'zaro aloqa uchun hali ham JNI talab qilinadi. Bunday gibrid arxitektura o'yin dvigatellarida uchraydi: grafika va fizika C++ da (Vulkan orqali), menyu va UI Kotlin da (Jetpack Compose orqali).

JNI: Kotlin C++ ni qanday chaqiradi

JNI (Java Native Interface) — Java/Kotlin virtual mashinasidan native kodni chaqirishning standart mexanizmi. Dasturchi Kotlin da external kalit so'zi bilan tashqi funksiyani e'lon qiladi va System.loadLibrary orqali .so kutubxonasini ulaydi. C++ tomonda funksiya paket va sinf nomini kodlaydigan JNI nomlash konvensiyasidan foydalangan holda e'lon qilinadi.

Kotlin da native funksiyani e'lon qilish

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
}

// Kodda ishlatish
val bridge = NativeBridge()
println(bridge.stringFromJNI())  // "Hello from C++"

C++ da JNI funksiyasini amalga oshirish

#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 uchun CMakeLists.txt sozlamalari

CMake — eskirgan ndk-build o'rnini bosgan NDK uchun asosiy qurilish tizimi. CMakeLists.txt fayli manba fayllarini, kutubxonalarni va kompilatsiya bayroqlarini tavsiflaydi. Android Studio build.gradle da externalNativeBuild sozlangan bo'lsa, loyihani qurishda CMake ni avtomatik chaqiradi. CMake har bir maqsadli ABI uchun make fayllarini yaratadi va native kodni parallel ravishda kompilatsiya qiladi.

Native kutubxona uchun CMakeLists.txt misoli

cmake_minimum_required(VERSION 3.22.1)
project("nativelib")

# Sarlavha fayllarini ulash
include_directories(src/main/cpp/include)

# Native kutubxona yaratish
add_library(
    native-lib
    SHARED
    src/main/cpp/native-lib.cpp
    src/main/cpp/math_utils.cpp
    src/main/cpp/audio_processor.cpp
)

# Android tizim kutubxonalarini ulash
target_link_libraries(
    native-lib
    android
    log
    OpenSLES
    # libc++ avtomatik ulanadi
)

# Optimallashtirish bayroqlari
target_compile_options(native-lib PRIVATE -O3 -Wall -Wextra)

NDK uchun build.gradle sozlamalari

android {
    defaultConfig {
        ndk {
            // Yig'ish uchun maqsadli ABI'lar
            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 va ko'p platformali yig'ish

ABI (Application Binary Interface) — qurilma protsessori bilan moslikni aniqlaydigan mashina kodi formati. Har bir ARM yoki x86 arxitekturasi o'z ABI siga ega. NDK native kodni ko'rsatilgan har bir ABI uchun alohida kompilatsiya qiladi. 2026 yilda eng keng tarqalgan ABI'lar: arm64-v8a (zamonaviy qurilmalarning 99%), armeabi-v7a (eski 32-bitli qurilmalar), x86_64 (emulator va Chromebook).

build.gradle da abiFilters ko'rsatilishi qurilishni faqat kerakli arxitekturalar bilan cheklaydi, bu kompilatsiya vaqtini qisqartiradi. Google Play uchun kutubxona mos keladigan barcha ABI'larni kiritish tavsiya etiladi — bu barcha qurilmalarda ishlashni kafolatlaydi. Google Play Console App Bundle orqali ABI-spesifik APK yetkazib berishni sozlash imkonini beradi.

Native kodda qurilma ABI sini aniqlash

#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++ da native kod misollari

Amaliy misolni ko'rib chiqamiz: suzuvchi nuqtali sonlar bilan ishlash uchun matematik kutubxona. C++ dagi native kod NEON ARM ko'rsatmalariga to'g'ridan-to'g'ri kirish va runtime da massiv chegaralarini tekshirishning yo'qligi tufayli Kotlin dan samaraliroq hisoblashlarni bajaradi. Ushbu misol NDK dan foydalanishning odatiy naqshini — og'ir hisoblashlarni native qatlamga chiqarishni namoyish etadi.

Native kodda matematik operatsiyalar

#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);

    // O'rtacha va standart og'ishni hisoblaymiz
    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);

    // Normalizatsiya: (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;
}

Native koddan loglash

Native kodni tuzatish uchun android/log.h kutubxonasidan __android_log_print makrosidan foydalaning. Xabarlar Logcat da Java/Kotlin loglari yonida paydo bo'ladi. Loglash darajasi (ANDROID_LOG_DEBUG, ANDROID_LOG_ERROR) xabarlarni filtrlashga yordam beradi.

#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++) {
        // Og'ir qayta ishlash
        LOGD("Item %d processed", i);
    }

    LOGD("Processing complete");
}