अपने बिल्ड कॉन्फ़िगरेशन को ग्रूवी से 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 जिराफ़ के साथ नए प्रोजेक्ट में, बिल्ड कॉन्फ़िगरेशन के लिए डिफ़ॉल्ट रूप से Kotlin DSL (build.gradle.kts) का इस्तेमाल किया जाता है. यह Groovy DSL (build.gradle) की तुलना में, सिंटैक्स हाइलाइट करने, कोड पूरा करने, और एलान करने के लिए नेविगेट करने की सुविधा के साथ, बदलाव करने का बेहतर अनुभव देता है. ज़्यादा जानने के लिए, Gradle Kotlin DSL Primer देखें.

सामान्य शब्द

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

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

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

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

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

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

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

मेथड कॉल में ब्रैकेट जोड़ना

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

compileSdkVersion 30

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

compileSdkVersion(30)

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

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

java {
    sourceCompatibility JavaVersion.VERSION_17
    targetCompatibility JavaVersion.VERSION_17
}

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

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

स्ट्रिंग बदलना

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

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

  • बिंदु वाले एक्सप्रेशन पर स्ट्रिंग इंटरपोलेशन: Groovy में, बिंदु वाले एक्सप्रेशन पर स्ट्रिंग इंटरपोलेशन के लिए, सिर्फ़ $ प्रीफ़िक्स का इस्तेमाल किया जा सकता है. हालांकि, 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 से शुरू करना होगा. इस कोड में, Groovy में बूलियन प्रॉपर्टी सेट करने का तरीका बताया गया है:

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

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

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

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

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

Groovy और 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 में सिर्फ़ डीबग और रिलीज़ बिल्ड टाइप, सीधे तौर पर उपलब्ध होते हैं. अन्य सभी कस्टम बिल्ड टाइप को मैन्युअल तरीके से बनाया जाना चाहिए.

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

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

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

buildTypes {
 debug {
   ...
 }

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

बिल्डस्क्रिप्ट से प्लगिन ब्लॉक पर माइग्रेट करें

अगर आपका बिल्ड, प्रोजेक्ट में प्लगिन जोड़ने के लिए 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 रिपॉज़िटरी में मिल सकती है.

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

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

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

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

  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()
    }
}

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

Groovy और Kotlin में, plugins {} ब्लॉक से प्लग इन लागू करने का तरीका एक जैसा है. यहां दिए गए कोड में, वर्शन कैटलॉग का इस्तेमाल करते समय, 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 सैंपल ऐप्लिकेशन देखें.