Kotlin Multiplatform: mi ez, shared module és expect/actual

Mi az a Kotlin Multiplatform?

Kotlin Multiplatform — cross-compilációs technológia, amely lehetővé teszi közös kód írását Kotlinban és annak lefordítását különböző platformokra: JVM (Android), LLVM (iOS, macOS, watchOS), JavaScript (Web) és natív binárisok (Linux, Windows). A KMP nem UI keretrendszer — az üzleti logika újrafelhasználásának problémáját oldja meg, nem az interfészekét.

A KMP architektúrája a shared module köré épül — egy Gradle modul, amely commonMain-t tartalmaz platformfüggetlen kóddal és source set-eket minden célhoz (androidMain, iosMain, desktopMain). A JetBrains 2025-ös adatai szerint az új Kotlin projektek több mint 40%-a használja a KMP-t a kód platformok közötti megosztására.

Kotlin Multiplatform Mobile (KMM) — a mobil iOS+Android forgatókönyv korábbi neve. A Kotlin 2.1+-tól kezdve a KMM kifejezést felváltotta az általános Kotlin Multiplatform, mivel a technológia túllépett a mobil fejlesztés határain. A Netflix, a McDonald's és a VMware éles környezetben használja a KMP-t a kód megosztására mobil alkalmazásaik között.

Expect/actual mechanizmus: architektúra

Expect/actual — a KMP kulcsmechanizmusa a platformkóddal való munkához. A commonMain-ben egy expect-deklaráció (függvény, osztály, tulajdonság) kerül deklarálásra, minden platform-specifikus source set-ben (androidMain, iosMain) pedig az actual-implementáció. A fordító ellenőrzi, hogy minden expect-hez tartozik-e actual minden célplatformon.

// commonMain — platform API deklarálása
expect fun getPlatformName(): String

expect class PlatformContext(val appVersion: String)

// androidMain — actual Androidhoz
actual fun getPlatformName(): String = "Android \${Build.VERSION.SDK_INT}"

// iosMain — actual iOS-hez
actual fun getPlatformName(): String =
    UIDevice.currentDevice.systemName

Source set-ek hierarchiája a KMP-ben lehetővé teszi köztes szintek létrehozását: például iosArm64Main (fizikai iOS eszközök) és iosSimulatorArm64Main (szimulátor) közös iosMain-nel. A commonMain-ből származó kód minden platform számára elérhető, az iosMain-ből származó kód pedig csak iOS célok számára. Ez csökkenti a duplikációt, amikor az implementáció nem minden platformon, hanem platformcsoportonként különbözik.

A gyakorlatban az expect/actual a következőkre használatos: helyi tárolás elérése (SharedPreferences vs NSUserDefaults), hálózati munka (HttpEngine minden platformhoz), fájlrendszerhez való hozzáférés, kriptográfia és analitika. A JetBrains azt javasolja, hogy minimalizáljuk az expect/actual számát és minél több kódot helyezzünk át a commonMain-be.

Shared module: struktúra és Gradle

Shared module — egy szabványos Gradle modul az `org.jetbrains.kotlin.multiplatform` pluginnal. Tartalmazza a közös kódot a `src/commonMain/kotlin/` könyvtárban és a platform implementációkat a `src/androidMain/kotlin/` és `src/iosMain/kotlin/` könyvtárakban. A KMP projekt csatlakoztatja a `androidApp` és `iosApp` modulokat is, amelyek függnek a shared modultól.

// build.gradle.kts — shared module
plugins {
    kotlin("multiplatform")
    id("com.android.library")
}

kotlin {
    androidTarget()
    
    listOf(
        iosX64(),
        iosArm64(),
        iosSimulatorArm64()
    ).forEach {
        it.binaries.framework {
            baseName = "shared"
            isStatic = true
        }
    }

    sourceSets {
        val commonMain by getting {
            dependencies {
                implementation("io.ktor:ktor-client-core:3.1.0")
                implementation("org.jetbrains.kotlinx:kotlinx-serialization-json:1.7.3")
            }
        }
        val androidMain by getting {
            dependencies {
                implementation("io.ktor:ktor-client-okhttp:3.1.0")
            }
        }
        val iosMain by creating {
            dependencies {
                implementation("io.ktor:ktor-client-darwin:3.1.0")
            }
        }
    }
}

A Gradle konfigurációja KMP-hez megköveteli az iOS célok explicit megadását — x64 (Intel szimulátor), arm64 (fizikai eszközök) és simulatorArm64 (Apple Silicon szimulátor). Minden célhoz külön Apple framework generálódik. A `kotlin("multiplatform")` plugin automatikusan konfigurálja a fordítást JVM és LLVM alá a deklarált célok függvényében.

Ktor és kotlinx.serialization — a KMP szabványos könyvtárai, amelyek támogatják a közös kódot. A Ktor HTTP klienst biztosít motorokkal minden platformhoz (OkHttp Androidhoz, Darwin iOS-hez). A kotlinx.serialization expect/actual nélkül működik bármely platformon a commonMain-ben lévő multiplatform implementációnak köszönhetően.

Integráció iOS-sel Kotlin/Native segítségével

Kotlin/Native — a Kotlin natív kódra fordítója LLVM segítségével. iOS esetén a shared module Apple framework-ké (.framework) fordítódik, amely Xcode-on keresztül csatlakozik. A közös kód meghívása Swift/Objective-C-ből generált Objective-C headereken keresztül történik, ezért a shared module API-nak kompatibilisnek kell lennie az Objective-C-vel.

Az iOS integráció korlátai: a Kotlin kollekciók (List, Map) NSArray/NSDictionary típusokká konvertálódnak. Az alapértelmezett paraméterekkel rendelkező függvények nem exportálódnak — overloads szükséges. A suspend-függvényekhez callback-alapú metódusok generálódnak `@ObjCName`-nel és async/await támogatással Kotlin 2.0+-tól.

// iOS alkalmazás: shared module hívása Swift-ből
import shared

class ViewModel: ObservableObject {
    let repository = UserRepository()
    
    func loadUsers() {
        repository.fetchUsers(completionHandler: { result, error in
            if let users = result as? [User] {
                print("Users: \(users.count)")
            }
        })
    }
}

A shared module integrációja Xcode-ban embed-and-framework segítségével történik — a generált `.xcframework` hozzáadásra kerül az Xcode projekthez. A Gradle plugin automatikusan frissítheti a framework-ot build közben az embedAndSignAppleFrameworkForXcode segítségével. Szimulátoron való teszteléshez elegendő az iosSimulatorArm64 vagy iosX64 bináris.

KMP vs Flutter vs React Native

A választás KMP, Flutter és React Native között a prioritástól függ: logika újrafelhasználása vagy teljes többplatformúság. A KMP natív UI-t biztosít minden platformon, de két kódbázist igényel a felülethez. A Flutter és a React Native egységes UI-t használ, de feláldozzák a natívságot.

Mikor válasszuk a KMP-t: a projekt nagy teljesítményű UI-t igényel (játékok, térképek, animációk), a meglévő natív kódot újra kell használni, a csapat már ismeri a Kotlin-t és a natív platformokat. Mikor válasszuk a Flutter/RN-t: MVP vagy startup korlátozott költségvetéssel, egységes profilú csapat, a UI nem igényel mély natív testreszabást.

KMP eszközök és könyvtárak

A KMP eszközök ökoszisztémája könyvtárakat tartalmaz az alkalmazás minden rétegéhez: hálózat (Ktor), szerializáció (kotlinx.serialization), adatbázis (SQLDelight), navigáció (Decompose), DI (Koin) és adattárolás (multiplatform-settings). A JetBrains támogatja a Compose Multiplatform-ot — egy Kotlin UI keretrendszert, amely minden platformon működik.

// Repository KMP-ben SQLDelight + Ktor segítségével
class UserRepository(
    private val httpClient: HttpClient,
    private val db: AppDatabase
) {
    suspend fun syncUsers(): List<User> {
        val remote = httpClient.get("https://api.example.com/users")
            .body<List<UserDto>>()
        
        db.userQueries.replaceAll(remote.map { it.toDomain() })
        
        return db.userQueries.selectAll().executeAsList()
    }
}

Compose Multiplatform — a Jetpack Compose-on alapuló UI keretrendszer KMP-hez. Lehetővé teszi a felület írását Kotlinban Android, iOS, Desktop és Web platformokra. 2025-ben a Compose Multiplatform stabil státuszt ért el Android és Desktop esetén; az iOS cél béta állapotban van. A natív UI-val rendelkező éles projektek esetében a KMP előnye továbbra is a fő különbség a Flutter-hez képest.