Kotlin Multiplatform: ce este, shared module și expect/actual

Ce este Kotlin Multiplatform?

Kotlin Multiplatform — tehnologie de cross-compilare care permite scrierea codului comun în Kotlin și compilarea lui pentru diferite platforme: JVM (Android), LLVM (iOS, macOS, watchOS), JavaScript (Web) și binare native (Linux, Windows). KMP nu este un framework UI — rezolvă problema reutilizării logicii de business, nu a interfețelor.

Arhitectura KMP se bazează pe shared module — un modul Gradle care conține commonMain cu cod independent de platformă și source sets pentru fiecare țintă (androidMain, iosMain, desktopMain). Conform datelor JetBrains din 2025, peste 40% din noile proiecte Kotlin folosesc KMP pentru partajarea codului între platforme.

Kotlin Multiplatform Mobile (KMM) — denumirea anterioară pentru scenariul mobil iOS+Android. De la Kotlin 2.1+, termenul KMM a fost înlocuit cu Kotlin Multiplatform general, deoarece tehnologia a depășit granițele dezvoltării mobile. Netflix, McDonald's și VMware folosesc KMP în producție pentru partajarea codului între aplicațiile mobile.

Mecanismul expect/actual: arhitectură

Expect/actual — mecanismul cheie al KMP pentru lucrul cu codul de platformă. În commonMain se declară o declarație expect (funcție, clasă, proprietate), iar în fiecare source set specific platformei (androidMain, iosMain) — implementarea actual. Compilatorul verifică dacă pentru fiecare expect există un actual în fiecare platformă țintă.

// commonMain — declararea API-ului de platformă
expect fun getPlatformName(): String

expect class PlatformContext(val appVersion: String)

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

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

Ierarhia source sets în KMP permite crearea de niveluri intermediare: de exemplu, iosArm64Main (dispozitive fizice iOS) și iosSimulatorArm64Main (simulator) cu iosMain comun. Codul din commonMain este accesibil tuturor platformelor, iar codul din iosMain doar țintelor iOS. Aceasta reduce duplicarea atunci când implementarea diferă nu pentru fiecare platformă, ci pentru un grup de platforme.

În practică, expect/actual este folosit pentru: obținerea stocării locale (SharedPreferences vs NSUserDefaults), lucrul cu rețeaua (HttpEngine pentru fiecare platformă), accesul la sistemul de fișiere, criptografie și analitică. JetBrains recomandă minimizarea numărului de expect/actual și mutarea cât mai multor cod în commonMain.

Shared module: structură și Gradle

Shared module — un modul Gradle standard cu pluginul `org.jetbrains.kotlin.multiplatform`. Acesta conține codul comun în `src/commonMain/kotlin/` și implementările de platformă în `src/androidMain/kotlin/` și `src/iosMain/kotlin/`. Proiectul KMP conectează, de asemenea, `androidApp` și `iosApp`, care depind de shared module.

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

Configurația Gradle pentru KMP necesită specificarea explicită a țintelor iOS — x64 (simulator Intel), arm64 (dispozitive fizice) și simulatorArm64 (simulator Apple Silicon). Pentru fiecare țintă este generat un Apple framework separat. Pluginul `kotlin("multiplatform")` configurează automat compilarea pentru JVM și LLVM în funcție de țintele declarate.

Ktor și kotlinx.serialization — bibliotecile standard KMP care suportă codul comun. Ktor oferă un client HTTP cu motoare pentru fiecare platformă (OkHttp pentru Android, Darwin pentru iOS). kotlinx.serialization funcționează pe orice platformă fără expect/actual datorită implementării multi-platformă în commonMain.

Integrare cu iOS prin Kotlin/Native

Kotlin/Native — compilatorul Kotlin în cod nativ prin LLVM. Pentru iOS, shared module se compilează în Apple framework (.framework) care se conectează prin Xcode. Apelarea codului comun din Swift/Objective-C se face prin antetele Objective-C generate, de aceea API-ul shared module trebuie să fie compatibil cu Objective-C.

Limitări ale integrării iOS: Colecțiile Kotlin (List, Map) sunt convertite în NSArray/NSDictionary. Funcțiile cu parametri impliciți nu sunt exportate — sunt necesare overloads. Pentru funcțiile suspend, sunt generate metode bazate pe callback cu `@ObjCName` și suport async/await din Kotlin 2.0+.

// Aplicație iOS: apelarea shared module din 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)")
            }
        })
    }
}

Integrarea shared module în Xcode se face prin embed-and-framework — `.xcframework`-ul generat este adăugat în proiectul Xcode. Pluginul Gradle poate actualiza automat framework-ul la compilare prin embedAndSignAppleFrameworkForXcode. Pentru testare pe simulator, este suficient binarul iosSimulatorArm64 sau iosX64.

KMP vs Flutter vs React Native

Alegerea între KMP, Flutter și React Native depinde de prioritate: reutilizarea logicii sau multi-platformă completă. KMP oferă UI nativ pe fiecare platformă, dar necesită două baze de cod pentru interfață. Flutter și React Native folosesc un UI unic, dar sacrifică nativitatea.

Când să alegeți KMP: proiectul necesită un UI de înaltă performanță (jocuri, hărți, animații), codul nativ existent trebuie reutilizat, echipa cunoaște deja Kotlin și platformele native. Când să alegeți Flutter/RN: MVP sau startup cu buget limitat, echipă cu un singur profil, UI nu necesită personalizare nativă profundă.

Instrumente și biblioteci KMP

Ecosistemul instrumentelor KMP include biblioteci pentru toate straturile aplicației: rețea (Ktor), serializare (kotlinx.serialization), baze de date (SQLDelight), navigare (Decompose), DI (Koin) și stocare date (multiplatform-settings). JetBrains susține Compose Multiplatform — un framework UI în Kotlin care funcționează pe toate platformele.

// Repository în KMP cu 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 — framework UI pentru KMP bazat pe Jetpack Compose. Permite scrierea interfeței în Kotlin pentru Android, iOS, Desktop și Web. În 2025, Compose Multiplatform a atins status stabil pentru Android și Desktop; ținta iOS este în beta. Pentru proiectele de producție cu UI nativ, avantajul KMP rămâne principala diferență față de Flutter.