Kotlin Multiplatform: apa itu, shared module dan expect/actual

Apa itu Kotlin Multiplatform?

Kotlin Multiplatform — teknologi kompilasi silang yang memungkinkan penulisan kode bersama di Kotlin dan mengompilasinya untuk berbagai platform: JVM (Android), LLVM (iOS, macOS, watchOS), JavaScript (Web) dan biner asli (Linux, Windows). KMP bukanlah kerangka UI — ia memecahkan masalah penggunaan kembali logika bisnis, bukan antarmuka.

Arsitektur KMP dibangun di sekitar shared module — modul Gradle yang berisi commonMain dengan kode independen platform dan source sets untuk setiap target (androidMain, iosMain, desktopMain). Menurut data JetBrains tahun 2025, lebih dari 40% proyek Kotlin baru menggunakan KMP untuk berbagi kode antar platform.

Kotlin Multiplatform Mobile (KMM) — nama sebelumnya untuk skenario seluler iOS+Android. Sejak Kotlin 2.1+, istilah KMM digantikan dengan Kotlin Multiplatform umum, karena teknologi telah melampaui batas pengembangan seluler. Netflix, McDonald's dan VMware menggunakan KMP dalam produksi untuk berbagi kode antar aplikasi seluler.

Mekanisme expect/actual: arsitektur

Expect/actual — mekanisme kunci KMP untuk bekerja dengan kode platform. Di commonMain dideklarasikan deklarasi expect (fungsi, kelas, properti), dan di setiap source set khusus platform (androidMain, iosMain) — implementasi actual. Kompilator memeriksa bahwa untuk setiap expect terdapat actual di setiap platform target.

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

expect class PlatformContext(val appVersion: String)

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

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

Hierarki source sets di KMP memungkinkan pembuatan level perantara: misalnya, iosArm64Main (perangkat fisik iOS) dan iosSimulatorArm64Main (simulator) dengan iosMain bersama. Kode dari commonMain dapat diakses oleh semua platform, dan kode dari iosMain hanya untuk target iOS. Ini mengurangi duplikasi ketika implementasi berbeda bukan untuk setiap platform, tetapi untuk sekelompok platform.

Dalam praktiknya, expect/actual digunakan untuk: mendapatkan penyimpanan lokal (SharedPreferences vs NSUserDefaults), bekerja dengan jaringan (HttpEngine untuk setiap platform), akses ke sistem file, kriptografi dan analitik. JetBrains merekomendasikan untuk meminimalkan jumlah expect/actual dan memindahkan sebanyak mungkin kode ke commonMain.

Shared module: struktur dan Gradle

Shared module — modul Gradle standar dengan plugin `org.jetbrains.kotlin.multiplatform`. Ini berisi kode bersama di `src/commonMain/kotlin/` dan implementasi platform di `src/androidMain/kotlin/` dan `src/iosMain/kotlin/`. Proyek KMP juga menghubungkan `androidApp` dan `iosApp`, yang bergantung pada 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")
            }
        }
    }
}

Konfigurasi Gradle untuk KMP memerlukan penentuan eksplisit target iOS — x64 (simulator Intel), arm64 (perangkat fisik) dan simulatorArm64 (simulator Apple Silicon). Untuk setiap target, Apple framework terpisah dibuat. Plugin `kotlin("multiplatform")` secara otomatis mengonfigurasi kompilasi untuk JVM dan LLVM tergantung pada target yang dideklarasikan.

Ktor dan kotlinx.serialization — pustaka standar KMP yang mendukung kode bersama. Ktor menyediakan klien HTTP dengan mesin untuk setiap platform (OkHttp untuk Android, Darwin untuk iOS). kotlinx.serialization bekerja pada platform apa pun tanpa expect/actual berkat implementasi multi-platform di commonMain.

Integrasi dengan iOS melalui Kotlin/Native

Kotlin/Native — kompilator Kotlin ke kode asli melalui LLVM. Untuk iOS, shared module dikompilasi menjadi Apple framework (.framework) yang dihubungkan melalui Xcode. Pemanggilan kode bersama dari Swift/Objective-C terjadi melalui header Objective-C yang dihasilkan, oleh karena itu API shared module harus kompatibel dengan Objective-C.

Keterbatasan integrasi iOS: Koleksi Kotlin (List, Map) dikonversi ke NSArray/NSDictionary. Fungsi dengan parameter default tidak diekspor — diperlukan overloads. Untuk fungsi suspend, metode berbasis callback dihasilkan dengan `@ObjCName` dan dukungan async/await sejak Kotlin 2.0+.

// Aplikasi iOS: memanggil shared module dari 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)")
            }
        })
    }
}

Integrasi shared module di Xcode dilakukan melalui embed-and-framework — `.xcframework` yang dihasilkan ditambahkan ke proyek Xcode. Plugin Gradle dapat secara otomatis memperbarui framework saat build melalui embedAndSignAppleFrameworkForXcode. Untuk pengujian pada simulator, biner iosSimulatorArm64 atau iosX64 sudah cukup.

KMP vs Flutter vs React Native

Pilihan antara KMP, Flutter dan React Native tergantung pada prioritas: penggunaan kembali logika atau multiplatform penuh. KMP memberikan UI asli di setiap platform, tetapi memerlukan dua basis kode untuk antarmuka. Flutter dan React Native menggunakan UI tunggal, tetapi mengorbankan keaslian.

Kapan memilih KMP: proyek membutuhkan UI berkinerja tinggi (game, peta, animasi), kode asli yang ada perlu digunakan kembali, tim sudah mengenal Kotlin dan platform asli. Kapan memilih Flutter/RN: MVP atau startup dengan anggaran terbatas, tim dengan satu profil, UI tidak memerlukan kustomisasi asli yang mendalam.

Alat dan pustaka KMP

Ekosistem alat KMP mencakup pustaka untuk semua lapisan aplikasi: jaringan (Ktor), serialisasi (kotlinx.serialization), basis data (SQLDelight), navigasi (Decompose), DI (Koin) dan penyimpanan data (multiplatform-settings). JetBrains mendukung Compose Multiplatform — kerangka UI di Kotlin yang berfungsi di semua platform.

// Repository di KMP dengan 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 — kerangka UI untuk KMP yang berbasis pada Jetpack Compose. Memungkinkan penulisan antarmuka di Kotlin untuk Android, iOS, Desktop dan Web. Pada tahun 2025, Compose Multiplatform mencapai status stabil untuk Android dan Desktop; target iOS dalam beta. Untuk proyek produksi dengan UI asli, keunggulan KMP tetap menjadi perbedaan utama dari Flutter.