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

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

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

फ़िलहाल, Android Studio के कोड एडिटर में Kotlin को Groovy की तुलना में बेहतर तरीके से इंटिग्रेट किया जा सकता है. हालांकि, 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 के सिंटैक्स में कुछ सामान्य अंतर होते हैं. इसलिए, आपको अपनी सभी बिल्ड स्क्रिप्ट में ये बदलाव करने होंगे.

तरीके के कॉल में पैरंटheses जोड़ना

Groovy में, मेथड कॉल में पैरंटheses को छोड़ा जा सकता है. हालांकि, 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 के बजाय toString() on project को कॉल करता है. रूट डायरेक्ट्री की वैल्यू पाने के लिए, ${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 से plugins ब्लॉक पर माइग्रेट करना

अगर आपके बिल्ड में प्रोजेक्ट में प्लगिन जोड़ने के लिए, 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 Plugin Portal, Maven Central Repository, और Google Maven repository पर भी प्लग इन खोजे जा सकते हैं. प्लगिन आईडी के काम करने के तरीके के बारे में ज़्यादा जानने के लिए, कस्टम 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 कोड के सैंपल देखने के लिए, यहां दिए गए दस्तावेज़ के पेज देखें:

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

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

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

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

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

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