Kotlin/Native — คืออะไร ตัวคอมไพล์เป็นโค้ดเนทีฟและคุณลักษณะ

Kotlin/Native คืออะไร?

Kotlin/Native คือเทคโนโลยีสำหรับคอมไพล์โค้ด Kotlin เป็นโค้ดเครื่องเนทีฟ พัฒนาโดย JetBrains ความแตกต่างหลักจาก Kotlin/JVM คือไม่จำเป็นต้องใช้เครื่องเสมือน — ไฟล์ปฏิบัติการที่ได้มีเพียงโค้ดเครื่องและรันไทม์ขั้นต่ำ ซึ่งช่วยให้เรียกใช้แอปพลิเคชัน Kotlin บนอุปกรณ์และระบบที่ไม่รองรับ JVM รวมถึง iPhone, Apple Watch และระบบฝังตัว

ประวัติของ Kotlin/Native เริ่มต้นจากโปรเจกต์ — คอมไพเลอร์ทดลองที่ถูกรวมเข้ากับสาขาหลักของ Kotlin ในปี 2017 ในปี 2019 ที่ KotlinConf มีการประกาศรองรับ iOS ในฐานะแพลตฟอร์มเป้าหมาย ซึ่งเป็นจุดเปลี่ยนสำคัญสำหรับการพัฒนามือถือ ตั้งแต่ Kotlin 1.9.20 คอมไพเลอร์ Kotlin/Native มีความเสถียรและรวมอยู่ใน Kotlin Multiplatform โดยค่าเริ่มต้น

คุณลักษณะสำคัญของ Kotlin/Native คือการใช้การแทนค่ากลางร่วมกัน IR ซึ่งถูกคอมไพล์เป็นโค้ดเครื่องสำหรับแต่ละแพลตฟอร์มแยกกัน ซึ่งให้ฟรอนต์เอนด์การคอมไพล์แบบรวมสำหรับแบ็กเอนด์ Kotlin ทั้งหมด: JVM, JS และ Native

คอมไพเลอร์ Kotlin/Native ทำงานอย่างไร

การคอมไพล์ ใน Kotlin/Native ผ่านหลายขั้นตอนการแปลง โค้ดต้นฉบับ Kotlin จะถูกแปลงเป็นการแทนค่าภายในก่อน จากนั้นปรับให้เหมาะสมและส่งไปยังแบ็กเอนด์ LLVM เพื่อสร้างโค้ดเครื่อง ขั้นตอนสุดท้ายคือการเชื่อมโยงกับไลบรารีรันไทม์และสร้างไฟล์ปฏิบัติการหรือไลบรารีไดนามิก

สถาปัตยกรรมประกอบด้วยสามองค์ประกอบหลัก: ฟรอนต์เอนด์ (การแยกวิเคราะห์และตรวจสอบชนิด), ตัวสร้าง IR (การสร้างการแทนค่ากลาง) และ แบ็กเอนด์ LLVM (การสร้างโค้ดเครื่อง) รูปแบบนี้คล้ายกับแนวทางที่ใช้ในคอมไพเลอร์ Clang สำหรับ C++ และ Rust

// การคอมไพล์ Kotlin/Native ผ่านบรรทัดคำสั่ง
kotlinc-native hello.kt -o hello -opt

// สร้างสำหรับ iOS arm64 ผ่าน Kotlin Multiplatform
./gradlew :shared:linkDebugFrameworkIosArm64

สำหรับการจัดการหน่วยความจำ Kotlin/Native ใช้ Memory Manager ของตัวเอง ซึ่งอิงตามการนับการอ้างอิงพร้อมตัวตรวจจับวงจร ตั้งแต่ Kotlin 1.7.20 ตัวจัดการหน่วยความจำใหม่ทำงานโดยค่าเริ่มต้นและไม่ต้องการคำอธิบายประกอบ @ThreadLocal หรือ @SharedImmutable ตัวเก็บขยะทำงานโดยไม่หยุดเธรด ซึ่งสำคัญมากสำหรับ iOS ที่ระบบสามารถบังคับปิดแอปพลิเคชันระหว่างการบล็อกเธรดหลักเป็นเวลานาน

ขั้นตอนการคอมไพล์ Kotlin/Native

กระบวนการคอมไพล์แบ่งออกเป็นห้าขั้นตอน: การแยกวิเคราะห์ (การวิเคราะห์โค้ดต้นฉบับ), การวิเคราะห์ความหมาย (การตรวจสอบชนิดและการแก้ไขชื่อ), การสร้าง IR (การสร้างการแทนค่ากลาง), การปรับให้เหมาะสม (การทำให้เรียบง่ายและการลบโค้ดที่ตายแล้ว) และ การสร้างโค้ด ผ่าน LLVM แต่ละขั้นตอนสามารถดำเนินการแบบขนานสำหรับโมดูลต่าง ๆ ซึ่งช่วยเร่งการสร้างโปรเจกต์ขนาดใหญ่

แพลตฟอร์มที่รองรับโดย Kotlin/Native

Kotlin/Native รองรับ 13 แพลตฟอร์มเป้าหมาย แบ่งตามหมวดหมู่ สำหรับการพัฒนามือถือ มี iOS (arm64), Android (arm32, arm64, x86_64) และ watchOS แพลตฟอร์มเดสก์ท็อปประกอบด้วย macOS (x64, arm64), Windows (mingw x64) และ Linux (x64, arm64, arm32) สำหรับการพัฒนาเซิร์ฟเวอร์และระบบฝังตัว มี WebAssembly และ Kotlin/Native บน LLVM โดยไม่มีระบบปฏิบัติการ (แบบสแตนด์อโลน) แต่ละแพลตฟอร์มต้องการเฟรมเวิร์กหรือไลบรารีแยกต่างหากเป็นเอาต์พุต

แพลตฟอร์มสำหรับการพัฒนามือถือ

สำหรับ iOS Kotlin/Native จะสร้างเฟรมเวิร์กสากล (.framework) ที่สามารถเชื่อมต่อกับโปรเจกต์ Xcode สำหรับ Android NDK จะสร้างไลบรารีเนทีฟ .so ที่สามารถเรียกผ่าน JNI watchOS รองรับตั้งแต่ Kotlin 1.6.0 และ tvOS ตั้งแต่เวอร์ชัน 1.7.0 สถาปัตยกรรมแต่ละแบบต้องการการคอมไพล์แยกต่างหาก แต่ Kotlin Multiplatform จะทำให้กระบวนการนี้เป็นอัตโนมัติผ่านปลั๊กอิน Gradle

แพลตฟอร์มเดสก์ท็อปและเซิร์ฟเวอร์

macOS และ Linux ใช้สำหรับพัฒนาแอปพลิเคชันเดสก์ท็อปเนทีฟใน Kotlin โดยใช้เฟรมเวิร์ก Compose Multiplatform Windows (MinGW) รองรับตั้งแต่ Kotlin 1.3.70 และช่วยให้สร้างแอปพลิเคชัน Windows ได้โดยไม่ต้องติดตั้ง JVM สำหรับการพัฒนาเซิร์ฟเวอร์ Kotlin/Native สามารถใช้ในสภาพแวดล้อมที่ไม่มี JVM เช่น คอนเทนเนอร์ Docker ที่มีอิมเมจขั้นต่ำบนพื้นฐาน scratch หรือ Alpine

Kotlin/Native สำหรับการพัฒนา iOS

iOS เป็นแพลตฟอร์มเป้าหมายหลักของ Kotlin/Native ในบริบทของ KMM คอมไพเลอร์สร้างเฟรมเวิร์ก iOS ที่มีโค้ดที่ใช้ร่วมกันทั้งหมด ซึ่งจากนั้นเชื่อมต่อกับโปรเจกต์ Xcode เฟรมเวิร์กรองรับทั้งการเชื่อมโยงแบบคงที่และแบบไดนามิก Kotlin/Native สร้างแรปเปอร์ Objective-C สำหรับคลาสและฟังก์ชัน Kotlin ซึ่งให้การผสานรวมโดยตรงกับโค้ด Swift และ Objective-C

การผสานรวมกับ iOS จำเป็นต้องกำหนดค่า Xcode เพื่อเชื่อมต่อเฟรมเวิร์กที่สร้างขึ้น Kotlin Multiplatform ทำให้กระบวนการนี้เป็นอัตโนมัติโดยใช้งาน embedAndSignAppleFrameworkForXcode ซึ่งเรียกใช้จาก Xcode Build Phases สำหรับการดีบัก Kotlin/Native รองรับจุดหยุดในโค้ดโมดูลที่ใช้ร่วมกันเมื่อเรียกใช้แอปพลิเคชันบนตัวจำลอง iOS

// โค้ด Kotlin ที่ถูกคอมไพล์เป็นเฟรมเวิร์ก iOS
package com.itsectr.shared

class GreetingProvider {
    fun createGreeting(): String {
        return "Hello from Kotlin/Native!"
    }

    fun formatVersion(major: Int, minor: Int): String {
        return "v$major.$minor"
    }
}

Interop กับ Objective-C และ Swift

Interop กับโค้ด iOS ทำงานทั้งสองทิศทาง Kotlin/Native สร้างส่วนหัว Objective-C สำหรับคลาส Kotlin ซึ่งเข้าถึงได้โดยอัตโนมัติจาก Swift การสื่อสารย้อนกลับมีให้โดยใช้คำอธิบายประกอบ @ObjCName สำหรับการส่งออกฟังก์ชัน Kotlin ภายใต้ชื่อ Objective-C ที่ระบุ คอลเล็กชัน Kotlin จะถูกแปลงเป็น NSArray และ NSDictionary โดยอัตโนมัติ และโคโรทีน Kotlin จะถูกห่อใน Combine publishers ผ่านไลบรารี SKIE สำหรับการทำงานกับเฟรมเวิร์ก iOS จาก Kotlin จะใช้ cinterop — เครื่องมือสำหรับสร้างการเชื่อมโยง Kotlin กับส่วนหัว Objective-C

ตัวอย่างโค้ด: การตั้งค่าและการคอมไพล์

ในการเริ่มต้นกับ Kotlin/Native จำเป็นต้องกำหนดค่า build.gradle.kts ด้วยปลั๊กอิน Kotlin Multiplatform และแพลตฟอร์มเป้าหมาย เรามาดูการกำหนดค่าขั้นต่ำสำหรับโปรเจกต์ KMM ที่รองรับ iOS และ Android

plugins {
    kotlin("multiplatform") version "2.0.21"
}

kotlin {
    iosArm64()
    iosSimulatorArm64()

    sourceSets {
        commonMain.dependencies {
            implementation("org.jetbrains.kotlinx:kotlinx-coroutines-core:1.9.0")
        }
        iosMain.dependencies {
            implementation("org.jetbrains.kotlinx:kotlinx-coroutines-core:1.9.0")
        }
    }
}

หลังจากตั้งค่าการคอมไพล์แล้ว สามารถเพิ่มโค้ดเฉพาะแพลตฟอร์มได้ Kotlin/Native ให้การเข้าถึงฟังก์ชัน iOS ผ่านแรปเปอร์ Kotlin ตัวอย่างเช่น การรับ UUID ของอุปกรณ์บน iOS จำเป็นต้องเรียก NSUUID จาก Foundation

import platform.Foundation.NSUUID

fun getDeviceId(): String {
    return NSUUID().UUIDString()
}

fun currentTimestampMillis(): Long {
    return (platform.Foundation.NSDate().timeIntervalSince1970 * 1000).toLong()
}

การสร้างเฟรมเวิร์ก iOS

ในการสร้างเฟรมเวิร์ก iOS ใช้งาน Gradle linkDebugFrameworkIosArm64 หรือ linkReleaseFrameworkIosArm64 สำหรับโปรดักชัน หลังจากการคอมไพล์ เฟรมเวิร์กจะอยู่ใน build/bin/iosArm64/debugFramework/ การเชื่อมต่อกับโปรเจกต์ Xcode ทำผ่าน Pods Podfile หรือโดยการเพิ่มเฟรมเวิร์กใน General → Frameworks, Libraries and Embedded Content

// สร้างเฟรมเวิร์กรุ่น release สำหรับ iOS arm64
./gradlew :shared:linkReleaseFrameworkIosArm64

// สร้างเฟรมเวิร์กสากล x86_64 + arm64
./gradlew :shared:linkReleaseFrameworkIosX64 \
    :shared:linkReleaseFrameworkIosArm64

// สร้าง XCFramework สำหรับ App Store
./gradlew :shared:assembleReleaseXCFramework

Kotlin/Native กับ Kotlin/JVM: การเปรียบเทียบ

Kotlin/Native และ Kotlin/JVM แตกต่างกันในด้านสถาปัตยกรรม ประสิทธิภาพ และขอบเขตการใช้งาน Kotlin/JVM คอมไพล์โค้ดเป็นไบต์โค้ดที่ทำงานบน JVM ซึ่งให้การเข้าถึงระบบนิเวศของไลบรารี Java ขนาดใหญ่ แต่ต้องใช้เครื่องเสมือนที่ติดตั้งไว้ Kotlin/Native สร้างไฟล์ปฏิบัติการที่ไม่มีสิ่งอ้างอิงภายนอก แต่มีระบบนิเวศของไลบรารีที่จำกัดกว่า

ประสิทธิภาพเวลาเริ่มทำงานสูงกว่าใน Kotlin/Native เนื่องจากไม่ต้องการการโหลด JVM ตามเกณฑ์วัดของ JetBrains แอปพลิเคชัน Hello World บน Kotlin/Native เริ่มทำงานใน 0.003 วินาที ในขณะที่ Kotlin/JVM ต้องการ 0.5–1 วินาทีในการโหลดเครื่องเสมือน อย่างไรก็ตาม ขนาดไฟล์ปฏิบัติการของ Kotlin/Native อาจใหญ่กว่า 2–3 เท่าเนื่องจากรันไทม์ที่รวมอยู่

การเลือกระหว่าง Kotlin/Native และ Kotlin/JVM ขึ้นอยู่กับแพลตฟอร์มเป้าหมาย หากโปรเจกต์กำหนดเป้าหมาย iOS หรือต้องการการใช้ทรัพยากรขั้นต่ำ Kotlin/Native คือตัวเลือกเดียว สำหรับการพัฒนา Android Kotlin/JVM ยังคงเป็นมาตรฐาน แม้ว่า Kotlin/Native จะใช้สำหรับส่วนประกอบ NDK ที่ต้องการประสิทธิภาพเนทีฟ ในโปรเจกต์หลายแพลตฟอร์ม Kotlin Multiplatform รวมทั้งสองแนวทาง: โค้ดที่ใช้ร่วมกันถูกคอมไพล์ผ่าน Kotlin/Native สำหรับ iOS และผ่าน Kotlin/JVM สำหรับ Android