build.gradle: यह क्या है, सिंटैक्स और Android में कॉन्फ़िगरेशन

build.gradle क्या है?

build.gradle Groovy (.gradle एक्सटेंशन) या Kotlin (.gradle.kts) भाषा में लिखा गया एक बिल्ड स्क्रिप्ट है जो Android एप्लिकेशन कंपिलेशन के सभी पहलुओं का प्रबंधन करता है। Gradle एक स्वचालित बिल्ड सिस्टम है जिसे Google ने 2013 में Android के लिए मानक के रूप में अपनाया था। build.gradle वर्णन करता है: कौन से प्लगइन लागू हैं (Android, Kotlin, लाइब्रेरी), कौन सी डिपेंडेंसी जुड़ी हैं, कौन से SDK संस्करण उपयोग किए गए हैं, एप्लिकेशन पर हस्ताक्षर कैसे करें और कहाँ प्रकाशित करें।

बिल्ड प्रक्रिया में तीन चरण शामिल हैं: Initialization (मॉड्यूल खोज), Configuration (build.gradle स्क्रिप्ट निष्पादन), Execution (कार्य निष्पादन)। build.gradle Configuration चरण के दौरान चलता है, जब Gradle कार्य ग्राफ बनाता है। इस बिंदु पर Build Variants निर्धारित होते हैं, डिपेंडेंसी गणना की जाती है और कार्य कॉन्फ़िगर किए जाते हैं। महत्वपूर्ण: build.gradle कोड है, सिर्फ कॉन्फ़िगरेशन नहीं। इसमें शर्तों, लूप्स, मेथड कॉल और बाहरी स्क्रिप्ट का उपयोग किया जा सकता है।

Gradle फ़ाइलें मॉड्यूल रूट (app/build.gradle) और प्रोजेक्ट रूट (build.gradle) में संग्रहीत होती हैं। इसके अलावा, Gradle apply from का समर्थन करता है — बाहरी Gradle स्क्रिप्ट को शामिल करना। यह दोहराए जाने वाले तर्क को साझा सेटिंग्स वाली फ़ाइलों में निकालने की अनुमति देता है। Convention Plugins (AGP 7+) के आगमन के साथ, apply from को पुराना माना जाता है — Convention Plugins मॉड्यूल के बीच कॉन्फ़िगरेशन पुन: उपयोग का type-safe और संयोजनीय तरीका प्रदान करते हैं।

build.gradle का विकास

2013 से, build.gradle सिंटैक्स में महत्वपूर्ण परिवर्तन हुए हैं: गतिशील कॉन्फ़िगरेशन वाले Groovy से लेकर compile-time जाँच वाले Kotlin DSL तक। AGP संस्करण 1.0 से 8.7 (2025) तक विकसित हुआ है। प्रमुख माइलस्टोन: AGP 3.0 (Java 8 desugar, नया variant API), AGP 4.0 (view binding, Java 11), AGP 7.0 (डिफ़ॉल्ट रूप से Kotlin DSL, Java 11 न्यूनतम), AGP 8.0 (non-transitive R classes, Kotlin में build config), AGP 8.7 (kapt के बजाय KSP, तेज़ कॉन्फ़िगरेशन)।

Project-level और Module-level build.gradle

Project-level build.gradle (रूट) सभी मॉड्यूल के लिए सामान्य प्लगइन, रिपॉज़िटरी और कॉन्फ़िगरेशन परिभाषित करता है। मुख्य ब्लॉक: plugins (Gradle प्लगइन घोषणाएँ), repositories (डिपेंडेंसी स्रोत: mavenCentral, google, jitpack)। रूट build.gradle में आमतौर पर android ब्लॉक नहीं होता — यह मॉड्यूल में दिखाई देता है। Project-level में सभी उपप्रोजेक्ट के सामान्य कॉन्फ़िगरेशन के लिए subprojects ब्लॉक भी हो सकता है, हालाँकि Convention Plugins बेहतर हैं।

Module-level build.gradle (उदाहरण के लिए, app/build.gradle) एक विशिष्ट मॉड्यूल का वर्णन करता है। यदि मॉड्यूल एक एप्लिकेशन है, तो यह com.android.application प्लगइन लागू करता है। यदि लाइब्रेरी है — com.android.library। Module-level में शामिल हैं: android ब्लॉक (compileSdk, defaultConfig, buildTypes, productFlavors), dependencies ब्लॉक (मॉड्यूल डिपेंडेंसी) और वैकल्पिक रूप से परीक्षण और पैकेजिंग कॉन्फ़िगरेशन के लिए ब्लॉक। Module-level project-level के बाद चलता है और सामान्य सेटिंग्स को ओवरराइड कर सकता है।

AGP 8.0 से शुरू करके, रूट build.gradle केंद्रीकृत डिपेंडेंसी संस्करण प्रबंधन के लिए version catalogs (libs.versions.toml) का उपयोग कर सकता है। version catalog gradle/ निर्देशिका में एक फ़ाइल है जिसमें संस्करण, लाइब्रेरी और प्लगइन होते हैं। build.gradle में डिपेंडेंसी libs के माध्यम से जुड़ती हैं: implementation(libs.retrofit). version catalogs नए प्रोजेक्ट के लिए अनिवार्य हैं और तीन या अधिक मॉड्यूल वाले सभी प्रोजेक्ट के लिए अनुशंसित हैं।

// settings.gradle.kts — प्रोजेक्ट रूट
pluginManagement {
    repositories {
        google()
        mavenCentral()
        gradlePluginPortal()
    }
}

// build.gradle.kts (project-level)
plugins {
    id("com.android.application") version "8.7.0" apply false
    id("org.jetbrains.kotlin.android") version "2.0.21" apply false
}

// app/build.gradle.kts (module-level)
plugins {
    id("com.android.application")
    id("org.jetbrains.kotlin.android")
    id("com.google.devtools.ksp")
}

android {
    namespace = "com.example.myapp"
    compileSdk = 35

    defaultConfig {
        applicationId = "com.example.myapp"
        minSdk = 26
        targetSdk = 35
        versionCode = 1
        versionName = "1.0.0"
    }
}

Groovy vs Kotlin DSL

Groovy एक गतिशील JVM भाषा है जो Gradle का मूल सिंटैक्स थी। Groovy स्क्रिप्ट (.gradle) गतिशील टाइपिंग का उपयोग करती हैं: आप टाइप छोड़ सकते हैं, उद्धरण के साथ या बिना स्ट्रिंग का उपयोग कर सकते हैं, ऐसे मेथड कॉल कर सकते हैं जो कंपाइल समय पर मौजूद नहीं हैं। Groovy की लचीलापन ही इसकी कमी है: IDE स्क्रिप्ट निष्पादित होने तक सिंटैक्स और टाइप की जाँच नहीं कर सकता, जिससे गलत पैरामीटर नाम या टाइप के कारण runtime त्रुटियाँ होती हैं।

Kotlin DSL (.gradle.kts) Kotlin की स्थिर टाइपिंग का उपयोग करता है। IDE टाइप की जाँच करता है, ऑटोकम्प्लीट के माध्यम से उपलब्ध पैरामीटर सुझाता है और संपादन के समय त्रुटियों को हाइलाइट करता है। Kotlin DSL Configuration चरण के दौरान धीमा है (.kts फ़ाइलों को बाइटकोड में कंपाइल करने के कारण), लेकिन Google लगातार प्रदर्शन में सुधार करता है: AGP 8.5+ Gradle Configuration Cache और Caching Kotlin DSL compilation का उपयोग करता है, जिससे अंतर 1-2 सेकंड तक कम हो जाता है।

Google सभी नए प्रोजेक्ट के लिए Kotlin DSL और मौजूदा प्रोजेक्ट के क्रमिक माइग्रेशन की अनुशंसा करता है। Groovy से Kotlin DSL में माइग्रेशन सीधा है: उद्धरण कोष्ठक से बदल दिए जाते हैं, टाइप जोड़े जाते हैं, ऑपरेटर फ़ंक्शन में परिवर्तित हो जाते हैं। अधिकांश लाइब्रेरी अपने दस्तावेज़ीकरण में Kotlin DSL उदाहरण प्रदान करती हैं। जटिल मामलों (Custom Plugin, Task Graph) के लिए, Kotlin DSL type-safe API प्रदान करता है और उन त्रुटियों को रोकता है जो Groovy में केवल runtime पर खोजी जाती हैं। Version catalogs (libs.versions.toml) दोनों सिंटैक्स के साथ समान रूप से काम करते हैं।

android ब्लॉक: एप्लिकेशन कॉन्फ़िगरेशन

compileSdk, minSdk और targetSdk

android ब्लॉक module-level build.gradle का केंद्रीय तत्व है। इसके अंदर कॉन्फ़िगर किए जाते हैं: namespace (R और BuildConfig के लिए), compileSdk, defaultConfig, buildTypes, productFlavors, sourceSets, compileOptions, packaging, bundle। android ब्लॉक के सभी पैरामीटर केवल Android मॉड्यूल पर लागू होते हैं। यदि मॉड्यूल एक लाइब्रेरी है, तो application के बजाय लाइब्रेरी प्लगइन का उपयोग किया जाता है, और android ब्लॉक में applicationId अनुपस्थित होता है।

compileSdk वह SDK संस्करण है जिसके साथ कोड कंपाइल किया जाता है। यह नवीनतम Android API के बराबर होना चाहिए (लेखन के समय — 35)। minSdk समर्थन के लिए न्यूनतम API संस्करण है। targetSdk वह संस्करण है जिसे एप्लिकेशन लक्षित करता है (इस संस्करण के व्यवहारिक परिवर्तन लागू होते हैं)। compileSdk और targetSdk के बीच अंतर: compileSdk उपलब्ध API निर्धारित करता है, targetSdk runtime व्यवहार निर्धारित करता है। अनुशंसा: compileSdk = नवीनतम, targetSdk = नवीनतम - 1 (नए परिवर्तनों के अनुकूलन के परीक्षण के लिए)।

compileOptions Java संगतता सेट करता है: sourceCompatibility और targetCompatibility। AGP 8+ को कंपिलेशन के लिए Java 17+ की आवश्यकता है। packaging लाइब्रेरी से फ़ाइल समावेशन प्रबंधित करता है: META-INF विरोधों को हल करने के लिए exclude, merge, pickFirst। buildFeatures ViewBinding, DataBinding, Compose को सक्षम/अक्षम करता है। aaptOptions संसाधन प्रसंस्करण कॉन्फ़िगर करता है: ignoreAssetsPattern, cruncherEnabled। android ब्लॉक का प्रत्येक तत्व बिल्ड के एक विशिष्ट पहलू को अनुकूलित करता है।

android {
    namespace = "com.example.myapp"
    compileSdk = 35
    buildToolsVersion = "35.0.0"

    defaultConfig {
        applicationId = "com.example.myapp"
        minSdk = 26
        targetSdk = 35
        versionCode = 5
        versionName = "2.3.1"

        testInstrumentationRunner = "androidx.test.runner.AndroidJUnitRunner"
    }

    buildTypes {
        getByName("debug") { isDebuggable = true }
        getByName("release") {
            isMinifyEnabled = true
            proguardFiles(getDefaultProguardFile("proguard-android-optimize.txt"))
        }
    }

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

    buildFeatures {
        viewBinding = true
        compose = true
    }
}

डिपेंडेंसी प्रबंधन

BOM (Bill of Materials)

डिपेंडेंसी build.gradle में वे लाइब्रेरी और मॉड्यूल हैं जो प्रोजेक्ट से जुड़े होते हैं। dependencies ब्लॉक android ब्लॉक के समान स्तर पर होता है। Gradle कई कॉन्फ़िगरेशन का समर्थन करता है: implementation (लाइब्रेरी इस मॉड्यूल में उपलब्ध है, ट्रांज़िटिव नहीं), api (लाइब्रेरी आश्रित मॉड्यूल के लिए ट्रांज़िटिव रूप से उपलब्ध है), compileOnly (केवल कंपिलेशन के लिए, APK में शामिल नहीं), runtimeOnly (केवल runtime में), annotationProcessor / ksp (एनोटेशन प्रोसेसर), testImplementation (केवल परीक्षण के लिए), androidTestImplementation (केवल इंस्ट्रुमेंटेशन परीक्षण के लिए)।

AGP 8.0 से शुरू करके, Non-Transitive R classes — प्रत्येक लाइब्रेरी का अपना R क्लास होता है, जो संसाधन विरोधों को रोकता है। dependencies ब्लॉक में सही कॉन्फ़िगरेशन का उपयोग करना महत्वपूर्ण है: implementation ट्रांज़िटिव डिपेंडेंसी को उजागर नहीं करता, जिससे बिल्ड तेज़ होता है। api उन्हें उजागर करता है — जब कोई लाइब्रेरी किसी अन्य लाइब्रेरी से टाइप निर्यात करती है तब उपयोग किया जाता है (उदाहरण के लिए, Retrofit अपने सार्वजनिक API में OkHttp टाइप का उपयोग करता है)।

संस्करण प्रबंधन के लिए BOM (Bill of Materials) का उपयोग करने की अनुशंसा की जाती है — एक बिल्ड फ़ाइल जो संगत लाइब्रेरी संस्करणों को परिभाषित करती है। Firebase BOM: implementation(platform("com.google.firebase:firebase-bom:33.0.0"))। BOM कनेक्ट करने के बाद, आप केवल लाइब्रेरी का नाम बिना संस्करण के निर्दिष्ट कर सकते हैं — BOM स्वचालित रूप से एक संगत संस्करण चुनेगा। यह विभिन्न लाइब्रेरी की ट्रांज़िटिव डिपेंडेंसी के बीच विरोधों को समाप्त करता है। BOM Firebase, Compose, Kotlin, Ktor, AndroidX के लिए उपलब्ध हैं।

dependencies {
    // BOM — संस्करण प्रबंधन
    implementation(platform("androidx.compose:compose-bom:2024.12.01"))
    implementation(platform("com.google.firebase:firebase-bom:33.0.0"))

    // AndroidX और Compose
    implementation("androidx.core:core-ktx")
    implementation("androidx.lifecycle:lifecycle-runtime-ktx")
    implementation("androidx.activity:activity-compose")
    implementation("androidx.compose.ui:ui")

    // Network
    implementation("com.squareup.retrofit2:retrofit:2.11.0")
    implementation("com.squareup.okhttp3:okhttp:4.12.0")

    // Firebase (BOM से संस्करण)
    implementation("com.google.firebase:firebase-firestore")
    implementation("com.google.firebase:firebase-crashlytics")

    // परीक्षण
    testImplementation("junit:junit:4.13.2")
    androidTestImplementation("androidx.test.ext:junit:1.2.1")
}

मल्टी-मॉड्यूल प्रोजेक्ट्स में build.gradle

मल्टी-मॉड्यूल प्रोजेक्ट में, प्रत्येक मॉड्यूल का अपना build.gradle होता है। एक मॉड्यूल को दूसरे से जोड़ने के लिए सिंटैक्स implementation(project(":module-name")) का उपयोग किया जाता है। यदि इसका कॉन्फ़िगरेशन बदल गया है तो Gradle स्वचालित रूप से मॉड्यूल का पुनर्निर्माण करता है। मल्टी-मॉड्यूल आर्किटेक्चर बिल्ड समय में सुधार करता है (इन्क्रीमेंटल बिल्ड, समानांतरता) और फीचर मॉड्यूल, कोर मॉड्यूल और लाइब्रेरी के बीच जिम्मेदारियों को अलग करता है।

मल्टी-मॉड्यूल प्रोजेक्ट की मुख्य समस्या कॉन्फ़िगरेशन डुप्लिकेशन है। यदि 10 मॉड्यूल में समान minSdk, compileSdk और Compose डिपेंडेंसी हैं, तो यह अलग-अलग build.gradle फ़ाइलों में 10 प्रतियाँ हैं। समाधान Convention Plugins (पहले buildSrc) है। Convention Plugin एक Gradle प्लगइन है जो Kotlin में लिखा गया है और मॉड्यूल पर लागू होता है: plugins { id("myapp.android.library") }। प्लगइन में सामान्य कॉन्फ़िगरेशन होता है, और परिवर्तन तुरंत सभी मॉड्यूल पर लागू होते हैं।

Convention Plugins को व्यवस्थित करने के लिए प्रोजेक्ट रूट में build-logic/ निर्देशिका का उपयोग किया जाता है। इसमें settings.gradle में includeBuild और Kotlin प्लगइन शामिल हैं। Convention Plugins को प्रोजेक्ट के बीच पुन: उपयोग के लिए maven रिपॉज़िटरी में प्रकाशित किया जा सकता है। Google मल्टी-मॉड्यूल प्रोजेक्ट के लिए मानक के रूप में Convention Plugins की अनुशंसा करता है, जो subprojects { } और apply from को बदलता है। Convention Plugins पर स्विच करने से मॉड्यूल का build.gradle 10-15 लाइनों तक कम हो जाता है।

// build-logic/src/main/kotlin/AndroidLibraryConventionPlugin.kt
class AndroidLibraryConventionPlugin : Plugin<Project> {
    override fun apply(target: Project) {
        with(target) {
            with(plugins) {
                apply("com.android.library")
                apply("org.jetbrains.kotlin.android")
            }
            extensions.configure<CommonExtension<*, *, *, *>> {
                compileSdk = 35
                defaultConfig { minSdk = 26 }
                compileOptions {
                    sourceCompatibility = JavaVersion.VERSION_17
                    targetCompatibility = JavaVersion.VERSION_17
                }
            }
        }
    }
}

// module/build.gradle.kts — Convention Plugin के बाद
plugins {
    id("myapp.android.library")
}

dependencies {
    implementation(project(":core:network"))
}