Kotlin Multiplatform: co to je, shared module a expect/actual

Co je Kotlin Multiplatform?

Kotlin Multiplatform — technologie křížové kompilace, která umožňuje psát společný kód v Kotlin a kompilovat jej pro různé platformy: JVM (Android), LLVM (iOS, macOS, watchOS), JavaScript (Web) a nativní binární soubory (Linux, Windows). KMP není UI framework — řeší problém znovupoužití obchodní logiky, nikoli rozhraní.

Architektura KMP je postavena kolem shared modulu — modulu Gradle obsahujícího commonMain s kódem nezávislým na platformě a source sets pro každý cíl (androidMain, iosMain, desktopMain). Podle údajů JetBrains za rok 2025 používá více než 40 % nových projektů Kotlin KMP pro sdílení kódu mezi platformami.

Kotlin Multiplatform Mobile (KMM) — dřívější název pro mobilní scénář iOS+Android. Od Kotlin 2.1+ byl termín KMM nahrazen obecným Kotlin Multiplatform, protože technologie překročila hranice mobilního vývoje. Netflix, McDonald's a VMware používají KMP v produkci pro sdílení kódu mezi mobilními aplikacemi.

Mechanismus expect/actual: architektura

Expect/actual — klíčový mechanismus KMP pro práci s platformním kódem. V commonMain je deklarována expect-deklarace (funkce, třída, vlastnost) a v každém source setu specifickém pro platformu (androidMain, iosMain) — actual-implementace. Kompilátor kontroluje, že pro každé expect existuje actual na každé cílové platformě.

// commonMain — deklarace platformního API
expect fun getPlatformName(): String

expect class PlatformContext(val appVersion: String)

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

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

Hierarchie source sets v KMP umožňuje vytvářet mezilehlé úrovně: například iosArm64Main (fyzická zařízení iOS) a iosSimulatorArm64Main (simulátor) se společným iosMain. Kód z commonMain je přístupný všem platformám a kód z iosMain pouze cílům iOS. To snižuje duplicitu, když se implementace liší ne pro každou platformu, ale pro skupinu platforem.

V praxi se expect/actual používá pro: získání lokálního úložiště (SharedPreferences vs NSUserDefaults), práci se sítí (HttpEngine pro každou platformu), přístup k souborovému systému, kryptografii a analytiku. JetBrains doporučuje minimalizovat počet expect/actual a přesunout co nejvíce kódu do commonMain.

Shared module: struktura a Gradle

Shared module — standardní modul Gradle s pluginem `org.jetbrains.kotlin.multiplatform`. Obsahuje společný kód v `src/commonMain/kotlin/` a implementace platformy v `src/androidMain/kotlin/` a `src/iosMain/kotlin/`. Projekt KMP také připojuje `androidApp` a `iosApp`, které závisí na shared modulu.

// 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")
            }
        }
    }
}

Konfigurace Gradle pro KMP vyžaduje explicitní uvedení cílů iOS — x64 (simulátor Intel), arm64 (fyzická zařízení) a simulatorArm64 (simulátor Apple Silicon). Pro každý cíl je generován samostatný Apple framework. Plugin `kotlin("multiplatform")` automaticky konfiguruje kompilaci pro JVM a LLVM v závislosti na deklarovaných cílech.

Ktor a kotlinx.serialization — standardní knihovny KMP podporující společný kód. Ktor poskytuje HTTP klienta s enginy pro každou platformu (OkHttp pro Android, Darwin pro iOS). kotlinx.serialization funguje na jakékoli platformě bez expect/actual díky multiplatformní implementaci v commonMain.

Integrace s iOS přes Kotlin/Native

Kotlin/Native — kompilátor Kotlin do nativního kódu přes LLVM. Pro iOS je shared modul kompilován do Apple frameworku (.framework), který je připojen přes Xcode. Volání společného kódu ze Swift/Objective-C probíhá přes generované Objective-C hlavičky, proto musí být API shared modulu kompatibilní s Objective-C.

Omezení iOS integrace: Kotlin kolekce (List, Map) jsou konvertovány na NSArray/NSDictionary. Funkce s výchozími parametry nejsou exportovány — jsou potřeba overloads. Pro suspend-funkce jsou generovány metody založené na callbacku s `@ObjCName` a podporou async/await od Kotlin 2.0+.

// iOS aplikace: volání shared modulu ze Swift
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)")
            }
        })
    }
}

Integrace shared modulu v Xcode probíhá přes embed-and-framework — generovaný `.xcframework` je přidán do projektu Xcode. Gradle plugin může automaticky aktualizovat framework při sestavení přes embedAndSignAppleFrameworkForXcode. Pro testování na simulátoru stačí binární soubor iosSimulatorArm64 nebo iosX64.

KMP vs Flutter vs React Native

Volba mezi KMP, Flutter a React Native závisí na prioritě: znovupoužití logiky nebo úplná multi-platformnost. KMP poskytuje nativní UI na každé platformě, ale vyžaduje dvě kódové základny pro rozhraní. Flutter a React Native používají jednotné UI, ale obětují nativitu.

Kdy zvolit KMP: projekt vyžaduje vysoce výkonné UI (hry, mapy, animace), stávající nativní kód je třeba znovu použít, tým již zná Kotlin a nativní platformy. Kdy zvolit Flutter/RN: MVP nebo startup s omezeným rozpočtem, tým jednoho profilu, UI nevyžaduje hlubokou nativní customizaci.

Nástroje a knihovny KMP

Ekosystém nástrojů KMP zahrnuje knihovny pro všechny vrstvy aplikace: síť (Ktor), serializace (kotlinx.serialization), databáze (SQLDelight), navigace (Decompose), DI (Koin) a ukládání dat (multiplatform-settings). JetBrains podporuje Compose Multiplatform — UI framework v Kotlin fungující na všech platformách.

// Repository v KMP s SQLDelight + Ktor
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 — UI framework pro KMP založený na Jetpack Compose. Umožňuje psát rozhraní v Kotlin pro Android, iOS, Desktop a Web. V roce 2025 dosáhl Compose Multiplatform stabilního stavu pro Android a Desktop; cíl iOS je v beta verzi. Pro produkční projekty s nativním UI zůstává výhoda KMP hlavním rozdílem oproti Flutter.