build.gradle: bu nima, sintaksisi va Android-da konfiguratsiyasi

build.gradle nima?

build.gradle — Android ilovasining kompilyatsiyasining barcha jihatlarini boshqaradigan Groovy (.gradle kengaytmasi) yoki Kotlin (.gradle.kts) tilidagi qurilish skriptidir. Gradle — 2013-yilda Google tomonidan Android uchun standart sifatida qabul qilingan avtomatik qurilish tizimidir. build.gradle quyidagilarni tavsiflaydi: qaysi plaginlar qo'llanilgan (Android, Kotlin, kutubxonalar), qaysi bog'liqliklar ulangan, qaysi SDK versiyalari ishlatiladi, ilovani qanday imzolash va qayerda nashr etish.

Qurilish jarayoni uch fazani o'z ichiga oladi: Initialization (modullarni aniqlash), Configuration (build.gradle skriptlarini bajarish), Execution (vazifalarni bajarish). build.gradle Konfiguratsiya fazasida bajariladi, bunda Gradle vazifalar grafigini yaratadi. Shu nuqtada Build Variant-lar aniqlanadi, bog'liqliklar hisoblanadi va vazifalar sozlanadi. Muhim: build.gradle — bu shunchaki konfiguratsiya emas, balki kod. Unda shartlar, sikllar, metod chaqiruvlari va tashqi skriptlardan foydalanish mumkin.

Gradle fayllari modulning ildizida (app/build.gradle) va loyihaning ildizida (build.gradle) saqlanadi. Bundan tashqari, Gradle apply from — tashqi Gradle skriptlarini ulashni qo'llab-quvvatlaydi. Bu takrorlanuvchi mantiqni umumiy sozlamalar bilan fayllarga chiqarish imkonini beradi. Convention Plugins (AGP 7+) paydo bo'lishi bilan apply from eskirgan hisoblanadi — Convention Plugins modullar o'rtasida konfiguratsiyani qayta ishlatishning type-safe va kompozit usulini ta'minlaydi.

build.gradle evolyutsiyasi

2013-yildan boshlab build.gradle sintaksisi sezilarli o'zgarishlarga uchradi: dinamik konfiguratsiyali Groovy-dan compile-time tekshiruvli Kotlin DSL-gacha. AGP 1.0 versiyasidan 8.7 (2025) gacha rivojlandi. Asosiy bosqichlar: AGP 3.0 (Java 8 desugar, new variant API), AGP 4.0 (view binding, Java 11), AGP 7.0 (standart sifatida Kotlin DSL, Java 11 min), AGP 8.0 (non-transitive R classes, Kotlin-da qurilish konfiguratsiyasi), AGP 8.7 (kapt o'rniga KSP, tezkor konfiguratsiya).

Project-level va Module-level build.gradle

Project-level build.gradle (ildiz) barcha modullar uchun umumiy bo'lgan plaginlar, omborlar va konfiguratsiyalarni belgilaydi. Asosiy bloklar: plugins (Gradle plaginlarini ulash), repositories (bog'liqlik manbalari: mavenCentral, google, jitpack). Ildiz build.gradle-da odatda android bloki bo'lmaydi — u modullarda paydo bo'ladi. Project-level shuningdek, barcha kichik loyihalarning umumiy konfiguratsiyasi uchun subprojects blokini o'z ichiga olishi mumkin, garchi Convention Plugins afzalroq bo'lsa ham.

Module-level build.gradle (masalan, app/build.gradle) aniq modulni tavsiflaydi. Agar modul ilova bo'lsa, com.android.application plaginini qo'llaydi. Agar kutubxona bo'lsa — com.android.library. Module-level-da joylashgan: android bloki (compileSdk, defaultConfig, buildTypes, productFlavors), dependencies bloki (modul bog'liqliklari) va test va qurilishni sozlash uchun ixtiyoriy bloklar. Module-level project-level-dan keyin bajariladi va umumiy sozlamalarni bekor qilishi mumkin.

AGP 8.0 dan boshlab, ildiz build.gradle bog'liqlik versiyalarini markazlashtirilgan boshqarish uchun version catalogs (libs.versions.toml) dan foydalanishi mumkin. Version catalog — gradle/ katalogida versiyalar, kutubxonalar va plaginlarni o'z ichiga olgan fayl. build.gradle da bog'liqliklar libs orqali ulanadi: implementation(libs.retrofit). Version catalogs yangi loyihalar uchun majburiy va uch yoki undan ortiq modulli barcha loyihalar uchun tavsiya etiladi.

// settings.gradle.kts — loyiha ildizi
pluginManagement {
    repositories {
        google()
        mavenCentral()
        gradlePluginPortal()
    }
}

// build.gradle.kts (loyiha darajasi)
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 (modul darajasi)
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 — Gradle-ning asl sintaksisi bo'lgan dinamik JVM tilidir. Groovy skriptlari (.gradle) dinamik tiplashdan foydalanadi: turlarni ko'rsatmaslik, qo'shtirnoqlardan foydalanish yoki foydalanmaslik, kompilyatsiya bosqichida mavjud bo'lmagan metodlarni chaqirish mumkin. Groovy-ning moslashuvchanligi uning kamchiligi hamdir: IDE skriptni bajarishdan oldin sintaksis va turlarni tekshira olmaydi, bu noto'g'ri parametr nomi yoki turi bilan runtime xatolariga olib keladi.

Kotlin DSL (.gradle.kts) Kotlin-ning statik tiplashidan foydalanadi. IDE turlarni tekshiradi, avtomatik to'ldirish orqali mavjud parametrlarni taklif qiladi va tahrirlash bosqichida xatolarni ko'rsatadi. Kotlin DSL Konfiguratsiya fazasida sekinroq (.kts fayllarini bayt kodiga kompilyatsiya qilish tufayli), lekin Google doimiy ravishda ish faoliyatini yaxshilaydi: AGP 8.5+ Gradle Configuration Cache va Caching Kotlin DSL compilation dan foydalanadi, bu farqni 1-2 soniyagacha kamaytiradi.

Google barcha yangi loyihalar uchun Kotlin DSL ni va mavjud loyihalarni bosqichma-bosqich migratsiya qilishni tavsiya qiladi. Groovy-dan Kotlin DSL-ga migratsiya oddiy: qo'shtirnoqlar qavslar bilan almashtiriladi, turlar qo'shiladi, operatorlar funksiyalarga aylantiriladi. Aksariyat kutubxonalar hujjatlarda Kotlin DSL misollarini taqdim etadi. Murakkab holatlar uchun (Custom Plugin, Task Graph) Kotlin DSL type-safe API ni ta'minlaydi va Groovy-da faqat runtime-da aniqlanadigan xatolarning oldini oladi. Version catalogs (libs.versions.toml) ikkala sintaksis bilan bir xil ishlaydi.

Android bloki: ilovani sozlash

compileSdk, minSdk va targetSdk

Android bloki — module-level build.gradle-ning markaziy elementi. Uning ichida sozlanadi: namespace (R va BuildConfig uchun), compileSdk, defaultConfig, buildTypes, productFlavors, sourceSets, compileOptions, packaging, bundle. Android blokining barcha parametrlari faqat Android modullariga qo'llaniladi. Agar modul kutubxona bo'lsa, ilova o'rniga kutubxona plaginidan foydalaniladi va android blokida applicationId bo'lmaydi.

compileSdk — kod kompilyatsiya qilinadigan SDK versiyasi. Eng so'nggi Android API-ga teng bo'lishi kerak (yozish vaqtida — 35). minSdk — qo'llab-quvvatlash uchun minimal API versiyasi. targetSdk — ilova yo'naltirilgan versiya (bu versiyaning xatti-harakat o'zgarishlari qo'llaniladi). compileSdk va targetSdk o'rtasidagi farq: compileSdk mavjud API-larni, targetSdk runtime xatti-harakatini belgilaydi. Tavsiya: compileSdk = eng so'nggi, targetSdk = eng so'nggi - 1 (yangi o'zgarishlarga moslashishni sinash uchun).

compileOptions Java muvofiqligini belgilaydi: sourceCompatibility va targetCompatibility. AGP 8+ kompilyatsiya uchun Java 17+ talab qiladi. packaging kutubxonalardan fayllarni kiritishni boshqaradi: META-INF mojarolarini hal qilish uchun exclude, merge, pickFirst. buildFeatures ViewBinding, DataBinding, Compose-ni yoqadi/o'chiradi. aaptOptions resurslarni qayta ishlashni sozlaydi: ignoreAssetsPattern, cruncherEnabled. Android blokining har bir elementi qurilishning ma'lum bir jihatini optimallashtiradi.

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

Bog'liqliklarni boshqarish

BOM (Bill of Materials)

Bog'liqliklar build.gradle da loyihaga ulanadigan kutubxonalar va modullardir. dependencies bloki android bloki bilan bir xil darajada joylashgan. Gradle bir nechta konfiguratsiyalarni qo'llab-quvvatlaydi: implementation (kutubxona ushbu modulda mavjud, tranzitiv emas), api (kutubxona bog'liq modullar uchun tranzitiv mavjud), compileOnly (faqat kompilyatsiya uchun, APK-ga kiritilmaydi), runtimeOnly (faqat runtime-da), annotationProcessor / ksp (annotatsiya ishlovchilari), testImplementation (faqat testlar uchun), androidTestImplementation (faqat instrumental testlar uchun).

AGP 8.0 dan boshlab, Non-Transitive R classes — har bir kutubxona o'zining R klassiga ega, bu resurs mojarolarining oldini oladi. dependencies blokida to'g'ri konfiguratsiyalardan foydalanish muhim: implementation tranzitiv bog'liqliklarni oshkor qilmaydi, bu qurilishni tezlashtiradi. api oshkor qiladi — kutubxona boshqa kutubxonadan turlarni eksport qilganda ishlatiladi (masalan, Retrofit o'zining public API-sida OkHttp turlaridan foydalanadi).

Versiyalarni boshqarish uchun BOM (Bill of Materials) — kutubxonalarning mos versiyalarini belgilaydigan qurilish faylidan foydalanish tavsiya etiladi. Firebase BOM: implementation(platform("com.google.firebase:firebase-bom:33.0.0")). BOM ulangandan so'ng, faqat kutubxona nomini versiyasiz ko'rsatish mumkin — BOM avtomatik ravishda mos versiyani tanlaydi. Bu turli kutubxonalarning tranzitiv bog'liqliklari o'rtasidagi mojarolarni bartaraf qiladi. BOM Firebase, Compose, Kotlin, Ktor, AndroidX uchun mavjud.

dependencies {
    // BOM — versiya boshqaruvi
    implementation(platform("androidx.compose:compose-bom:2024.12.01"))
    implementation(platform("com.google.firebase:firebase-bom:33.0.0"))

    // AndroidX va 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 versiyalari)
    implementation("com.google.firebase:firebase-firestore")
    implementation("com.google.firebase:firebase-crashlytics")

    // Test
    testImplementation("junit:junit:4.13.2")
    androidTestImplementation("androidx.test.ext:junit:1.2.1")
}

Ko'p modulli loyihalarda build.gradle

Ko'p modulli loyihalarda har bir modul o'zining build.gradle fayliga ega. Bir modulni boshqasiga ulash uchun implementation(project(":module-name")) sintaksisidan foydalaniladi. Gradle konfiguratsiyasi o'zgarganda modulni avtomatik ravishda quradi. Ko'p modulli arxitektura qurilish vaqtini yaxshilaydi (inkremental qurilish, parallellik) va mas'uliyatni funksional modullar, core modullar va kutubxonalar o'rtasida taqsimlaydi.

Ko'p modulli loyihalarning asosiy muammosi — konfiguratsiyaning takrorlanishi. Agar 10 modul bir xil minSdk, compileSdk va Compose bog'liqliklariga ega bo'lsa, bu turli build.gradle fayllarida 10 nusxadir. Yechim — Convention Plugins (ilgari buildSrc). Convention Plugin — Kotlin tilida yozilgan, modullarga qo'llaniladigan Gradle plaginidir: plugins { id("myapp.android.library") }. Plugin umumiy konfiguratsiyani o'z ichiga oladi va o'zgarishlar darhol barcha modullarga qo'llaniladi.

Convention Plugins-ni tashkil qilish uchun loyihaning ildizida build-logic/ katalogidan foydalaniladi. U settings.gradle da includeBuild va Kotlin plaginlarini o'z ichiga oladi. Convention Plugins loyihalar o'rtasida qayta foydalanish uchun maven omborida nashr etilishi mumkin. Google Convention Plugins-ni subprojects { } va apply from o'rnini bosuvchi ko'p modulli loyihalar uchun standart sifatida tavsiya qiladi. Convention Plugins-ga o'tish modulning build.gradle faylini 10-15 qatorgacha qisqartiradi.

// 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-dan keyin
plugins {
    id("myapp.android.library")
}

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