Menyiapkan Plugin Library Android Gradle untuk KMP

Plugin Gradle com.android.kotlin.multiplatform.library adalah alat yang didukung secara resmi untuk menambahkan target Android ke modul library Kotlin Multiplatform (KMP). Plugin ini menyederhanakan konfigurasi project, meningkatkan performa build, dan menawarkan integrasi yang lebih baik dengan Android Studio.

Penggunaan plugin com.android.library untuk pengembangan KMP bergantung pada API Plugin Android Gradle yang tidak digunakan lagi dan memerlukan keikutsertaan di plugin Android Gradle 9.0 dan yang lebih tinggi (K4 2025). API ini diharapkan akan dihapus di plugin Android Gradle 10.0 (paruh kedua tahun 2026).

Catatan: Tidak ada pengganti langsung untuk mengonfigurasi modul Kotlin Multiplatform menggunakan plugin com.android.application. Untuk melakukan migrasi, ekstrak aplikasi Android Anda ke modul Gradle terpisah.

Untuk menerapkan plugin ini, lihat bagian Menerapkan plugin Android-KMP. Jika Anda perlu bermigrasi dari API lama, lihat Panduan Migrasi.

Perhatian: Sebelum Anda bermigrasi ke plugin baru, perhatikan masalah umum dan fitur yang tidak didukung.

Fitur dan perbedaan utama

Plugin Android-KMP dirancang khusus untuk project KMP dan berbeda dari plugin com.android.library standar dalam beberapa aspek utama:

• Arsitektur varian tunggal: Plugin menggunakan satu varian, menghapus dukungan untuk ragam produk dan jenis build, yang menyederhanakan konfigurasi dan meningkatkan performa build.

• Dioptimalkan untuk KMP: Plugin ini dirancang untuk library KMP, dengan berfokus pada kode Kotlin bersama dan interoperabilitas, serta tidak mendukung build native khusus Android, AIDL, dan RenderScript.

• Pengujian dinonaktifkan secara default: Pengujian unit dan perangkat (instrumentasi) dinonaktifkan secara default untuk meningkatkan kecepatan build. Anda dapat mengaktifkannya jika diperlukan.

• Tidak ada ekstensi Android tingkat atas: Konfigurasi ditangani dengan blok androidLibrary dalam DSL KMP Gradle, sehingga mempertahankan struktur project KMP yang konsisten. Tidak ada pemblokiran ekstensi android tingkat teratas.

• Kompilasi Java keikutsertaan: Kompilasi Java dinonaktifkan secara default. Gunakan withJava() di blok androidLibrary untuk mengaktifkannya. Hal ini akan meningkatkan waktu build saat kompilasi Java tidak diperlukan.

Manfaat plugin library Android-KMP

Plugin Android-KMP memberikan manfaat berikut untuk project KMP:

• Peningkatan performa dan stabilitas build: Didesain untuk kecepatan build yang dioptimalkan dan peningkatan stabilitas dalam project KMP. Fokusnya pada alur kerja KMP berkontribusi pada proses build yang lebih efisien dan andal.

• Integrasi IDE yang ditingkatkan: Memberikan pelengkapan kode, navigasi, proses debug, dan pengalaman developer yang lebih baik secara keseluruhan saat bekerja dengan library Android KMP.

• Konfigurasi project yang disederhanakan: Plugin ini menyederhanakan konfigurasi untuk project KMP dengan menghapus kompleksitas khusus Android seperti varian build. Hal ini menghasilkan file build yang lebih bersih dan mudah dipelihara. Sebelumnya, penggunaan plugin com.android.library di project KMP dapat membuat nama set sumber yang membingungkan, seperti androidAndroidTest. Konvensi penamaan ini kurang intuitif bagi developer yang sudah memahami struktur project KMP standar.

Prasyarat

Untuk menggunakan plugin com.android.kotlin.multiplatform.library, project Anda harus dikonfigurasi dengan versi minimum berikut atau yang lebih tinggi:

• Plugin Android Gradle (AGP): 8.10.0
• Plugin Gradle Kotlin (KGP): 2.0.0

Menerapkan plugin Android-KMP ke modul yang ada

Untuk menerapkan plugin Android-KMP ke modul library KMP yang ada, ikuti langkah-langkah berikut:

1. Mendeklarasikan plugin dalam katalog versi. Buka file TOML katalog versi (biasanya gradle/libs.versions.toml) dan tambahkan bagian definisi plugin:

   # To check the version number of the latest Kotlin release, go to
   # https://kotlinlang.org/docs/releases.html
   
   [versions]
   androidGradlePlugin = "8.13.2"
   kotlin = "KOTLIN_VERSION"
   
   [plugins]
   kotlin-multiplatform = { id = "org.jetbrains.kotlin.multiplatform", version.ref = "kotlin" }
   android-kotlin-multiplatform-library = { id = "com.android.kotlin.multiplatform.library", version.ref = "androidGradlePlugin" }
   

2. Terapkan deklarasi plugin dalam file build root. Buka file build.gradle.kts yang ada di direktori root project Anda. Tambahkan alias plugin ke blok plugins menggunakan apply false. Hal ini membuat alias plugin tersedia untuk semua subproject tanpa menerapkan logika plugin ke project root itu sendiri.

   Kotlin

   // Root build.gradle.kts file
   
   plugins {
      alias(libs.plugins.kotlin.multiplatform) apply false
   
      // Add the following
      alias(libs.plugins.android.kotlin.multiplatform.library) apply false
   }

   Groovy

   // Root build.gradle file
   
   plugins {
      alias(libs.plugins.kotlin.multiplatform) apply false
   
      // Add the following
      alias(libs.plugins.android.kotlin.multiplatform.library) apply false
   }

3. Terapkan plugin dalam file build modul library KMP. Buka file build.gradle.kts di modul library KMP Anda dan terapkan plugin di bagian atas file dalam blok plugins:

   Kotlin

   // Module-specific build.gradle.kts file
   
   plugins {
      alias(libs.plugins.kotlin.multiplatform)
   
      // Add the following
      alias(libs.plugins.android.kotlin.multiplatform.library)
   }

   Groovy

   // Module-specific build.gradle file
   
   plugins {
      alias(libs.plugins.kotlin.multiplatform)
   
      // Add the following
      alias(libs.plugins.android.kotlin.multiplatform.library)
   }

4. Konfigurasi target KMP Android. Konfigurasi blok Multiplatform Kotlin (kotlin) untuk menentukan target Android. Dalam blok kotlin, tentukan target Android menggunakan androidLibrary:

   Kotlin

   kotlin {
      androidLibrary {
          namespace = "com.example.kmpfirstlib"
          compileSdk = 33
          minSdk = 24
   
          withJava() // enable java compilation support
          withHostTestBuilder {}.configure {}
          withDeviceTestBuilder {
              sourceSetTreeName = "test"
          }
   
          compilerOptions.configure {
              jvmTarget.set(
                  org.jetbrains.kotlin.gradle.dsl.JvmTarget.JVM_1_8
              )
          }
      }
   
      sourceSets {
          androidMain {
              dependencies {
                  // Add Android-specific dependencies here
              }
          }
          getByName("androidHostTest") {
              dependencies {
              }
          }
   
          getByName("androidDeviceTest") {
              dependencies {
              }
          }
      }
      // ... other targets (JVM, iOS, etc.) ...
   }

   Groovy

   kotlin {
      androidLibrary {
          namespace = "com.example.kmpfirstlib"
          compileSdk = 33
          minSdk = 24
   
          withJava() // enable java compilation support
          withHostTestBuilder {}.configure {}
          withDeviceTestBuilder {
              it.sourceSetTreeName = "test"
          }
   
          compilerOptions.options.jvmTarget.set(
              org.jetbrains.kotlin.gradle.dsl.JvmTarget.JVM_1_8
          )
      }
   
      sourceSets {
          androidMain {
              dependencies {
              }
          }
          androidHostTest {
              dependencies {
              }
          }
          androidDeviceTest {
              dependencies {
              }
          }
      }
      // ... other targets (JVM, iOS, etc.) ...
   }

5. Terapkan perubahan. Setelah menerapkan plugin dan mengonfigurasi blok kotlin, sinkronkan project Gradle Anda untuk menerapkan perubahan.

Bermigrasi dari plugin lama

Panduan ini membantu Anda bermigrasi dari plugin com.android.library lama ke plugin com.android.kotlin.multiplatform.library.

Catatan: Sejak Plugin Gradle Kotlin versi 2.2.0-Beta2 dan Plugin Gradle Android versi 8.12.0-alpha04, ada blok konfigurasi baru yang disebut android{} bersama dengan androidLibrary{}. Blok androidLibrary{} tidak digunakan lagi dan akan dihapus dalam rilis AGP mendatang, jadi bermigrasilah ke blok android{}

.

1. Mendeklarasikan Dependensi

Tugas umum adalah mendeklarasikan dependensi untuk set sumber khusus Android. Plugin baru ini mengharuskan elemen tersebut ditempatkan secara eksplisit dalam blok sourceSets, tidak seperti blok dependencies umum yang digunakan sebelumnya.

Android-KMP

Plugin baru ini mempromosikan struktur yang lebih bersih dengan mengelompokkan dependensi Android dalam set sumber androidMain. Selain set sumber utama, ada dua set sumber pengujian, yang dibuat sesuai permintaan: androidDeviceTest dan androidHostTest (lihat mengonfigurasi pengujian host dan perangkat untuk mengetahui informasi selengkapnya).

// build.gradle.kts

kotlin {
    androidLibrary {}
    //... other targets

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

        // Dependencies are now scoped to the specific Android source set
        androidMain.dependencies {
            implementation("androidx.appcompat:appcompat:1.7.0")
            implementation("com.google.android.material:material:1.11.0")
        }
    }
}

Set sumber memiliki kompilasi Kotlin yang sesuai bernama main, deviceTest, dan hostTest. Set sumber dan kompilasi dapat dikonfigurasi dalam skrip build seperti berikut:

// build.gradle.kts

kotlin {
    androidLibrary {
        compilations.getByName("deviceTest") {
            kotlinOptions.languageVersion = "2.0"
        }
    }
}

Plugin Lama

Dengan plugin lama, Anda dapat mendeklarasikan dependensi khusus Android di blok dependensi tingkat teratas, yang terkadang membingungkan dalam modul multiplatform.

// build.gradle.kts

kotlin {
  androidTarget()
  //... other targets
}

// Dependencies for all source sets were often mixed in one block
dependencies {
  // Common dependencies
  commonMainImplementation("org.jetbrains.kotlinx:kotlinx-coroutines-core:1.8.0")

  // Android-specific dependencies
  implementation("androidx.appcompat:appcompat:1.7.0")
  implementation("com.google.android.material:material:1.11.0")
}

2. Mengaktifkan Resource Android

Dukungan untuk Resource Android (folder res) tidak diaktifkan secara default di plugin baru untuk mengoptimalkan performa build. Anda harus mengaktifkannya untuk menggunakannya. Perubahan ini membantu memastikan bahwa project yang tidak memerlukan resource khusus Android tidak terbebani oleh overhead build terkait.

Catatan: Hal ini hanya terkait dengan resource khusus Android. Anda tidak perlu mengaktifkannya jika Anda menggunakan Resource multiplatform Compose.

Android-KMP

Anda harus mengaktifkan pemrosesan resource Android secara eksplisit. Resource harus ditempatkan di src/androidMain/res.

// build.gradle.kts

kotlin {
  androidLibrary {
    // ...
    // Enable Android resource processing
    androidResources {
      enable = true
    }
  }
}

// Project Structure
// └── src
//     └── androidMain
//         └── res
//             ├── values
//             │   └── strings.xml
//             └── drawable
//                 └── icon.xml

Plugin Lama

Pemrosesan resource diaktifkan secara default. Anda dapat langsung menambahkan direktori res di src/main dan mulai menambahkan drawable, nilai, dll. XML.

// build.gradle.kts

android {
    namespace = "com.example.library"
    compileSdk = 34
    // No extra configuration was needed to enable resources.
}

// Project Structure
// └── src
//     └── main
//         └── res
//             ├── values
//             │   └── strings.xml
//             └── drawable
//                 └── icon.xml

3. Mengonfigurasi Pengujian Host dan Perangkat

Perubahan signifikan pada plugin baru ini adalah pengujian sisi host (unit) dan sisi perangkat (berinstrumen) Android dinonaktifkan secara default. Anda harus secara eksplisit memilih untuk membuat set sumber dan konfigurasi pengujian, sedangkan plugin lama membuatnya secara otomatis.

Model keikutsertaan ini membantu memverifikasi bahwa project Anda tetap ramping dan hanya menyertakan logika build dan set sumber yang Anda gunakan secara aktif.

Android-KMP

Di plugin baru, Anda dapat mengaktifkan dan mengonfigurasi pengujian di dalam blok kotlin.androidLibrary. Hal ini membuat penyiapan lebih eksplisit dan menghindari pembuatan komponen pengujian yang tidak digunakan. Kumpulan sumber test menjadi androidHostTest, dan androidTest menjadi androidDeviceTest.

// build.gradle.kts

kotlin {
  androidLibrary {
    // ...

    // Opt-in to enable and configure host-side (unit) tests
    withHostTest {
      isIncludeAndroidResources = true
    }

    // Opt-in to enable and configure device-side (instrumented) tests
    withDeviceTest {
      instrumentationRunner = "androidx.test.runner.AndroidJUnitRunner"
      execution = "ANDROIDX_TEST_ORCHESTRATOR"
    }
  }
}

// Project Structure (After Opt-in)
// └── src
//     ├── androidHostTest
//     └── androidDeviceTest

Plugin Lama

Dengan plugin com.android.library, set sumber test dan androidTest dibuat secara default. Anda akan mengonfigurasi perilakunya di dalam blok android, biasanya menggunakan DSL testOptions.

// build.gradle.kts

android {
  defaultConfig {
    // Runner was configured in defaultConfig
    testInstrumentationRunner = "androidx.test.runner.AndroidJUnitRunner"
  }

  testOptions {
    // Configure unit tests (for the 'test' source set)
    unitTests.isIncludeAndroidResources = true

    // Configure device tests (for the 'androidTest' source set)
    execution = "ANDROIDX_TEST_ORCHESTRATOR"
  }
}

// Project Structure (Defaults)
// └── src
//     ├── test
//     └── androidTest

4. Mengaktifkan kompilasi sumber Java

Jika library KMP Anda perlu mengompilasi sumber Java untuk target Android-nya, Anda harus mengaktifkan fungsi ini secara eksplisit dengan plugin baru. Perhatikan bahwa hal ini mengaktifkan kompilasi untuk file Java yang berada langsung di dalam project Anda, bukan untuk dependensinya. Metode untuk menyetel versi target JVM compiler Java dan Kotlin juga berubah.

Android-KMP

Anda harus memilih untuk mengaktifkan kompilasi Java dengan memanggil withJava(). Target JVM kini dikonfigurasi langsung di dalam blok kotlin { androidLibrary {} } untuk penyiapan yang lebih terpadu. Setelan jvmTarget di sini berlaku untuk kompilasi Kotlin dan Java untuk target Android.

// build.gradle.kts

kotlin {
  androidLibrary {
    //  Opt-in to enable Java source compilation
    withJava()
    // Configure the JVM target for both Kotlin and Java sources
    compilerOptions {
      jvmTarget.set(org.jetbrains.kotlin.gradle.dsl.JvmTarget.JVM_1_8)
    }
  }
  // ...
}

// Project Structure:
// └── src
//     └── androidMain
//         ├── kotlin
//         │   └── com/example/MyKotlinClass.kt
//         └── java
//             └── com.example/MyJavaClass.java

Plugin Lama

Kompilasi Java diaktifkan secara default. Target JVM untuk sumber Java dan Kotlin ditetapkan di blok Android menggunakan compileOptions.

// build.gradle.kts

android {
  // ...
  compileOptions {
    sourceCompatibility = JavaVersion.VERSION_1_8
    targetCompatibility = JavaVersion.VERSION_1_8
  }
}

kotlin {
  androidTarget {
    compilations.all {
      kotlinOptions.jvmTarget = "1.8"
    }
  }
}

5. Berinteraksi dengan varian build menggunakan androidComponents

Ekstensi androidComponents masih tersedia untuk berinteraksi dengan artefak build secara terprogram. Meskipun sebagian besar Variant API tetap sama, antarmuka AndroidKotlinMultiplatformVariant baru lebih terbatas karena plugin hanya menghasilkan satu varian.

Akibatnya, properti yang terkait dengan jenis build dan ragam produk tidak lagi tersedia di objek varian.

Android-KMP

Blok onVariants kini melakukan iterasi pada satu varian. Anda masih dapat mengakses properti umum seperti name dan artifacts, tetapi tidak yang khusus untuk jenis build.

// build.gradle.kts

androidComponents {
  onVariants { variant ->
      val artifacts = variant.artifacts
  }
}

Plugin Lama

Dengan beberapa varian, Anda dapat mengakses properti khusus jenis build untuk mengonfigurasi tugas.

// build.gradle.kts

androidComponents {
  onVariants(selector().withBuildType("release")) { variant ->
    // ...
  }
}

6. Memilih varian dependensi library Android

Library KMP Anda menghasilkan satu varian untuk Android. Namun, Anda mungkin bergantung pada library Android standar (com.android.library) yang memiliki beberapa varian (misalnya, free/paid ragam produk). Mengontrol cara project Anda memilih varian dari dependensi tersebut adalah persyaratan umum.

Android-KMP

Plugin baru memusatkan dan memperjelas logika ini dalam blok kotlin.androidLibrary.localDependencySelection. Hal ini membuat varian dependensi eksternal yang akan dipilih untuk library KMP varian tunggal Anda menjadi jauh lebih jelas.

// build.gradle.kts
kotlin {
  androidLibrary {
    localDependencySelection {
      // For dependencies with multiple build types, select 'debug' first, and 'release' in case 'debug' is missing
      selectBuildTypeFrom.set(listOf("debug", "release"))

      // For dependencies with a 'type' flavor dimension...
      productFlavorDimension("type") {
        // ...select the 'typeone' flavor.
        selectFrom.set(listOf("typeone"))
      }
    }
  }
}

Plugin Lama

Anda mengonfigurasi strategi pemilihan dependensi di dalam blok buildTypes and productFlavors. Hal ini sering kali melibatkan penggunaan missingDimensionStrategy untuk memberikan ragam default untuk dimensi yang tidak dimiliki library Anda, atau matchingFallbacks dalam ragam tertentu untuk menentukan urutan penelusuran.

Lihat Mengatasi Error Pencocokan untuk mengetahui informasi yang lebih mendetail tentang penggunaan API.

7. Dependensi pratinjau pembuatan video

Biasanya, kita ingin memiliki library tertentu yang dicakup ke lingkungan pengembangan lokal untuk mencegah alat internal bocor ke artefak yang dipublikasikan akhir. Hal ini menjadi tantangan dengan plugin Android KMP baru karena plugin tersebut menghapus arsitektur jenis build yang digunakan untuk memisahkan dependensi pengembangan dari kode rilis.

Android-KMP

Untuk menambahkan dependensi hanya untuk pengembangan dan pengujian lokal, tambahkan dependensi langsung ke konfigurasi classpath runtime (di blok dependencies tingkat teratas) kompilasi Android utama. Hal ini membantu memastikan dependensi tersedia saat runtime (misalnya untuk alat seperti Pratinjau Compose), tetapi bukan bagian dari classpath kompilasi atau API yang dipublikasikan dari library Anda.

Pratinjau: Solusi ini hanya tersedia di plugin Android Gradle versi 9.0.0-beta01 dan yang lebih tinggi.

// build.gradle.kts
dependencies {
  "androidRuntimeClasspath"(libs.androidx.compose.ui.tooling)
}

Plugin Lama

Project Multiplatform Kotlin yang menggunakan plugin com.android.library untuk target Android harus menggunakan konfigurasi debugImplementation, yang mencakup dependensi ke jenis build debug dan mencegahnya disertakan dalam varian rilis library yang digunakan oleh konsumen.

// build.gradle.kts
dependencies {
  debugImplementation(libs.androidx.compose.ui.tooling)
}

8. Mengonfigurasi target JVM untuk target Android KMP

Plugin Android KMP menetapkan target JVM menggunakan androidLibrary.compilerOptions.jvmTarget, yang berlaku untuk Java dan Kotlin, sehingga menyederhanakan konfigurasi dibandingkan dengan blok compileOptions dan kotlinOptions terpisah dalam project Android murni.

Android-KMP

Saat mengerjakan project Multiplatform Kotlin (KMP) yang menyertakan target Android, Anda memiliki beberapa cara untuk mengonfigurasi versi target JVM untuk compiler Kotlin dan Java. Memahami cakupan dan hierarki konfigurasi ini adalah kunci untuk mengelola kompatibilitas bytecode project Anda.

Berikut tiga cara utama untuk menetapkan target JVM, yang diurutkan dari prioritas terendah hingga tertinggi. Nilai target JVM yang memiliki prioritas lebih tinggi berlaku untuk subset target yang dikonfigurasi dan menggantikan nilai yang memiliki prioritas lebih rendah, yang berarti Anda dapat menetapkan versi JVM yang berbeda untuk target dan kompilasi yang berbeda dalam target di project Anda.

Menggunakan toolchain kotlin (prioritas terendah)

Cara paling umum untuk menyetel target JVM adalah dengan menentukan toolchain dalam blok kotlin pada file build.gradle.kts Anda. Pendekatan ini menetapkan target untuk tugas kompilasi Kotlin dan Java di semua target berbasis JVM dalam project Anda, termasuk Android.

// build.gradle.kts
kotlin {
    jvmToolchain(21)
}

Konfigurasi ini membuat kotlinc dan javac menargetkan JVM 21. Cara ini adalah cara yang bagus untuk menetapkan baseline yang konsisten untuk seluruh project Anda.

Menggunakan opsi compiler tingkat target Android (prioritas sedang)

Anda dapat menentukan target JVM secara khusus untuk target KMP Android dalam blok android. Setelan ini menggantikan konfigurasi jvmToolchain di seluruh project dan berlaku untuk semua kompilasi Android.

// build.gradle.kts
kotlin {
    androidLibrary {
        compilerOptions {
            jvmTarget.set(JvmTarget.JVM_11)
        }
    }
}

Dalam hal ini, meskipun jvmToolchain ditetapkan ke versi yang berbeda, kode Kotlin dan Java target Android akan dikompilasi untuk menargetkan JVM 11.

Menggunakan opsi compiler tingkat kompilasi (prioritas tertinggi)

Untuk kontrol yang paling terperinci, Anda dapat mengonfigurasi opsi compiler berdasarkan per-kompilasi (misalnya, hanya di androidMain atau androidHostTest). Tindakan ini berguna jika kompilasi tertentu perlu menargetkan versi JVM yang berbeda. Setelan ini menggantikan toolchain Kotlin dan opsi tingkat target Android.

// build.gradle.kts
kotlin {
    androidLibrary {
        compilations.all {
            compileTaskProvider.configure {
                compilerOptions.jvmTarget.set(JvmTarget.JVM_11)
            }
        }
    }
}

Konfigurasi ini membantu memastikan bahwa semua kompilasi dalam target Android menggunakan JVM 11, sehingga memberikan kontrol yang terperinci.

Plugin Lama

Dalam project KMP yang menggunakan plugin library Android standar (com.android.library), konfigurasi sedikit berbeda dari saat Anda menggunakan plugin Android KMP (tetapi secara konseptual serupa).

Menggunakan toolchain kotlin

Metode kotlin.jvmToolchain() berfungsi secara identik, menetapkan sourceCompatibility dan targetCompatibility untuk Java serta jvmTarget untuk Kotlin. Sebaiknya gunakan pendekatan ini.

// build.gradle.kts
kotlin {
    jvmToolchain(21)
}

compileOptions dan kotlinOptions

Jika Anda tidak menggunakan toolchain Kotlin, Anda harus mengonfigurasi target JVM menggunakan blok terpisah untuk Java dan Kotlin.

// build.gradle.kts
android {
    compileOptions {
        sourceCompatibility = JavaVersion.VERSION_11
        targetCompatibility = JavaVersion.VERSION_11
    }

    kotlinOptions {
        jvmTarget = "11"
    }
}

Referensi Plugin API

Plugin baru memiliki platform API yang berbeda dengan com.android.library. Untuk informasi mendetail tentang DSL dan antarmuka baru, lihat referensi API:

• KotlinMultiplatformAndroidLibraryExtension
• KotlinMultiplatformAndroidLibraryTarget
• KotlinMultiplatformAndroidDeviceTest
• KotlinMultiplatformAndroidHostTest
• KotlinMultiplatformAndroidVariant

Masalah umum di plugin library Android-KMP

Berikut adalah masalah umum yang mungkin terjadi saat Anda menerapkan plugin com.android.kotlin.multiplatform.library baru:

• Pratinjau Compose gagal saat menggunakan plugin android-KMP baru

  • Diperbaiki di Android Studio Otter 2 Feature Drop | 2025.2.2 Canary 3 dan Android Gradle Plugin 9.0.0-alpha13

• NullPointerException di pratinjau Multiplatform Compose dengan plugin com.android.kotlin.multiplatform.library

  • Diperbaiki di Android Studio Otter 2 Feature Drop | 2025.2.2 Canary 3 dan Android Gradle Plugin 9.0.0-alpha13

• KMP menyimpan penyelesaian dependensi kompilasi umum di Cache konfigurasi yang menyebabkan error saat melakukan deserialisasi (khusus Android)

  • Diperbaiki di Kotlin Gradle Plugin 2.3.0-Beta2

• Mendukung instrumented sourceSetTree untuk target androidLibrary

  • Diperbaiki di Android Studio Otter 2 Feature Drop | 2025.2.2 Canary 3 dan Android Gradle Plugin 9.0.0-alpha13

Fitur yang tidak didukung

Jika dibandingkan dengan integrasi KMP dengan plugin com.android.library, fitur berikut tidak ada di plugin com.android.kotlin.multiplatform.library:

• Data binding dan View binding

  Fitur ini adalah fitur framework UI khusus Android yang terikat erat dengan sistem View Android dan tata letak XML. Di plugin library Android-KMP baru, kami merekomendasikan agar Anda menangani UI menggunakan framework multiplatform seperti Compose Multiplatform. Data binding dan View binding dianggap sebagai detail implementasi aplikasi Android akhir, bukan library yang dapat dibagikan.

• Dukungan build native

  Plugin baru ini berfokus untuk menghasilkan AAR standar untuk target Android. Integrasi kode native di Kotlin Multiplatform ditangani langsung oleh target native KMP sendiri (seperti androidNativeArm64 dan androidNativeX86) dan kemampuan C-interopnya. Jika perlu menyertakan kode C/C++ native, Anda harus menentukannya sebagai bagian dari set sumber umum atau native dan mengonfigurasi C-interop dalam blok kotlin, bukan menggunakan mekanisme externalNativeBuild khusus Android.

  Atau, jika Anda memerlukan dukungan build native, sebaiknya buat com.android.library mandiri terpisah tempat Anda dapat mengintegrasikan kode native dan menggunakan library mandiri dari project library Multiplatform Kotlin.

• Class BuildConfig

  Fitur BuildConfig paling berguna dalam lingkungan multi-varian. Karena plugin library Multiplatform Kotlin yang baru tidak bergantung pada varian dan tidak mendukung jenis build dan varian produk, fitur ini tidak diterapkan. Sebagai alternatif, sebaiknya gunakan plugin BuildKonfig atau solusi komunitas serupa untuk membuat metadata bagi semua target.