Kotlin/Native — mi ez, natív kód fordítás és jellemzők

Mi az a Kotlin/Native?

Kotlin/Native — a Kotlin kód natív gépi kódra fordításának technológiája, amelyet a JetBrains fejlesztett ki. A fő különbség a Kotlin/JVM-hez képest a virtuális gép hiánya — a kész végrehajtható fájl csak gépi kódot és minimális futásidejű környezetet tartalmaz. Ez lehetővé teszi Kotlin alkalmazások futtatását olyan eszközökön és rendszereken, ahol a JVM nem támogatott, beleértve az iPhone-t, Apple Watch-ot és beágyazott rendszereket.

A Kotlin/Native története egy kísérleti fordítóprojekttel kezdődött, amelyet 2017-ben integráltak a Kotlin fő ágába. 2019-ben a KotlinConf-on bejelentették az iOS támogatását célplatformként, ami fordulópontot jelentett a mobilfejlesztésben. A Kotlin 1.9.20 verziótól kezdve a Kotlin/Native fordító stabilizálódott, és alapértelmezetten része a Kotlin Multiplatformnak.

A Kotlin/Native kulcsfontosságú jellemzője a közös köztes reprezentáció, az IR használata, amely minden platformhoz külön-külön gépi kódra fordul. Ez egységes fordítói frontendet biztosít az összes Kotlin backend számára: JVM, JS és Native.

Hogyan működik a Kotlin/Native fordító

Fordítás A Kotlin/Native több átalakítási szakaszon megy keresztül. A Kotlin forráskód először belső reprezentációvá alakul, majd optimalizálásra kerül, és továbbítódik az LLVM backendhez gépi kód előállításához. Az utolsó szakasz a futásidejű könyvtárakkal való összekapcsolás és a végrehajtható fájl vagy dinamikus könyvtár létrehozása.

Az architektúra három kulcsfontosságú összetevőt foglal magában: frontend (értelmezés és típusellenőrzés), IR generátor (köztes reprezentáció felépítése) és LLVM backend (gépi kód előállítása). Ez a séma hasonló a Clang fordítókban használt megközelítéshez C++ és Rust esetén.

// Kotlin/Native fordítás parancssoron keresztül
kotlinc-native hello.kt -o hello -opt

// iOS arm64 építése Kotlin Multiplatform segítségével
./gradlew :shared:linkDebugFrameworkIosArm64

A memóriakezeléshez a Kotlin/Native saját Memory Manager-t használ, amely ciklikus detektorral ellátott referenciaszámláláson alapul. A Kotlin 1.7.20-tól kezdve az új memóriakezelő alapértelmezetten működik, és nem igényel @ThreadLocal vagy @SharedImmutable annotációkat. A szemétgyűjtő a szálak leállítása nélkül működik, ami kritikus fontosságú iOS esetében, ahol a rendszer kényszerítve bezárhatja az alkalmazást a főszál hosszú blokkolása esetén.

A Kotlin/Native fordítás szakaszai

A fordítási folyamat öt szakaszra oszlik: értelmezés (forráskód elemzése), szemantikai elemzés (típusellenőrzés és névfeloldás), IR generálás (köztes reprezentáció felépítése), optimalizálás (egyszerűsítés és holt kód eltávolítása) és kódgenerálás LLVM-en keresztül. Minden szakasz párhuzamosan végezhető különböző modulokhoz, ami felgyorsítja a nagy projektek építését.

Támogatott platformok Kotlin/Native

Kotlin/Native 13 célplatformot támogat, kategóriákra osztva. Mobilfejlesztéshez elérhető az iOS (arm64), Android (arm32, arm64, x86_64) és a watchOS. Az asztali platformok közé tartozik a macOS (x64, arm64), Windows (mingw x64) és Linux (x64, arm64, arm32). Szerver és beágyazott fejlesztéshez elérhető a WebAssembly és a Kotlin/Native LLVM-en operációs rendszer nélkül (standalone). Minden platform külön frameworköt vagy könyvtárat igényel a kimeneten.

Platformok mobilfejlesztéshez

iOS esetén a Kotlin/Native univerzális frameworköt (.framework) hoz létre, amely csatlakoztatható egy Xcode projekthez. Android NDK esetén natív .so könyvtárak jönnek létre, amelyek JNI-n keresztül hívhatók meg. A watchOS platform a Kotlin 1.6.0-tól, a tvOS pedig az 1.7.0 verziótól támogatott. Minden architektúra külön buildet igényel, de a Kotlin Multiplatform automatizálja ezt a folyamatot a Gradle plugin segítségével.

Asztali és szerver platformok

macOS és Linux natív asztali alkalmazások fejlesztésére szolgál Kotlinban a Compose Multiplatform framework segítségével. A Windows (MinGW) platform a Kotlin 1.3.70-től támogatott, és lehetővé teszi Windows alkalmazások létrehozását JVM telepítése nélkül. Szerverfejlesztéshez a Kotlin/Native olyan környezetekben használható, ahol a JVM nem elérhető, például Docker konténerekben scratch vagy Alpine alapú minimális képpel.

Kotlin/Native iOS fejlesztéshez

iOS a Kotlin/Native elsődleges célplatformja a KMM kontextusában. A fordító létrehoz egy iOS frameworköt, amely tartalmazza az összes közös kódot, majd ezt csatlakoztatják az Xcode projekthez. A framework támogatja mind a statikus, mind a dinamikus kapcsolást. A Kotlin/Native Objective-C burkolókat generál a Kotlin osztályokhoz és függvényekhez, biztosítva a közvetlen integrációt Swift és Objective-C kóddal.

Az iOS integrációhoz Xcode konfiguráció szükséges a generált framework csatlakoztatásához. A Kotlin Multiplatform automatizálja ezt a folyamatot az embedAndSignAppleFrameworkForXcode feladattal, amely az Xcode Build Phases-ből indul. Hibakereséshez a Kotlin/Native támogatja a töréspontokat a közös modul kódjában az alkalmazás iOS szimulátoron történő futtatásakor.

// Kotlin kód iOS frameworkké fordítva
package com.itsectr.shared

class GreetingProvider {
    fun createGreeting(): String {
        return "Hello from Kotlin/Native!"
    }

    fun formatVersion(major: Int, minor: Int): String {
        return "v$major.$minor"
    }
}

Objective-C és Swift Interop

Interop az iOS kóddal mindkét irányban működik. A Kotlin/Native Objective-C fejléceket generál a Kotlin osztályokhoz, amelyek automatikusan elérhetővé válnak Swiftből. A visszacsatolást a @ObjCName annotáció biztosítja a Kotlin függvények meghatározott Objective-C néven történő exportálásához. A Kotlin gyűjtemények automatikusan NSArray és NSDictionary típusokká konvertálódnak, a Kotlin korutinok pedig Combine publishers-ekbe vannak csomagolva a SKIE könyvtáron keresztül. Az iOS frameworkökkel való munkához Kotlinból a cinterop használatos — egy eszköz Kotlin kötések generálásához Objective-C fejlécekhez.

Kód példák: konfiguráció és fordítás

A Kotlin/Native használatának megkezdéséhez a build.gradle.kts konfigurálása szükséges a Kotlin Multiplatform plugin és a célplatformok megadásával. Tekintsük át a minimális konfigurációt egy iOS és Android támogatással rendelkező KMM projekthez.

plugins {
    kotlin("multiplatform") version "2.0.21"
}

kotlin {
    iosArm64()
    iosSimulatorArm64()

    sourceSets {
        commonMain.dependencies {
            implementation("org.jetbrains.kotlinx:kotlinx-coroutines-core:1.9.0")
        }
        iosMain.dependencies {
            implementation("org.jetbrains.kotlinx:kotlinx-coroutines-core:1.9.0")
        }
    }
}

A build konfigurálása után platformfüggő kód adható hozzá. A Kotlin/Native hozzáférést biztosít az iOS függvényekhez Kotlin burkolókon keresztül. Például az eszköz UUID lekérése iOS-en a Foundation NSUUID hívását igényli.

import platform.Foundation.NSUUID

fun getDeviceId(): String {
    return NSUUID().UUIDString()
}

fun currentTimestampMillis(): Long {
    return (platform.Foundation.NSDate().timeIntervalSince1970 * 1000).toLong()
}

iOS framework építése

Az iOS framework előállításához a linkDebugFrameworkIosArm64 vagy éles környezetben a linkReleaseFrameworkIosArm64 Gradle feladat használatos. A build után a framework a build/bin/iosArm64/debugFramework/ könyvtárban található. Az Xcode projekthez csatlakoztatás a Pods Podfile-on keresztül vagy a framework General → Frameworks, Libraries and Embedded Content szakaszba történő hozzáadásával történik.

// Release framework építése iOS arm64-hez
./gradlew :shared:linkReleaseFrameworkIosArm64

// Univerzális framework x86_64 + arm64 építése
./gradlew :shared:linkReleaseFrameworkIosX64 \
    :shared:linkReleaseFrameworkIosArm64

// XCFramework létrehozása App Store-hoz
./gradlew :shared:assembleReleaseXCFramework

Kotlin/Native vs Kotlin/JVM: összehasonlítás

Kotlin/Native és Kotlin/JVM architektúrában, teljesítményben és alkalmazási területben különböznek. A Kotlin/JVM a kódot bájtkóddá fordítja, amely a JVM-en fut, hozzáférést biztosítva a Java könyvtárak hatalmas ökoszisztémájához, de telepített virtuális gépet igényel. A Kotlin/Native végrehajtható fájlt hoz létre külső függőségek nélkül, de korlátozottabb könyvtár ökoszisztémával.

A Kotlin/Native indítási idejének teljesítménye jobb, mivel nem szükséges a JVM betöltése. A JetBrains benchmarkjai szerint a Hello World alkalmazás Kotlin/Native-on 0.003 másodperc alatt indul el, míg a Kotlin/JVM-nek 0.5–1 másodpercre van szüksége a virtuális gép betöltéséhez. A Kotlin/Native végrehajtható fájljának mérete azonban 2–3-szor nagyobb lehet a mellékelt futásidejű környezet miatt.

A választás Kotlin/Native és Kotlin/JVM között a célplatformtól függ. Ha a projekt iOS orientált vagy minimális erőforrás-felhasználást igényel, a Kotlin/Native az egyetlen lehetőség. Android fejlesztéshez a Kotlin/JVM marad a szabvány, bár a Kotlin/Native NDK komponensekhez használatos, ahol natív teljesítmény szükséges. Többplatformos projektekben a Kotlin Multiplatform mindkét megközelítést kombinálja: a közös kódot Kotlin/Native-on keresztül fordítja iOS-re és Kotlin/JVM-en keresztül Androidra.