अपने बिल्ड कॉन्फ़िगरेशन को ग्रूवी से Kotlin में माइग्रेट करें

'Android Gradle प्लग इन 4.0' के Gradle बिल्ड कॉन्फ़िगरेशन में Kotlin का इस्तेमाल करने की सुविधा जोड़ी गई. यह Gradle कॉन्फ़िगरेशन फ़ाइलों में पारंपरिक रूप से इस्तेमाल की जाने वाली प्रोग्रामिंग भाषा ग्रूवी की जगह है.

Gradle स्क्रिप्ट लिखने के लिए, Groovy के बजाय Kotlin को प्राथमिकता दी जाती है. इसकी वजह यह है कि Kotlin को पढ़ना आसान है. साथ ही, यह कंपाइल करने के समय बेहतर जांच करने और आईडीई (इंटिग्रेटेड डेवलपमेंट एनवायरमेंट) की सुविधा देता है.

फ़िलहाल, Kotlin की तुलना में Groovy, Android Studio के कोड एडिटर में बेहतर इंटिग्रेशन देता है. हालांकि, Kotlin का इस्तेमाल करने वाले बिल्ड, Groovy का इस्तेमाल करने वाले बिल्ड की तुलना में धीमे होते हैं. इसलिए, माइग्रेट करने का फ़ैसला लेते समय, बिल्ड की परफ़ॉर्मेंस पर ध्यान दें.

इस पेज पर, अपने Android ऐप्लिकेशन की Gradle बिल्ड फ़ाइलों को Groovy से Kotlin में बदलने के बारे में बुनियादी जानकारी दी गई है. माइग्रेशन से जुड़ी ज़्यादा जानकारी वाली गाइड के लिए, Gradle का आधिकारिक दस्तावेज़ देखें.

टाइमलाइन

Android Studio Giraffe से शुरू होने वाले नए प्रोजेक्ट, बिल्ड कॉन्फ़िगरेशन के लिए डिफ़ॉल्ट रूप से Kotlin DSL (build.gradle.kts) का इस्तेमाल करते हैं. यह ऐप्लिकेशन ग्रूवी DSL (build.gradle) के मुकाबले बेहतर तरीके से बदलाव करने की सुविधा देता है. इसमें सिंटैक्स हाइलाइट करने, कोड पूरा करने, और एलानों तक नेविगेट करने जैसी सुविधाओं की मदद से बेहतर तरीके से बदलाव किया जा सकता है. ज़्यादा जानने के लिए, Gradle Kotlin DSL Primer देखें.

सामान्य शब्द

Kotlin DSL: इसका मतलब मुख्य रूप से Android Gradle प्लग इन Kotlin DSL या कभी-कभी, आधारभूत Gradle Kotlin DSL से है.

डेटा को दूसरी जगह भेजने से जुड़ी इस गाइड में, "Kotlin" और "Kotlin DSL" को एक-दूसरे की जगह इस्तेमाल किया गया है. इसी तरह, "Groovy" और "Groovy DSL", दोनों का इस्तेमाल एक-दूसरे के लिए किया जाता है.

स्क्रिप्ट फ़ाइल को नाम देना

स्क्रिप्ट फ़ाइल एक्सटेंशन के नाम, उस भाषा के आधार पर तय होते हैं जिसमें बिल्ड फ़ाइल लिखी गई है:

  • ग्रूवी में लिखी गई Gradle बिल्ड फ़ाइलें, .gradle फ़ाइल के नाम का एक्सटेंशन इस्तेमाल करती हैं.
  • Kotlin में लिखी गई Gradle बिल्ड फ़ाइलें, .gradle.kts फ़ाइल के नाम के एक्सटेंशन का इस्तेमाल करती हैं.

सिंटैक्स को बदलना

ग्रूवी और Kotlin के सिंटैक्स में कुछ सामान्य अंतर हैं, इसलिए आपको इन बदलावों को अपनी पूरी बिल्ड स्क्रिप्ट पर लागू करना होगा.

तरीके से जुड़े कॉल में ब्रैकेट जोड़ें

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

compileSdkVersion 30

यह वही कोड है जो Kotlin में लिखा है:

compileSdkVersion(30)

= को असाइनमेंट कॉल में जोड़ें

Groovy DSL की मदद से, प्रॉपर्टी असाइन करते समय असाइनमेंट ऑपरेटर = को छोड़ा जा सकता है. हालांकि, Kotlin में ऐसा नहीं किया जा सकता. यह कोड दिखाता है कि ग्रूवी में प्रॉपर्टी कैसे असाइन की जाती हैं:

java {
    sourceCompatibility JavaVersion.VERSION_17
    targetCompatibility JavaVersion.VERSION_17
}

यह कोड बताता है कि Kotlin में प्रॉपर्टी कैसे असाइन करें:

java {
    sourceCompatibility = JavaVersion.VERSION_17
    targetCompatibility = JavaVersion.VERSION_17
}

स्ट्रिंग बदलें

Groovy और Kotlin के बीच स्ट्रिंग के अंतर यहां दिए गए हैं:

  • स्ट्रिंग के लिए डबल कोट: हालांकि, ग्रूवी स्ट्रिंग को सिंगल कोट का इस्तेमाल करके तय करने देता है, जबकि Kotlin को डबल कोट की ज़रूरत होती है.

  • बिंदु वाले एक्सप्रेशन पर स्ट्रिंग इंटरपोलेशन: ग्रूवी में, डॉट एक्सप्रेशन पर स्ट्रिंग इंटरपोलेशन के लिए सिर्फ़ $ प्रीफ़िक्स का इस्तेमाल किया जा सकता है, लेकिन Kotlin के लिए यह ज़रूरी है कि आप बिंदु वाले एक्सप्रेशन को कर्ली ब्रेसेस के साथ रैप करें. उदाहरण के लिए, Groovy में $project.rootDir का इस्तेमाल किया जा सकता है, जैसा कि इस स्निपेट में दिखाया गया है:

        myRootDirectory = "$project.rootDir/tools/proguard-rules-debug.pro"

    हालांकि, Kotlin में, ऊपर दिया गया कोड project.rootDir पर नहीं, बल्कि project पर toString() को कॉल करता है. रूट डायरेक्ट्री की वैल्यू पाने के लिए, ${project.rootDir} एक्सप्रेशन को कर्ली ब्रैकेट से रैप करें:

        myRootDirectory = "${project.rootDir}/tools/proguard-rules-debug.pro"

    ज़्यादा जानने के लिए, Kotlin दस्तावेज़ में स्ट्रिंग टेंप्लेट देखें.

फ़ाइल एक्सटेंशन का नाम बदलना

बिल्ड फ़ाइल का कॉन्टेंट माइग्रेट करते समय, उसमें .kts जोड़ें. उदाहरण के लिए, कोई बिल्ड फ़ाइल चुनें, जैसे कि settings.gradle फ़ाइल. फ़ाइल का नाम बदलकर settings.gradle.kts करें और फ़ाइल के कॉन्टेंट को Kotlin में बदलें. पक्का करें कि हर बिल्ड फ़ाइल के माइग्रेट होने के बाद भी, आपका प्रोजेक्ट कंपाइल हो रहा हो.

सबसे पहले अपनी छोटी फ़ाइलों को माइग्रेट करें, अनुभव हासिल करें, और फिर आगे बढ़ें. किसी प्रोजेक्ट में, Kotlin और Groovy, दोनों तरह की बिल्ड फ़ाइलें हो सकती हैं. इसलिए, ध्यान से यह फ़ैसला लें.

def को val या var से बदलें

def को val या var से बदलें. यह Kotlin में वैरिएबल तय करने का तरीका है. यह Groovy पर आधारित वैरिएबल की जानकारी है:

def building64Bit = false

यह वही कोड है जिसे Kotlin में लिखा गया है:

val building64Bit = false

बूलियन प्रॉपर्टी के प्रीफ़िक्स के तौर पर is का इस्तेमाल करना

Groovy, प्रॉपर्टी के नामों के आधार पर प्रॉपर्टी के हिसाब से कटौती के लॉजिक का इस्तेमाल करता है. बूलियन प्रॉपर्टी foo के लिए, अनुमानित तरीके getFoo, setFoo या isFoo हो सकते हैं. इसलिए, Kotlin में बदलने के बाद, आपको प्रॉपर्टी के नामों को उन तरीकों में बदलना होगा जो Kotlin के साथ काम नहीं करते. उदाहरण के लिए, buildTypes डीएसएल बूलियन एलिमेंट के लिए, आपको उनकी शुरुआत में is लगाना होगा. यह कोड बताता है कि ग्रूवी में बूलियन प्रॉपर्टी को कैसे सेट किया जाता है:

android {
    buildTypes {
        release {
            minifyEnabled true
            shrinkResources true
            ...
        }
        debug {
            debuggable true
            ...
        }
    ...

यहां Kotlin में वही कोड दिया गया है. ध्यान रखें कि प्रॉपर्टी की शुरुआत में is लगा होता है.

android {
    buildTypes {
        getByName("release") {
            isMinifyEnabled = true
            isShrinkResources = true
            ...
        }
        getByName("debug") {
            isDebuggable = true
            ...
        }
    ...

सूचियों और मैप को बदलना

ग्रूवी और Kotlin में सूचियों और मैप को अलग-अलग सिंटैक्स का इस्तेमाल करके तय किया जाता है. ग्रूवी, [] का इस्तेमाल करता है, जबकि Kotlin में कलेक्शन बनाने के तरीकों का साफ़ तौर पर listOf या mapOf इस्तेमाल करता है. माइग्रेट करते समय, [] को listOf या mapOf से बदलना न भूलें.

यहां ग्रूवी बनाम Kotlin में लिस्ट बनाने का तरीका बताया गया है:

jvmOptions += ["-Xms4000m", "-Xmx4000m", "-XX:+HeapDumpOnOutOfMemoryError</code>"]

यह वही कोड है जो Kotlin में लिखा है:

jvmOptions += listOf("-Xms4000m", "-Xmx4000m", "-XX:+HeapDumpOnOutOfMemoryError")

Groovy और Kotlin में मैप तय करने का तरीका यहां बताया गया है:

def myMap = [key1: 'value1', key2: 'value2']

यह वही कोड है जो Kotlin में लिखा है:

val myMap = mapOf("key1" to "value1", "key2" to "value2")

बिल्ड टाइप कॉन्फ़िगर करना

Kotlin DSL में सिर्फ़ डीबग और रिलीज़ बिल्ड टाइप, सीधे तौर पर उपलब्ध होते हैं. अन्य सभी कस्टम बिल्ड टाइप को मैन्युअल तरीके से बनाया जाना चाहिए.

ग्रूवी में आप डीबग, रिलीज़ और कुछ अन्य बिल्ड टाइप को पहले बनाए बिना उनका इस्तेमाल कर सकते हैं. नीचे दिया गया कोड स्निपेट debug, release, और benchmark ग्रूवी में बिल्ड टाइप के साथ कॉन्फ़िगरेशन दिखाता है.

buildTypes {
 debug {
   ...
 }
 release {
   ...
 }
 benchmark {
   ...
 }
}

Kotlin में एक जैसा कॉन्फ़िगरेशन बनाने के लिए, आपको साफ़ तौर पर benchmark बिल्ड टाइप बनाना होगा.

buildTypes {
 debug {
   ...
 }

 release {
   ...
 }
 register("benchmark") {
    ...
 }
}

buildscript से प्लग इन ब्लॉक पर माइग्रेट करना

अगर आपका बिल्ड, प्रोजेक्ट में प्लग इन जोड़ने के लिए buildscript {} ब्लॉक का इस्तेमाल करता है, तो आपको इसके बजाय plugins {} ब्लॉक का इस्तेमाल करने के लिए, फिर से फ़ैक्टर करना चाहिए. plugins {} ब्लॉक से, प्लगिन लागू करना आसान हो जाता है. साथ ही, यह वर्शन कैटलॉग के साथ अच्छे से काम करता है.

इसके अलावा, जब अपनी बिल्ड फ़ाइलों में plugins {} ब्लॉक का इस्तेमाल किया जाता है, तो Android Studio को कॉन्टेक्स्ट की जानकारी होती है. भले ही, बिल्ड न हो पाए. इस कॉन्टेक्स्ट से, आपकी Kotlin DSL फ़ाइलों में सुधार करने में मदद मिलती है. ऐसा इसलिए होता है, क्योंकि इससे Studio IDE को कोड पूरा करने और अन्य मददगार सुझाव देने की सुविधा मिलती है.

प्लग इन आईडी ढूंढें

buildscript {} ब्लॉक, प्लग इन के Maven कोऑर्डिनेट का इस्तेमाल करके, प्लग इन को बिल्ड क्लासपाथ में जोड़ता है. उदाहरण के लिए, com.android.tools.build:gradle:7.4.0. वहीं, plugins {} ब्लॉक, प्लग इन आईडी का इस्तेमाल करता है.

ज़्यादातर प्लग इन के लिए, प्लग इन आईडी वह स्ट्रिंग होती है जिसका इस्तेमाल, apply plugin का इस्तेमाल करके उन्हें लागू करते समय किया जाता है. उदाहरण के लिए, ये प्लग इन आईडी, Android Gradle प्लग इन का हिस्सा हैं:

  • com.android.application
  • com.android.library
  • com.android.lint
  • com.android.test

आपको प्लग इन की पूरी सूची, Google Maven Repository में मिल सकती है.

Kotlin प्लग इन का रेफ़रंस, कई प्लग इन आईडी से दिया जा सकता है. हमारा सुझाव है कि आप नेमस्पेस वाले प्लग इन आईडी का इस्तेमाल करें. साथ ही, इस टेबल की मदद से शॉर्टहैंड से नेमस्पेस वाले प्लग इन आईडी में बदलाव करें:

शॉर्टहैंड प्लगिन आईडी नेमस्पेस किए गए प्लगिन आईडी
kotlin org.jetbrains.kotlin.jvm
kotlin-android org.jetbrains.kotlin.android
kotlin-kapt org.jetbrains.kotlin.kapt
kotlin-parcelize org.jetbrains.kotlin.plugin.parcelize

प्लगिन, Gredle प्लगिन पोर्टल, Maven सेंट्रल रिपॉज़िटरी, और Google Maven रिपॉज़िटरी पर भी खोजे जा सकते हैं. प्लग इन आईडी के काम करने के तरीके के बारे में ज़्यादा जानने के लिए, कस्टम Gradle प्लग इन बनाना लेख पढ़ें.

रीफ़ैक्टरिंग करना

इस्तेमाल किए जाने वाले प्लगिन के आईडी जानने के बाद, यह तरीका अपनाएं:

  1. अगर आपके पास अब भी buildscript {} ब्लॉक में बताए गए प्लग इन के लिए रिपॉज़िटरी हैं, तो उन्हें settings.gradle फ़ाइल में ले जाएं.

  2. टॉप-लेवल की build.gradle फ़ाइल में, plugins {} ब्लॉक में प्लगिन जोड़ें. यहां आपको प्लगिन का आईडी और वर्शन बताना होगा. अगर रूट प्रोजेक्ट पर प्लगिन को लागू करने की ज़रूरत नहीं है, तो apply false का इस्तेमाल करें.

  3. टॉप-लेवल की build.gradle.kts फ़ाइल से classpath एंट्री हटाएं.

  4. प्लग इन लागू करने के लिए, उन्हें मॉड्यूल-लेवल build.gradle फ़ाइल में plugins {} ब्लॉक में जोड़ें. आपको यहां सिर्फ़ प्लग इन का आईडी बताना होगा, क्योंकि वर्शन को रूट प्रोजेक्ट से इनहेरिट किया जाता है.

  5. मॉड्यूल-लेवल build.gradle फ़ाइल से, प्लगिन के लिए apply plugin कॉल को हटाएं.

उदाहरण के लिए, यह सेटअप buildscript {} ब्लॉक का इस्तेमाल करता है:

// Top-level build.gradle file
buildscript {
    repositories {
        google()
        mavenCentral()
        gradlePluginPortal()
    }
    dependencies {
        classpath("com.android.tools.build:gradle:7.4.0")
        classpath("org.jetbrains.kotlin:kotlin-gradle-plugin:1.8.0")
        ...
    }
}

// Module-level build.gradle file
apply(plugin: "com.android.application")
apply(plugin: "kotlin-android")

plugins {} ब्लॉक का इस्तेमाल करके, यह सेटअप भी किया जा सकता है:

// Top-level build.gradle file
plugins {
   id 'com.android.application' version '7.4.0' apply false
   id 'org.jetbrains.kotlin.android' version '1.8.0' apply false
   ...
}

// Module-level build.gradle file
plugins {
   id 'com.android.application'
   id 'org.jetbrains.kotlin.android'
   ...
}

// settings.gradle
pluginManagement {
    repositories {
        google()
        mavenCentral()
        gradlePluginPortal()
    }
}

प्लगिन ब्लॉक को बदलें

plugins {} ब्लॉक से प्लगिन लागू करना, Groovy और Kotlin में एक जैसा होता है. यहां दिए गए कोड में, वर्शन कैटलॉग का इस्तेमाल करते समय, Groovy में प्लग इन लागू करने का तरीका बताया गया है:

// Top-level build.gradle file
plugins {
   alias libs.plugins.android.application apply false
   ...
}

// Module-level build.gradle file
plugins {
   alias libs.plugins.android.application
   ...
}

इस कोड से यह पता चलता है कि Kotlin में ऐसा ही कैसे किया जा सकता है:

// Top-level build.gradle.kts file
plugins {
   alias(libs.plugins.android.application) apply false
   ...
}

// Module-level build.gradle.kts file
plugins {
   alias(libs.plugins.android.application)
   ...
}

जब आप वर्शन कैटलॉग का इस्तेमाल नहीं कर रहे होते हैं, तब नीचे दिया गया कोड ग्रूवी में प्लगिन को लागू करने का तरीका बताता है:

// Top-level build.gradle file
plugins {
   id 'com.android.application' version '7.3.0' apply false
   ...
}

// Module-level build.gradle file
plugins {
   id 'com.android.application'
   ...
}

इस कोड से यह पता चलता है कि Kotlin में ऐसा ही कैसे किया जा सकता है:

// Top-level build.gradle.kts file
plugins {
   id("com.android.application") version "7.3.0" apply false
   ...
}

// Module-level build.gradle.kts file
plugins {
   id("com.android.application")
   ...
}

plugins {} ब्लॉक के बारे में ज़्यादा जानकारी के लिए, Gradle के दस्तावेज़ में प्लग इन लागू करना देखें.

अन्य चीज़ें

अन्य फ़ंक्शन के Kotlin कोड के सैंपल के लिए, दस्तावेज़ के ये पेज देखें:

पहले से मालूम समस्याएं

फ़िलहाल, यह एक आम समस्या है कि Groovy की तुलना में Kotlin में, बिल्ड करने की स्पीड धीमी हो सकती है.

समस्याओं की शिकायत करने का तरीका

आपकी समस्या को प्राथमिकता के हिसाब से निपटाने के लिए ज़रूरी जानकारी किस तरह उपलब्ध कराई जाए, इस बारे में जानने के लिए बिल्ड टूल और Gradle बग के बारे में जानकारी देखें. इसके बाद, Google के सार्वजनिक समस्या को ट्रैक करने वाले टूल की मदद से, गड़बड़ी की शिकायत करें.

ज़्यादा संसाधन

Kotlin में लिखी गई Gradle बिल्ड फ़ाइलों का काम करने वाला उदाहरण देखने के लिए, GitHub पर Now In Android सैंपल ऐप्लिकेशन देखें.