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

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

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

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

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

टाइमलाइन

Android Studio Giraffe से शुरू होने वाले नए प्रोजेक्ट, बिल्ड कॉन्फ़िगरेशन के लिए डिफ़ॉल्ट रूप से 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
}

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

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

  • स्ट्रिंग के लिए डबल कोट: Groovy में स्ट्रिंग को सिंगल कोट का इस्तेमाल करके तय किया जा सकता है, जबकि 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 में, सूचियों और मैप को अलग-अलग सिंटैक्स का इस्तेमाल करके तय किया जाता है. Groovy में [] का इस्तेमाल किया जाता है, जबकि 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 से प्लग इन ब्लॉक पर माइग्रेट करना

अगर आपका बिल्ड, प्रोजेक्ट में प्लग इन जोड़ने के लिए 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

Gradle प्लग इन पोर्टल, Maven Central डेटा संग्रह, और 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()
    }
}

प्लग इन ब्लॉक को बदलना

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

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

// 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 सैंपल ऐप्लिकेशन देखें.