KMP के लिए Android Gradle लाइब्रेरी प्लग इन सेट अप करना

com.android.kotlin.multiplatform.library Gradle प्लगिन, Kotlin Multiplatform (केएमपी) लाइब्रेरी मॉड्यूल में Android टारगेट जोड़ने के लिए, आधिकारिक तौर पर सहायता पाने वाला टूल है. इससे प्रोजेक्ट को कॉन्फ़िगर करना आसान हो जाता है, बिल्ड की परफ़ॉर्मेंस बेहतर होती है, और Android Studio के साथ बेहतर इंटिग्रेशन मिलता है.

केएमपी डेवलपमेंट के लिए com.android.library प्लगिन का इस्तेमाल, Android Gradle प्लगिन के उन एपीआई पर निर्भर करता है जो अब काम नहीं करते. साथ ही, Android Gradle प्लगिन 9.0 और इसके बाद वाले वर्शन (साल 2025 की चौथी तिमाही) में, इनके लिए ऑप्ट-इन करना ज़रूरी है. उम्मीद है कि इन एपीआई को Android Gradle प्लगिन 10.0 (साल 2026 की दूसरी छमाही) में हटा दिया जाएगा.

इस प्लगिन को लागू करने के लिए, Android-KMP प्लगिन लागू करना सेक्शन देखें. अगर आपको लेगसी एपीआई से माइग्रेट करना है, तो माइग्रेशन गाइड देखें.

AGP 9.0 और इसके बाद वाले वर्शन पर माइग्रेट करने में मदद पाने के लिए, एजेंट स्किल का इस्तेमाल किया जा सकता है. इसे JetBrains ने केएमपी ऐप्लिकेशन के लिए बनाया है. Android Studio में स्किल इस्तेमाल करने के बारे में ज़्यादा जानने के लिए, स्किल की मदद से एजेंट मोड को बढ़ाना लेख पढ़ें. ध्यान रखें कि एआई से मिले नतीजे पूरी तरह से अनुमान के मुताबिक नहीं होते.

मुख्य सुविधाएं और अंतर

Android-KMP प्लगिन को खास तौर पर केएमपी प्रोजेक्ट के लिए बनाया गया है. यह कई अहम पहलुओं में, स्टैंडर्ड com.android.library प्लगिन से अलग है:

• सिंगल वैरिएंट आर्किटेक्चर: यह प्लगिन, एक ही वैरिएंट का इस्तेमाल करता है. इससे ऐप्लिकेशन टाइप और बिल्ड के तरीके के लिए सहायता हट जाती है. इससे कॉन्फ़िगरेशन आसान हो जाता है और बिल्ड की परफ़ॉर्मेंस बेहतर हो जाती है.

• KMP के लिए ऑप्टिमाइज़ किया गया: इस प्लगिन को KMP लाइब्रेरी के लिए डिज़ाइन किया गया है. इसमें शेयर किए गए Kotlin कोड और इंटरऑपरेबिलिटी पर फ़ोकस किया गया है. साथ ही, इसमें Android के लिए खास तौर पर बनाए गए नेटिव बिल्ड, एआईडीएल, और RenderScript के लिए सहायता शामिल नहीं है.

• डिफ़ॉल्ट रूप से बंद टेस्ट: बिल्ड की स्पीड को बेहतर बनाने के लिए, यूनिट और डिवाइस (इंस्ट्रुमेंटेशन), दोनों टेस्ट डिफ़ॉल्ट रूप से बंद होते हैं. अगर ज़रूरी हो, तो इन्हें चालू किया जा सकता है.

• कोई टॉप-लेवल Android एक्सटेंशन नहीं: कॉन्फ़िगरेशन को Gradle KMP DSL में मौजूद android ब्लॉक की मदद से मैनेज किया जाता है. इससे केएमपी प्रोजेक्ट का स्ट्रक्चर एक जैसा बना रहता है. कोई टॉप-लेवल android एक्सटेंशन ब्लॉक नहीं है.

• Java कंपाइलेशन के लिए ऑप्ट-इन करना: Java कंपाइलेशन डिफ़ॉल्ट रूप से बंद होता है. इसे चालू करने के लिए, android ब्लॉक में withJava() का इस्तेमाल करें. इससे Java कंपाइलेशन की ज़रूरत न होने पर, बिल्ड के समय में सुधार होता है.

Android-KMP लाइब्रेरी प्लगिन के फ़ायदे

Android-KMP प्लगिन से, केएमपी प्रोजेक्ट के लिए ये फ़ायदे मिलते हैं:

• बिल्ड की परफ़ॉर्मेंस और स्थिरता बेहतर होना: इसे केएमपी प्रोजेक्ट में, बिल्ड की स्पीड को ऑप्टिमाइज़ करने और स्थिरता को बेहतर बनाने के लिए डिज़ाइन किया गया है. केएमपी वर्कफ़्लो पर फ़ोकस करने से, बिल्ड की प्रोसेस ज़्यादा असरदार और भरोसेमंद बनती है.

• आईडीई इंटिग्रेशन बेहतर होना: केएमपी Android लाइब्रेरी के साथ काम करते समय, यह कोड पूरा करने, नेविगेशन, डीबग करने, और डेवलपर के अनुभव को बेहतर बनाता है.

• प्रोजेक्ट को आसानी से कॉन्फ़िगर करना: यह प्लगिन, KMP प्रोजेक्ट को आसानी से कॉन्फ़िगर करने में मदद करता है. इसके लिए, यह Android से जुड़ी जटिलताओं को दूर करता है. जैसे, बिल्ड वैरिएंट. इससे, बिल्ड फ़ाइलें ज़्यादा व्यवस्थित और रखरखाव में आसान हो जाती हैं. पहले, KMP प्रोजेक्ट में com.android.library प्लगिन का इस्तेमाल करने पर, source set के नाम गलत हो सकते थे. जैसे, androidAndroidTest. नाम रखने का यह तरीका, स्टैंडर्ड KMP प्रोजेक्ट स्ट्रक्चर के बारे में जानने वाले डेवलपर के लिए कम सहज था.

इस्तेमाल न की जा सकने वाली सुविधाओं के लिए वर्कअराउंड

com.android.library प्लगिन के साथ केएमपी इंटिग्रेशन की तुलना में, com.android.kotlin.multiplatform.library प्लगिन में कुछ सुविधाएं मौजूद नहीं हैं. इस्तेमाल न की जा सकने वाली सुविधाओं के लिए यहां वर्कअराउंड दिए गए हैं:

• बिल्ड वैरिएंट

  ऐप्लिकेशन टाइप और प्रॉडक्ट फ़्लेवर इस्तेमाल नहीं किए जा सकते. ऐसा इसलिए है, क्योंकि नया प्लगिन, सिंगल वैरिएंट आर्किटेक्चर का इस्तेमाल करता है. इससे कॉन्फ़िगरेशन आसान हो जाता है और बिल्ड की परफ़ॉर्मेंस बेहतर हो जाती है.

  अगर आपको बिल्ड वैरिएंट की ज़रूरत है, तो हमारा सुझाव है कि com.android.library प्लगिन का इस्तेमाल करके, Android लाइब्रेरी का कोई अलग स्टैंडअलोन मॉड्यूल बनाएं. इसके बाद, उस मॉड्यूल में ऐप्लिकेशन टाइप और प्रॉडक्ट फ़्लेवर कॉन्फ़िगर करें. फिर, इसे अपनी Kotlin Multiplatform लाइब्रेरी के androidMain source set से, स्टैंडर्ड प्रोजेक्ट डिपेंडेंसी के तौर पर इस्तेमाल करें. ज़्यादा जानकारी के लिए, Android लाइब्रेरी बनाना और बिल्ड वैरिएंट कॉन्फ़िगर करना लेख पढ़ें.

• डेटा बाइंडिंग और व्यू बाइंडिंग

  ये Android के लिए खास तौर पर बनाए गए यूज़र इंटरफ़ेस (यूआई) फ़्रेमवर्क की सुविधाएं हैं. ये Android View सिस्टम और एक्सएमएल लेआउट से जुड़ी हैं. Android-KMP लाइब्रेरी के नए प्लगिन में, हमारा सुझाव है कि यूज़र इंटरफ़ेस (यूआई) को मैनेज करने के लिए, Compose Multiplatform जैसे मल्टीप्लैटफ़ॉर्म फ़्रेमवर्क का इस्तेमाल करें. डेटा बाइंडिंग और व्यू बाइंडिंग को, शेयर की जा सकने वाली लाइब्रेरी नहीं, बल्कि Android ऐप्लिकेशन की लागू करने से जुड़ी जानकारी माना जाता है.

• नेटिव बिल्ड की सुविधा

  नया प्लगिन, Android टारगेट के लिए स्टैंडर्ड एएआर बनाने पर फ़ोकस करता है. Kotlin Multiplatform में नेटिव कोड इंटिग्रेशन को, केएमपी के अपने नेटिव टारगेट (जैसे, androidNativeArm64 और androidNativeX86) और इसकी सी-इंटरऑप क्षमताओं से सीधे तौर पर मैनेज किया जाता है. अगर आपको नेटिव C/C++ कोड शामिल करना है, तो इसे किसी सामान्य या नेटिव source set के हिस्से के तौर पर तय करें. साथ ही, Android के लिए खास तौर पर बनाए गए externalNativeBuild मैकेनिज़्म का इस्तेमाल करने के बजाय, kotlin ब्लॉक में सी-इंटरऑप को कॉन्फ़िगर करें.

  इसके अलावा, अगर आपको externalNativeBuild के ज़रिए नेटिव बिल्ड की सुविधा चाहिए, तो हमारा सुझाव है कि com.android.library का कोई अलग स्टैंडअलोन मॉड्यूल बनाएं. इसमें नेटिव कोड इंटिग्रेट किया जा सकता है. साथ ही, उस स्टैंडअलोन लाइब्रेरी को अपने Kotlin Multiplatform लाइब्रेरी प्रोजेक्ट के androidMain source set से इस्तेमाल किया जा सकता है. ज़्यादा जानकारी के लिए, Android लाइब्रेरी बनाना और अपने प्रोजेक्ट में C और C++ कोड जोड़ना लेख पढ़ें.

• BuildConfig क्लास

  BuildConfig सुविधा, मल्टी-वैरिएंट एनवायरमेंट में सबसे ज़्यादा काम की होती है. Kotlin Multiplatform लाइब्रेरी का नया प्लगिन, वैरिएंट-अग्नोस्टिक है. साथ ही, इसमें ऐप्लिकेशन टाइप और प्रॉडक्ट फ़्लेवर की सुविधा नहीं है. इसलिए, यह सुविधा लागू नहीं की गई है. इसके विकल्प के तौर पर, हमारा सुझाव है कि सभी टारगेट के लिए मेटाडेटा जनरेट करने के लिए, BuildKonfig प्लगिन या कम्यूनिटी के इसी तरह के समाधानों का इस्तेमाल करें.

ज़रूरी शर्तें

com.android.kotlin.multiplatform.library प्लगिन का इस्तेमाल करने के लिए, आपके प्रोजेक्ट को इन ज़रूरी वर्शन या इसके बाद वाले वर्शन के साथ कॉन्फ़िगर किया जाना चाहिए:

• Android Gradle प्लगिन (एजीपी): 8.10.0
• Kotlin Gradle प्लगिन (केजीपी): 2.0.0

किसी मौजूदा मॉड्यूल पर Android-KMP प्लगिन लागू करना

किसी मौजूदा केएमपी लाइब्रेरी मॉड्यूल पर Android-KMP प्लगिन लागू करने के लिए, यह तरीका अपनाएं:

1. वर्शन कैटलॉग में प्लगिन के बारे में जानकारी देना. वर्शन कैटलॉग की TOML फ़ाइल खोलें. यह फ़ाइल आम तौर पर gradle/libs.versions.toml होती है. इसके बाद, प्लगिन डेफ़िनिशन सेक्शन जोड़ें:

   # To check the version number of the latest Kotlin release, go to
   # https://kotlinlang.org/docs/releases.html
   
   [versions]
   androidGradlePlugin = "9.2.0"
   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. रूट बिल्ड फ़ाइल में प्लगिन के बारे में जानकारी दें. अपने प्रोजेक्ट की रूट डायरेक्ट्री में मौजूद build.gradle.kts फ़ाइल खोलें. apply false का इस्तेमाल करके, प्लगिन के अन्य नाम plugins ब्लॉक में जोड़ें. इससे प्लगिन के दूसरे नाम, सभी सबप्रोजेक्ट के लिए उपलब्ध हो जाते हैं. इसके लिए, प्लगिन के लॉजिक को रूट प्रोजेक्ट पर लागू करने की ज़रूरत नहीं होती.

   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. केएमपी लाइब्रेरी मॉड्यूल की बिल्ड फ़ाइल में प्लगिन लागू करना. अपने केएमपी लाइब्रेरी मॉड्यूल में build.gradle.kts फ़ाइल खोलें. इसके बाद, 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. Android KMP टारगेट कॉन्फ़िगर करना. Android टारगेट तय करने के लिए, Kotlin Multiplatform ब्लॉक (kotlin) को कॉन्फ़िगर करें. kotlin ब्लॉक में, android का इस्तेमाल करके Android टारगेट तय करें:

   Kotlin

   kotlin {
      android {
          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 {
      android {
          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. बदलाव लागू करें. प्लगिन लागू करने और kotlin ब्लॉक को कॉन्फ़िगर करने के बाद, बदलाव लागू करने के लिए अपने Gradle प्रोजेक्ट को सिंक करें.

लेगसी प्लगिन से माइग्रेट करना

इस गाइड की मदद से, लेगसी com.android.library प्लगिन से com.android.kotlin.multiplatform.library प्लगिन पर माइग्रेट किया जा सकता है.

1. सोर्स को दूसरी जगह ले जाना

लेगसी प्लगिन की मदद से, src/main, src/test, और src/androidTest source set के साथ-साथ, src/androidMain, src/androidHostTest, और src/androidDeviceTest का इस्तेमाल किया जा सकता था. नया प्लगिन सिर्फ़ बाद वाली सोर्स डायरेक्ट्री का इस्तेमाल करता है. इसलिए, आपको सोर्स को src/main से src/androidMain, src/test से src/androidHostTest, और src/androidTest से src/androidDeviceTest में ले जाना होगा.

2. डिपेंडेंसी का एलान करना

Android के लिए खास तौर पर बनाए गए source set के लिए, डिपेंडेंसी का एलान करना एक सामान्य टास्क है. नए प्लगिन के लिए, इन्हें साफ़ तौर पर sourceSets ब्लॉक में रखना ज़रूरी है. जबकि पहले, सामान्य dependencies ब्लॉक का इस्तेमाल किया जाता था.

// build.gradle.kts

kotlin {
    android {}
    //... 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")
        }
    }
}

// build.gradle.kts

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

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

3. Android के रिसॉर्स चालू करना

बिल्ड की परफ़ॉर्मेंस को ऑप्टिमाइज़ करने के लिए, नए प्लगिन में Android के रिसॉर्स (res फ़ोल्डर) की सुविधा डिफ़ॉल्ट रूप से चालू नहीं होती. इनका इस्तेमाल करने के लिए, आपको ऑप्ट-इन करना होगा. इस बदलाव से यह पक्का करने में मदद मिलती है कि जिन प्रोजेक्ट के लिए Android के खास रिसॉर्स की ज़रूरत नहीं है उन पर, बिल्ड के ओवरहेड का बोझ न पड़े.

// build.gradle.kts

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

// Project Structure
// └── src
//     └── androidMain
//         └── res
//             ├── values
//             │   └── strings.xml
//             └── drawable
//                 └── icon.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

4. होस्ट और डिवाइस टेस्ट कॉन्फ़िगर करना

नए प्लगिन में एक अहम बदलाव यह है कि Android के होस्ट-साइड (यूनिट) और डिवाइस-साइड (इंस्ट्रुमेंटेड) टेस्ट डिफ़ॉल्ट रूप से बंद होते हैं. टेस्ट के लिए source set और कॉन्फ़िगरेशन बनाने के लिए, आपको साफ़ तौर पर ऑप्ट-इन करना होगा. जबकि पुराने प्लगिन में, ये अपने-आप बन जाते थे.

ऑप्ट-इन मॉडल से यह पुष्टि करने में मदद मिलती है कि आपका प्रोजेक्ट व्यवस्थित रहे. साथ ही, इसमें सिर्फ़ वे बिल्ड लॉजिक और source set शामिल हों जिनका इस्तेमाल आप लगातार करते हैं.

// build.gradle.kts

kotlin {
  android {
    // ...

    // 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 = "HOST"
    }
  }
}

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

// 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 = "HOST"
  }
}

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

5. Java सोर्स कंपाइलेशन चालू करना

अगर आपकी केएमपी लाइब्रेरी को Android टारगेट के लिए Java सोर्स कंपाइल करने की ज़रूरत है, तो नए प्लगिन के साथ आपको इस सुविधा को साफ़ तौर पर चालू करना होगा. ध्यान दें कि इससे आपके प्रोजेक्ट में सीधे तौर पर मौजूद Java फ़ाइलों के लिए कंपाइलेशन चालू होता है. इसकी डिपेंडेंसी के लिए नहीं. Java और Kotlin कंपाइलर के जेवीएम टारगेट वर्शन को सेट करने का तरीका भी बदल जाता है.

// build.gradle.kts

kotlin {
  android {
    //  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

// build.gradle.kts

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

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

6. androidComponents का इस्तेमाल करके, बिल्ड वैरिएंट के साथ इंटरैक्ट करना

androidComponents एक्सटेंशन, बिल्ड आर्टफ़ैक्ट के साथ प्रोग्राम के ज़रिए इंटरैक्ट करने के लिए अब भी उपलब्ध है. Variant एपीआई का ज़्यादातर हिस्सा पहले जैसा ही है, हालांकि, AndroidKotlinMultiplatformVariant का नया इंटरफ़ेस ज़्यादा सीमित है, क्योंकि प्लगिन सिर्फ़ एक वैरिएंट बनाता है.

इसलिए, वैरिएंट ऑब्जेक्ट पर, ऐप्लिकेशन टाइप और प्रॉडक्ट फ़्लेवर से जुड़ी प्रॉपर्टी अब उपलब्ध नहीं हैं.

// build.gradle.kts

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

// build.gradle.kts

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

7. Android लाइब्रेरी डिपेंडेंसी के वैरिएंट चुनना

आपकी केएमपी लाइब्रेरी, Android के लिए एक वैरिएंट बनाती है. हालांकि, ऐसा हो सकता है कि आपकी लाइब्रेरी, स्टैंडर्ड Android लाइब्रेरी (com.android.library) पर निर्भर हो.इसमें कई वैरिएंट हो सकते हैं. जैसे, free/paid प्रॉडक्ट फ़्लेवर. यह एक सामान्य ज़रूरत है कि आपका प्रोजेक्ट, उस डिपेंडेंसी से कोई वैरिएंट कैसे चुनता है, इसे कंट्रोल किया जाए.

// build.gradle.kts
kotlin {
  android {
    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"))
      }
    }
  }
}

8. Compose की झलक देखने की सुविधा के लिए डिपेंडेंसी

आम तौर पर, हम अपने लोकल डेवलपमेंट एनवायरमेंट के लिए खास लाइब्रेरी को स्कोप करना चाहते हैं, ताकि इंटरनल टूल, पब्लिश किए गए फ़ाइनल आर्टफ़ैक्ट में लीक न हों. केएमपी Android के नए प्लगिन के साथ यह एक चुनौती बन जाती है, क्योंकि यह रिलीज़ कोड से डेवलपमेंट डिपेंडेंसी को अलग करने के लिए इस्तेमाल किए जाने वाले ऐप्लिकेशन टाइप आर्किटेक्चर को हटा देता है.

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

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

9. केएमपी Android टारगेट के लिए जेवीएम टारगेट कॉन्फ़िगर करना

केएमपी Android प्लगिन, android.compilerOptions.jvmTarget का इस्तेमाल करके जेवीएम टारगेट सेट करता है. यह Java और Kotlin, दोनों पर लागू होता है. इससे, सिर्फ़ Android प्रोजेक्ट में अलग-अलग compileOptions और kotlinOptions ब्लॉक की तुलना में, कॉन्फ़िगरेशन आसान हो जाता है.

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

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

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

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

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

    kotlinOptions {
        jvmTarget = "11"
    }
}

10. इस्तेमाल करने वाले लोगों के लिए, कीप रूल पब्लिश करना

अगर आपकी केएमपी लाइब्रेरी को इस्तेमाल करने वाले लोगों के लिए, कीप रूल (जैसे, R8 के लिए ProGuard रूल) शिप करने की ज़रूरत है, तो नए प्लगिन में आपको पब्लिश करने की सुविधा को साफ़ तौर पर चालू करना होगा. पहले, कीप रूल तय किए जाने पर, वे डिफ़ॉल्ट रूप से पब्लिश किए जाते थे.

// build.gradle.kts
kotlin {
  android {
    optimization {
      consumerKeepRules.apply {
        publish = true
        file("consumer-proguard-rules.pro")
      }
    }
  }
}

// build.gradle.kts
android {
  defaultConfig {
    consumerProguardFiles("consumer-proguard-rules.pro")
  }
}

11. Maven पर अपनी लाइब्रेरी पब्लिश करना

अगर आपको अपनी केएमपी लाइब्रेरी को Maven पर पब्लिश करना है, ताकि दूसरे प्रोजेक्ट इसका इस्तेमाल कर सकें, तो यह प्रोसेस इस बात पर निर्भर करती है कि आप Android-KMP का नया प्लगिन इस्तेमाल कर रहे हैं या लेगसी प्लगिन.

प्लगिन एपीआई का संदर्भ

नए प्लगिन का एपीआई, com.android.library से अलग है. नए डीएसएल और इंटरफ़ेस के बारे में ज़्यादा जानकारी के लिए, एपीआई के संदर्भ देखें:

• KotlinMultiplatformAndroidLibraryExtension
• KotlinMultiplatformAndroidLibraryTarget
• KotlinMultiplatformAndroidDeviceTest
• KotlinMultiplatformAndroidHostTest
• KotlinMultiplatformAndroidVariant

Android-KMP लाइब्रेरी प्लगिन में जानी-मानी समस्याएं

com.android.kotlin.multiplatform.library का नया प्लगिन लागू करने पर, ये समस्याएं आ सकती हैं:

• Android-KMP के नए प्लगिन का इस्तेमाल करने पर, Compose की झलक देखने की सुविधा काम नहीं करती

  • Android Studio Otter 2 Feature Drop | 2025.2.2 Canary 3 और Android Gradle Plugin 9.0.0-alpha13 में ठीक की गई

• com.android.kotlin.multiplatform.library प्लगिन के साथ, Compose Multiplatform की झलक देखने की सुविधा में NullPointerException

  • Android Studio Otter 2 Feature Drop | 2025.2.2 Canary 3 और Android Gradle Plugin 9.0.0-alpha13 में ठीक की गई

• केएमपी, सामान्य कंपाइलेशन डिपेंडेंसी रिज़ॉल्यूशन को कॉन्फ़िगरेशन कैश में सेव करता है. इससे डीसीरियलाइज़ेशन के दौरान गड़बड़ी होती है. यह समस्या सिर्फ़ Android में होती है

  • `Kotlin Gradle Plugin 2.3.0-Beta2` में ठीक की गई

• androidLibrary टारगेट के लिए, इंस्ट्रुमेंटेड sourceSetTree की सुविधा

  • Android Studio Otter 2 Feature Drop | 2025.2.2 Canary 3 और Android Gradle Plugin 9.0.0-alpha13 में ठीक की गई