Kotlin Multiplatform: bu nima, shared module va expect/actual

Kotlin Multiplatform nima?

Kotlin Multiplatform — umumiy kodni Kotlin da yozish va uni turli platformalar uchun kompilyatsiya qilish imkonini beruvchi o'zaro kompilyatsiya texnologiyasi: JVM (Android), LLVM (iOS, macOS, watchOS), JavaScript (Web) va mahalliy binary fayllar (Linux, Windows). KMP UI framework emas — u interfeyslarni emas, balki biznes mantiqini qayta ishlatish muammosini hal qiladi.

KMP arxitekturasi shared module — platformadan mustaqil kodga ega commonMain va har bir maqsad uchun source sets (androidMain, iosMain, desktopMain) ni o'z ichiga olgan Gradle moduli atrofida quriladi. JetBrains ning 2025 yil ma'lumotlariga ko'ra, yangi Kotlin loyihalarining 40% dan ortig'i platformalar o'rtasida kod almashish uchun KMP dan foydalanadi.

Kotlin Multiplatform Mobile (KMM) — iOS+Android mobil stsenariysi uchun oldingi nom. Kotlin 2.1+ dan boshlab KMM atamasi umumiy Kotlin Multiplatform bilan almashtirildi, chunki texnologiya mobil ishlanma chegaralaridan chiqib ketdi. Netflix, McDonald's va VMware mobil ilovalar o'rtasida kod almashish uchun KMP dan ishlab chiqarishda foydalanadi.

Expect/actual mexanizmi: arxitektura

Expect/actual — platforma kodi bilan ishlash uchun KMP ning asosiy mexanizmi. commonMain da expect-deklaratsiya (funksiya, sinf, xususiyat) e'lon qilinadi, har bir platform-specific source set da (androidMain, iosMain) esa actual-amalga oshirish. Kompilyator har bir expect uchun har bir maqsadli platformada actual mavjudligini tekshiradi.

// commonMain — platforma API ni e'lon qilish
expect fun getPlatformName(): String

expect class PlatformContext(val appVersion: String)

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

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

Source sets iyerarxiyasi KMP da oraliq darajalar yaratishga imkon beradi: masalan, iosArm64Main (fizik iOS qurilmalari) va iosSimulatorArm64Main (simulyator) umumiy iosMain bilan. commonMain dan kelgan kod barcha platformalar uchun mavjud, iosMain dan kelgan kod esa faqat iOS maqsadlari uchun. Bu amalga oshirish har bir platforma uchun emas, balki platformalar guruhi uchun farq qilganda takrorlanishni kamaytiradi.

Amaliyotda expect/actual quyidagilar uchun ishlatiladi: mahalliy saqlashga kirish (SharedPreferences vs NSUserDefaults), tarmoq bilan ishlash (har bir platforma uchun HttpEngine), fayl tizimiga kirish, kriptografiya va analitika. JetBrains expect/actual sonini minimallashtirish va imkon qadar ko'proq kodni commonMain ga o'tkazishni tavsiya qiladi.

Shared module: tuzilma va Gradle

Shared module — `org.jetbrains.kotlin.multiplatform` plagini bilan standart Gradle moduli. U umumiy kodni `src/commonMain/kotlin/` da va platforma amalga oshirishlarini `src/androidMain/kotlin/` va `src/iosMain/kotlin/` da o'z ichiga oladi. KMP loyihasi shuningdek shared moduliga bog'liq bo'lgan `androidApp` va `iosApp` ni birlashtiradi.

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

KMP uchun Gradle konfiguratsiyasi iOS maqsadlarini — x64 (Intel simulyatori), arm64 (fizik qurilmalar) va simulatorArm64 (Apple Silicon simulyatori) aniq ko'rsatishni talab qiladi. Har bir maqsad uchun alohida Apple framework yaratiladi. `kotlin("multiplatform")` plagini e'lon qilingan maqsadlarga qarab avtomatik ravishda JVM va LLVM uchun kompilyatsiyani sozlaydi.

Ktor va kotlinx.serialization — umumiy kodni qo'llab-quvvatlovchi standart KMP kutubxonalari. Ktor har bir platforma uchun dvigatellar bilan (Android uchun OkHttp, iOS uchun Darwin) HTTP mijozini taqdim etadi. kotlinx.serialization commonMain da ko'p platformali amalga oshirish tufayli expect/actual siz istalgan platformada ishlaydi.

iOS bilan Kotlin/Native orqali integratsiya

Kotlin/Native — LLVM orqali Kotlin ni mahalliy kodga kompilyatsiya qiluvchi kompilyator. iOS uchun shared module Apple framework (.framework) shaklida kompilyatsiya qilinadi va Xcode orqali ulanadi. Swift/Objective-C dan umumiy kodni chaqirish yaratilgan Objective-C sarlavhalari orqali amalga oshadi, shuning uchun shared module API si Objective-C bilan mos kelishi kerak.

iOS integratsiyasining cheklovlari: Kotlin kolleksiyalari (List, Map) NSArray/NSDictionary ga aylantiriladi. Standart parametrlarga ega funksiyalar eksport qilinmaydi — overloads kerak. Suspend-funksiyalar uchun `@ObjCName` bilan callback-ga asoslangan metodlar va Kotlin 2.0+ dan async/await qo'llab-quvvatlashi yaratiladi.

// iOS ilovasi: shared module ni Swift dan chaqirish
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)")
            }
        })
    }
}

Shared module ni Xcode da integratsiyasi embed-and-framework orqali amalga oshadi — yaratilgan `.xcframework` Xcode loyihasiga qo'shiladi. Gradle plagini embedAndSignAppleFrameworkForXcode orqali yig'ish vaqtida framework ni avtomatik yangilashi mumkin. Simulyatorda sinash uchun iosSimulatorArm64 yoki iosX64 binary fayli yetarli.

KMP vs Flutter vs React Native

KMP, Flutter va React Native o'rtasidagi tanlov ustuvorlikka bog'liq: mantiqni qayta ishlatish yoki to'liq ko'p platformalilik. KMP har bir platformada mahalliy UI ni ta'minlaydi, lekin interfeys uchun ikkita kod bazasini talab qiladi. Flutter va React Native yagona UI dan foydalanadi, ammo mahalliylikni yo'qotadi.

KMP ni qachon tanlash kerak: loyiha yuqori unumli UI talab qiladi (o'yinlar, xaritalar, animatsiyalar), mavjud mahalliy kodni qayta ishlatish kerak, jamoa allaqachon Kotlin va mahalliy platformalarni biladi. Flutter/RN ni qachon tanlash kerak: cheklangan byudjetli MVP yoki startap, bir profilli jamoa, UI chuqur mahalliy sozlashni talab qilmaydi.

KMP vositalari va kutubxonalari

KMP vositalari ekotizimiga ilovaning barcha qatlamlari uchun kutubxonalar kiradi: tarmoq (Ktor), serializatsiya (kotlinx.serialization), ma'lumotlar bazasi (SQLDelight), navigatsiya (Decompose), DI (Koin) va ma'lumot saqlash (multiplatform-settings). JetBrains barcha platformalarda ishlaydigan Kotlin da UI framework bo'lgan Compose Multiplatform ni qo'llab-quvvatlaydi.

// SQLDelight + Ktor bilan KMP da Repository
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 — Jetpack Compose ga asoslangan KMP uchun UI framework. Android, iOS, Desktop va Web uchun Kotlin da interfeys yozish imkonini beradi. 2025 yilda Compose Multiplatform Android va Desktop uchun barqaror holatga erishdi; iOS maqsadi beta bosqichida. Mahalliy UI bilan ishlab chiqarish loyihalari uchun KMP ning afzalligi Flutter dan asosiy farq bo'lib qolmoqda.