Kotlin Multiplatform: ano ito, shared module at expect/actual

Ano ang Kotlin Multiplatform?

Kotlin Multiplatform — teknolohiya ng cross-compilation na nagpapahintulot sa pagsulat ng shared code sa Kotlin at pag-compile nito para sa iba't ibang platform: JVM (Android), LLVM (iOS, macOS, watchOS), JavaScript (Web) at native na binary (Linux, Windows). Ang KMP ay hindi isang UI framework — nilulutas nito ang problema ng muling paggamit ng lohika ng negosyo, hindi ng mga interface.

Ang arkitektura ng KMP ay binuo sa paligid ng shared module — isang Gradle module na naglalaman ng commonMain na may code na independyente sa platform at source sets para sa bawat target (androidMain, iosMain, desktopMain). Ayon sa datos ng JetBrains noong 2025, mahigit 40% ng mga bagong proyekto ng Kotlin ang gumagamit ng KMP para sa pagbabahagi ng code sa pagitan ng mga platform.

Kotlin Multiplatform Mobile (KMM) — dating pangalan para sa mobile scenario na iOS+Android. Mula noong Kotlin 2.1+, ang terminong KMM ay pinalitan ng pangkalahatang Kotlin Multiplatform, dahil ang teknolohiya ay lumampas na sa mga hangganan ng mobile development. Ang Netflix, McDonald's at VMware ay gumagamit ng KMP sa produksyon para sa pagbabahagi ng code sa pagitan ng mga mobile application.

Mekanismong expect/actual: arkitektura

Expect/actual — pangunahing mekanismo ng KMP para sa pagtatrabaho sa platform code. Sa commonMain ay idinedeklara ang isang expect-deklarasyon (function, class, property), at sa bawat platform-specific source set (androidMain, iosMain) — ang actual-implementasyon. Sinusuri ng compiler na para sa bawat expect ay may actual sa bawat target na platform.

// commonMain — deklarasyon ng platform API
expect fun getPlatformName(): String

expect class PlatformContext(val appVersion: String)

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

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

Hierarkiya ng source sets sa KMP ay nagpapahintulot sa paglikha ng mga intermediate na antas: halimbawa, iosArm64Main (mga pisikal na iOS device) at iosSimulatorArm64Main (simulator) na may karaniwang iosMain. Ang code mula sa commonMain ay naa-access ng lahat ng platform, at ang code mula sa iosMain ay para lamang sa mga iOS target. Binabawasan nito ang pagdoble kapag ang implementasyon ay naiiba hindi para sa bawat platform, kundi para sa isang grupo ng mga platform.

Sa praktika, ang expect/actual ay ginagamit para sa: pagkuha ng lokal na storage (SharedPreferences vs NSUserDefaults), pagtatrabaho sa network (HttpEngine para sa bawat platform), pag-access sa file system, cryptography at analytics. Inirerekomenda ng JetBrains na bawasan ang bilang ng expect/actual at ilipat ang mas maraming code hangga't maaari sa commonMain.

Shared module: istraktura at Gradle

Shared module — isang karaniwang Gradle module na may plugin na `org.jetbrains.kotlin.multiplatform`. Naglalaman ito ng shared code sa `src/commonMain/kotlin/` at mga implementasyon ng platform sa `src/androidMain/kotlin/` at `src/iosMain/kotlin/`. Ang proyektong KMP ay kumokonekta rin sa `androidApp` at `iosApp`, na nakadepende sa 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")
            }
        }
    }
}

Ang configuration ng Gradle para sa KMP ay nangangailangan ng malinaw na pagtukoy ng mga iOS target — x64 (Intel simulator), arm64 (mga pisikal na device) at simulatorArm64 (Apple Silicon simulator). Para sa bawat target, isang hiwalay na Apple framework ang nabubuo. Ang plugin na `kotlin("multiplatform")` ay awtomatikong nagco-configure ng compilation para sa JVM at LLVM depende sa mga idineklarang target.

Ktor at kotlinx.serialization — mga karaniwang aklatan ng KMP na sumusuporta sa shared code. Ang Ktor ay nagbibigay ng HTTP client na may mga engine para sa bawat platform (OkHttp para sa Android, Darwin para sa iOS). Ang kotlinx.serialization ay gumagana sa anumang platform nang walang expect/actual dahil sa multi-platform na implementasyon sa commonMain.

Pagsasama sa iOS sa pamamagitan ng Kotlin/Native

Kotlin/Native — compiler ng Kotlin sa native code sa pamamagitan ng LLVM. Para sa iOS, ang shared module ay nagko-compile sa Apple framework (.framework) na kumokonekta sa pamamagitan ng Xcode. Ang pagtawag ng shared code mula sa Swift/Objective-C ay nangyayari sa pamamagitan ng nabubuong Objective-C headers, kaya ang API ng shared module ay dapat na compatible sa Objective-C.

Mga limitasyon ng pagsasama sa iOS: Ang mga koleksyon ng Kotlin (List, Map) ay nagko-convert sa NSArray/NSDictionary. Ang mga function na may default na parameter ay hindi ini-export — kailangan ang mga overloads. Para sa mga suspend-function, nabubuo ang mga pamamaraang nakabatay sa callback na may `@ObjCName` at suporta sa async/await mula noong Kotlin 2.0+.

// iOS app: pagtawag ng shared module mula sa 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)")
            }
        })
    }
}

Ang pagsasama ng shared module sa Xcode ay ginagawa sa pamamagitan ng embed-and-framework — ang nabuong `.xcframework` ay idinaragdag sa proyekto ng Xcode. Ang Gradle plugin ay maaaring awtomatikong mag-update ng framework sa pag-build sa pamamagitan ng embedAndSignAppleFrameworkForXcode. Para sa pagsubok sa simulator, sapat na ang iosSimulatorArm64 o iosX64 binary.

KMP vs Flutter vs React Native

Ang pagpili sa pagitan ng KMP, Flutter at React Native ay depende sa prayoridad: muling paggamit ng lohika o ganap na multi-platform. Ang KMP ay nagbibigay ng native na UI sa bawat platform, ngunit nangangailangan ng dalawang code base para sa interface. Ang Flutter at React Native ay gumagamit ng iisang UI, ngunit isinasakripisyo ang pagka-native.

Kailan pumili ng KMP: ang proyekto ay nangangailangan ng high-performance UI (mga laro, mapa, animation), umiiral na native code ay kailangang gamitin muli, ang team ay alam na ang Kotlin at native platforms. Kailan pumili ng Flutter/RN: MVP o startup na may limitadong budget, team na may isang profile, ang UI ay hindi nangangailangan ng malalim na native customization.

Mga tool at aklatan ng KMP

Ang ecosystem ng mga tool ng KMP ay may kasamang mga aklatan para sa lahat ng layer ng application: network (Ktor), serialization (kotlinx.serialization), database (SQLDelight), navigation (Decompose), DI (Koin) at storage ng data (multiplatform-settings). Sinusuportahan ng JetBrains ang Compose Multiplatform — isang UI framework sa Kotlin na gumagana sa lahat ng platform.

// Repository sa KMP gamit ang 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 para sa KMP na nakabatay sa Jetpack Compose. Nagbibigay-daan sa pagsulat ng interface sa Kotlin para sa Android, iOS, Desktop at Web. Noong 2025, ang Compose Multiplatform ay umabot sa stable na status para sa Android at Desktop; ang iOS target ay nasa beta. Para sa production projects na may native na UI, ang bentahe ng KMP ay nananatiling pangunahing pagkakaiba mula sa Flutter.