Kotlin Multiplatform Mobile — apa itu, konsep kunci dan arsitektur KMM

Apa itu Kotlin Multiplatform Mobile?

Kotlin Multiplatform Mobile (KMM) — adalah teknologi yang memungkinkan menulis logika bisnis bersama aplikasi seluler di Kotlin dan menggunakannya di iOS dan Android tanpa menduplikasi kode. Berbeda dengan Ionic atau Cordova, KMM tidak merender antarmuka di WebView — UI tetap sepenuhnya asli dan ditulis di SwiftUI (iOS) dan Jetpack Compose (Android).

KMM diumumkan oleh JetBrains pada tahun 2019 sebagai bagian dari strategi Kotlin Multiplatform. Perbedaan utama dari solusi lintas platform lainnya — kerangka kerja tidak mencoba menyatukan UI, tetapi berfokus pada berbagi kode yang benar-benar sama untuk kedua platform: permintaan jaringan, model data, validasi formulir, aturan bisnis, dan bekerja dengan basis data.

Menurut JetBrains Developer Survey (2025), KMM digunakan oleh 14% pengembang seluler, dan angka ini tumbuh 5% setiap tahun. Teknologi ini dipilih oleh perusahaan dengan persyaratan kinerja tinggi dan pengalaman pengguna asli, yang solusi hibridanya tidak dapat diterima.

Arsitektur KMM: modul shared dan implementasi platform

Arsitektur KMM terdiri dari tiga modul: shared (kode bersama di Kotlin), iosApp (aplikasi iOS asli di Swift) dan androidApp (aplikasi Android asli di Kotlin). Modul shared dikompilasi menjadi JAR untuk Android dan menjadi kerangka kerja universal (Apple Framework) untuk iOS.

Modul Shared: apa yang masuk ke kode bersama

Semua lapisan yang tidak bergantung pada platform masuk ke modul shared: lapisan jaringan di Ktor Client, model data dengan serialisasi melalui kotlinx.serialization, repositori untuk manajemen data, validasi formulir, dan aturan bisnis (misalnya, menghitung biaya pengiriman atau memeriksa hak akses).

Modul shared menggunakan Gradle Multiplatform Plugin dan berisi tiga set sumber: commonMain (kode bersama), androidMain (implementasi khusus Android) dan iosMain (implementasi khusus iOS). Kompiler Kotlin/Native mengubah kode bersama menjadi pustaka asli untuk iOS, yang terhubung ke proyek Swift melalui XCFramework.

Modul platform

Modul Android — adalah aplikasi Android standar di Kotlin dengan Jetpack Compose atau ViewBinding. Modul shared terhubung sebagai dependensi Gradle biasa, dan semua kelas dari commonMain dapat diakses langsung.

Modul iOS — adalah proyek Xcode di Swift atau Objective-C. Modul shared terhubung melalui CocoaPods, Swift Package Manager atau XCFramework. Kotlin/Native menghasilkan header Objective-C untuk mengekspor tipe Kotlin, membuatnya dapat diakses dari Swift.

Mekanisme expect/actual di KMM

expect/actual — adalah mekanisme Kotlin Multiplatform yang memungkinkan mendeklarasikan API dalam kode bersama (expect declaration) dan menyediakan implementasinya secara terpisah untuk setiap platform (actual declaration). Kompiler memastikan bahwa actual ada untuk setiap platform target.

Skenario umum penggunaan expect/actual: mendapatkan waktu saat ini dengan mempertimbangkan zona waktu, bekerja dengan SharedPreferences (Android) / UserDefaults (iOS), fungsi kriptografi, dan pembuatan UUID. Di setiap platform, API sistem sendiri digunakan.

Tanpa expect/actual, mustahil memiliki kode logika bisnis yang seragam, karena API untuk bekerja dengan sistem file, jaringan, dan penyimpanan berbeda antara iOS dan Android pada tingkat panggilan sistem. Mekanisme ini menjamin pengembang tidak lupa mengimplementasikan bagian platform.

Untuk panggilan platform seperti bekerja dengan kamera atau biometrik, KMM menawarkan pustaka expect/actual yang dikombinasikan dengan plugin mirip Cordova, tetapi di Kotlin/Native. JetBrains juga merilis pustaka kotlinx-datetime yang mengabstraksikan pekerjaan dengan tanggal.

Contoh kode di KMM

Mari kita lihat struktur dasar proyek KMM dengan deklarasi fungsi expect untuk menghasilkan UUID dan implementasinya untuk iOS dan Android.

// commonMain — deklarasi bersama
expect fun generateUUID(): String

// androidMain — implementasi untuk Android
actual fun generateUUID(): String {
    return java.util.UUID.randomUUID().toString()
}

// iosMain — implementasi untuk iOS
actual fun generateUUID(): String {
    return platform.Foundation.NSUUID().UUIDString
}

Dalam kode bersama dideklarasikan expect fun generateUUID(). Untuk Android menggunakan java.util.UUID, untuk iOS — NSUUID dari kerangka kerja Foundation. Di sisa kode modul shared, fungsi ini dipanggil tanpa mempertimbangkan platform.

Contoh permintaan jaringan menggunakan Ktor Client dalam kode bersama:

import io.ktor.client.*
import io.ktor.client.request.*
import io.ktor.client.statement.*
import kotlinx.serialization.*
import kotlinx.serialization.json.*

@Serializable
data class User(
    val id: Int,
    val name: String
)

class UserRepository {
    private val client = HttpClient()

    suspend fun getUser(id: Int): User {
        val response: HttpStatement =
            client.get("https://api.example.com/users/$id")
        return Json.decodeFromString(response.bodyAsText())
    }
}

Kode ini bekerja di kedua platform tanpa perubahan. Ktor Client menggunakan OkHttp di Android dan NSURLSession di iOS secara otomatis, tanpa konfigurasi tambahan. Serialisasi JSON melalui kotlinx.serialization juga lintas platform.

Perbandingan KMM dengan Flutter dan React Native

KMM menempati posisi unik di antara teknologi lintas platform, karena tidak mencoba mengganti UI asli tidak seperti Flutter dan React Native. KMM — adalah solusi untuk berbagi logika, bukan untuk menyatukan antarmuka.

Keuntungan utama KMM — kontrol penuh atas UI. Jika aplikasi harus terlihat dan berperilaku asli di setiap platform (misalnya, menggunakan iOS TabBar dan Android BottomNavigation dengan animasi platform), KMM adalah satu-satunya solusi lintas platform yang menyediakan ini tanpa solusi sementara.

Kekurangan — tim harus menguasai Kotlin, Swift, Jetpack Compose dan SwiftUI secara bersamaan, yang mempersulit perekrutan. Flutter dan React Native memerlukan pengetahuan satu bahasa dan satu kerangka kerja.

Keuntungan dan tantangan penerapan KMM

Kotlin Multiplatform Mobile — adalah teknologi yang kuat, tetapi penerapannya memerlukan pendekatan yang seimbang. Mari kita lihat keuntungan utama dan tantangan umum yang dihadapi tim.

Keuntungan KMM

Keuntungan pertama dan utama — pengurangan duplikasi kode. Menurut JetBrains Case Studies (2024), tim yang menerapkan KMM mengurangi jumlah kode yang digandakan sebesar 60–80% untuk lapisan jaringan dan 40–50% untuk logika bisnis secara keseluruhan. Ini langsung memengaruhi kecepatan pengembangan dan jumlah bug.

Keuntungan kedua — kinerja pada tingkat aplikasi asli. Berbeda dengan kerangka kerja hibrida, KMM tidak menambahkan lapisan abstraksi antara UI dan sistem. Kode logika bisnis dijalankan sama cepatnya seperti jika ditulis dalam Swift atau Kotlin untuk setiap platform secara terpisah.

Tantangan penerapan

Tantangan utama — kualifikasi tim. Pengembang harus menguasai Kotlin (untuk modul shared), serta Swift dan Jetpack Compose (untuk UI). Menemukan spesialis universal sulit, oleh karena itu biasanya tim dibentuk dari pengembang Android dan iOS yang bersama-sama mengelola modul shared.

Tantangan kedua — perangkat. KMM memerlukan konfigurasi Gradle, CocoaPods atau Swift Package Manager, serta integrasi dengan Xcode. Pada tahap awal proyek, masalah konfigurasi build sering terjadi, terutama saat bekerja dengan pustaka C.

Tantangan ketiga — debugging. Ketika bug muncul di persimpangan Kotlin/Native dan Swift, menentukan penyebabnya lebih sulit daripada dalam aplikasi monolitik. JetBrains terus meningkatkan alat debugging, tetapi dalam praktiknya tim harus menghabiskan hingga 20% waktu untuk tugas infrastruktur.