NDK Android: co to je, Native Development Kit a JNI pro C++

Co je NDK

NDK (Native Development Kit) — je sada nástrojů pro křížovou kompilaci kódu C a C++ do spustitelných knihoven pro Android. NDK zahrnuje kompilátor Clang, standardní knihovnu libc++, hlavičkové soubory Android API a nástroje pro sestavení. Vývojář píše nativní kód v C nebo C++, kompiluje jej do .so souborů (shared objects) a připojuje k aplikaci přes JNI.

NDK nenahrazuje Android SDK, ale doplňuje jej. Celé UI, lifecycle a systémové služby zůstávají v Kotlin nebo Java. Nativní kód řeší úzké úkoly: matematické výpočty, kryptografie, kodeky, fyzika ve hrách. Google doporučuje používat NDK pouze tehdy, když SDK neposkytuje požadovaný výkon nebo přístup k hardwarovým možnostem.

Historie NDK začíná v roce 2009 (NDK r1). Během této doby nástroje prošly cestou od experimentální sady skriptů k vyspělému systému s podporou CMake, ladění LLDB a profilování. K roku 2026 je aktuální verzí NDK r27 s Clang 19, plnou podporou C++20 a libc++ jako jedinou standardní knihovnou.

Klíčové možnosti NDK

NDK poskytuje vývojáři přístup k nízkoúrovňovým možnostem Androidu prostřednictvím nativních API. Hlavní scénáře použití zahrnují: práci s OpenGL ES a Vulkan pro 3D grafiku, zpracování zvuku přes Oboe, kryptografické operace přes BoringSSL a NEON optimalizace pro ARM. Všechna tato API jsou přístupná z C/C++ a vyžadují NDK pro kompilaci.

Kromě toho NDK umožňuje opětovné použití stávajících C/C++ knihoven bez přepisování do Kotlin. To je zvláště důležité pro projekty s dlouholetou historií v C++ — herní engine (Unity, Unreal Engine), knihovny počítačového vidění (OpenCV) nebo kryptografické balíčky (OpenSSL). V takových případech NDK šetří roky vývoje.

NDK vs SDK: kdy je potřeba nativní kód

Volba mezi NDK a čistým SDK závisí na úkolu. Android SDK poskytuje hotová Java/Kotlin API pro 90% scénářů — práce se sítí, soubory, oznámeními, kamerou. NDK se připojuje, když tato API neposkytují požadovaný výkon nebo funkčnost. Například zpracování zvuku v reálném čase přes SDK je možné, ale se zpožděním 50–200 ms, zatímco nativní knihovna přes Oboe snižuje zpoždění na 5–15 ms.

Velikost APK — další faktor. Přidání NDK zvyšuje velikost aplikace, protože každá ABI architektura vyžaduje samostatnou .so knihovnu. Použití Android App Bundle (AAB) však problém zmírňuje: Google Play doručuje uživateli pouze knihovnu pro jeho architekturu. Typický nativní projekt přidává 1–10 MB k velikosti instalace na zařízení.

Srovnání SDK a NDK podle kritérií

Architektura NDK: nástroje a knihovny

NDK se instaluje odděleně od Android SDK přes SDK Manager. Uvnitř adresáře NDK se nachází toolchain (kompilátory), platformní knihovny, hlavičkové soubory a nástroje. Toolchain NDK zahrnuje Clang pro křížovou kompilaci pro všechny cílové ABI: arm64-v8a, armeabi-v7a, x86_64 a x86. Kompilátor automaticky vybírá správnou architekturu na základě přepínačů CMake nebo ndk-build.

Android API pro nativní kód jsou reprezentována hlavičkovými soubory v adresáři sysroot/usr/include. Jsou zde deklarace pro všechna API dostupná v nativním kódu: native_activity.h pro lifecycle Activity, input.h pro vstupní události, sensor.h pro senzory. Připojení těchto hlaviček poskytuje přístup k hardwarovým možnostem bez vrstvy JNI.

Struktura adresáře NDK

ndk/
  toolchains/
    llvm/prebuilt/windows-x86_64/
      bin/        // Clang, ld, llvm-profdata
      sysroot/    // Hlavičkové soubory Android API
  platforms/
    android-26/  // libc, libm, libdl pro API 26
    android-34/
  sources/
    cxx-stl/     // Hlavičky libc++
  build/
    cmake/       // Soubor toolchain CMake

Nativní Android API

Prostřednictvím NDK jsou dostupné následující skupiny nativních API: Native App Glue (správa lifecycle Activity z C), OpenGL ES 3.2 a Vulkan 1.3 (grafika), Oboe (zvuk s nízkou latencí), Neural Networks API (strojové učení na zařízení). Každé API má hlavičkový soubor a statickou/dynamickou knihovnu v rámci NDK.

Pro práci s nativními API není potřeba JNI — funkce jsou volány přímo z C/C++ kódu. Pro interakci s UI v Kotlin je však stále vyžadován JNI. Tato hybridní architektura se vyskytuje v herních enginech: grafika a fyzika v C++ (přes Vulkan), menu a UI v Kotlin (přes Jetpack Compose).

JNI: jak Kotlin volá C++

JNI (Java Native Interface) — standardní mechanismus volání nativního kódu z virtuálního stroje Java/Kotlin. Vývojář deklaruje v Kotlin externí funkci s klíčovým slovem external a připojí .so knihovnu přes System.loadLibrary. Na straně C++ je funkce deklarována pomocí konvence pojmenování JNI, která kóduje balíček a název třídy.

Deklarace nativní funkce v 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
}

// Použití v kódu
val bridge = NativeBridge()
println(bridge.stringFromJNI())  // "Hello from C++"

Implementace JNI funkce v C++

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

Nastavení CMakeLists.txt pro NDK

CMake — hlavní systém sestavení pro NDK, který nahradil zastaralý ndk-build. Soubor CMakeLists.txt popisuje zdrojové soubory, knihovny a přepínače kompilace. Android Studio automaticky volá CMake při sestavení projektu, pokud je nakonfigurován externalNativeBuild v build.gradle. CMake generuje make soubory pro každý cílový ABI a kompiluje nativní kód paralelně.

Příklad CMakeLists.txt pro nativní knihovnu

cmake_minimum_required(VERSION 3.22.1)
project("nativelib")

# Připojení hlavičkových souborů
include_directories(src/main/cpp/include)

# Vytvoření nativní knihovny
add_library(
    native-lib
    SHARED
    src/main/cpp/native-lib.cpp
    src/main/cpp/math_utils.cpp
    src/main/cpp/audio_processor.cpp
)

# Připojení systémových knihoven Android
target_link_libraries(
    native-lib
    android
    log
    OpenSLES
    # libc++ se připojuje automaticky
)

# Přepínače optimalizace
target_compile_options(native-lib PRIVATE -O3 -Wall -Wextra)

Nastavení build.gradle pro NDK

android {
    defaultConfig {
        ndk {
            // Cílová ABI pro sestavení
            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 a multiplatformní sestavení

ABI (Application Binary Interface) — je formát strojového kódu, který určuje kompatibilitu s procesorem zařízení. Každá architektura ARM nebo x86 má své vlastní ABI. NDK kompiluje nativní kód samostatně pro každé zadané ABI. Nejrozšířenější ABI v roce 2026: arm64-v8a (99% moderních zařízení), armeabi-v7a (stará 32-bitová zařízení), x86_64 (emulátor a Chromebook).

Uvedení abiFilters v build.gradle omezuje sestavení pouze na potřebné architektury, což zkracuje dobu kompilace. Pro Google Play se doporučuje zahrnout všechna ABI, se kterými je knihovna kompatibilní — to zaručuje fungování na všech zařízeních. Google Play Console umožňuje konfigurovat doručování ABI-specifických APK prostřednictvím App Bundle.

Určení ABI zařízení v nativním kódu

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

Příklady nativního kódu v C++

Podívejme se na praktický příklad: matematická knihovna pro práci s čísly s plovoucí desetinnou čárkou. Nativní kód v C++ provádí výpočty efektivněji než Kotlin, díky přímému přístupu k NEON ARM instrukcím a absenci kontrol hranic polí během běhu. Tento příklad ukazuje typický vzor použití NDK — přesun těžkých výpočtů do nativní vrstvy.

Matematické operace v nativním kódu

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

    // Vypočítáme průměr a směrodatnou odchylku
    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);

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

Logování z nativního kódu

Pro ladění nativního kódu použijte makro __android_log_print z knihovny android/log.h. Zprávy se objevují v Logcat vedle Java/Kotlin logů. Úroveň logování (ANDROID_LOG_DEBUG, ANDROID_LOG_ERROR) pomáhá filtrovat zprávy.

#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++) {
        // Těžké zpracování
        LOGD("Item %d processed", i);
    }

    LOGD("Processing complete");
}