Gradle KTS — bu nima, Gradle uchun Kotlin DSL va sintaksis

Gradle KTS nima?

Gradle KTS — bu Gradle konfiguratsiya fayllarini yozish uchun Groovy ga alternativani taqdim etuvchi Kotlin DSL (Domain Specific Language). Groovy sintaksisi o'rniga ishlab chiquvchilar Kotlin dan — konfiguratsiyaning to'g'riligini kompilyatsiya bosqichida tekshiradigan qattiq tipli tildan foydalanadilar. KTS birinchi marta 2018 yilda Gradle 5.0 da eksperimental funksiya sifatida taqdim etilgan va Gradle 6.0 da barqarorlikka erishgan.

KTS ning asosiy maqsadi build-skriptlardagi Groovy ning kamchiliklarini bartaraf etishdir. Groovy — dinamik tipli til bo'lib, unda konfiguratsiya xatolari faqat vazifani bajarish vaqtida runtime da namoyon bo'ladi. KTS Kotlin ning statik tiplashtirishi tufayli bir xil xatolarni kodni tahrirlash bosqichida aniqlash imkonini beradi. Qo'shimcha ravishda, KTS tiplarning to'liq hujjatlari bilan Gradle API-ga kirishni ta'minlaydi, bu murakkab konfiguratsiya bloklarini o'rganish va ishlatishni sezilarli darajada osonlashtiradi.

KTS ekotizimi barcha asosiy vositalar tomonidan qo'llab-quvvatlanadi: Android Studio, IntelliJ IDEA, Kotlin plaginli VS Code va Gradle Build Tool. Barcha zamonaviy plaginlar (Android Gradle Plugin, Kotlin Multiplatform, Protobuf, Compose) aniq tiplar bilan Kotlin-dostona API ni taqdim etadi, bu KTS ni yangi loyihalar uchun afzal tanlovga aylantiradi.

Gradle KTS qanday ishlaydi

Gradle KTS .gradle.kts fayllarini qayta ishlash uchun Kotlin kompilyatoridan foydalanadi. Gradle kengaytmani taniydi va skriptlarni qayta ishlash uchun Kotlin skript mexanizmiga uzatadi, u ularni sinflarga kompilyatsiya qiladi. Bu sinflar keyinchalik loyiha modelini qurish uchun Gradle tomonidan bajariladi. Groovy dan asosiy farq: KTS skriptlari oldindan kompilyatsiya qilinadi, dinamik talqin qilinmaydi, bu vazifalarni bajarish boshlanishidan oldin xatolarni aniqlash imkonini beradi.

KTS arxitekturasi kotlin-scripting ga asoslangan. Har bir .gradle.kts fayli Gradle API ning yashirin importlari bilan Kotlin skriptidir. Ishlab chiquvchi Kotlin ning har qanday konstruksiyalaridan foydalanishi mumkin: extension-funksiyalar, lambdalar, data-sinflar va hatto build-skript ichida yordamchi funksiyalarni e'lon qilishi mumkin. Gradle bloklarning tipli konfiguratsiyasi uchun extension-funksiyalar to'plamini taqdim etadi: dependencies, android, kotlin va boshqalar.

plugins {
    id("com.android.application") version "8.4.0"
    kotlin("android") version "2.0.21"
}

android {
    namespace = "com.itsectr.app"
    compileSdk = 34

    defaultConfig {
        applicationId = "com.itsectr.app"
        minSdk = 26
        targetSdk = 34
        versionCode = 1
        versionName = "1.0.0"
    }
}

dependencies {
    implementation(platform("androidx.compose:compose-bom:2024.06.00"))
    implementation("androidx.compose.ui:ui")
    implementation("androidx.core:core-ktx:1.13.1")
}

KTS da tiplarni o'zgartirish

KTS va Groovy o'rtasidagi asosiy farqlardan biri tiplar bilan ishlashdir. Groovy da barcha konfiguratsiyalar Object ni qabul qiladi, KTS da esa aniq Kotlin tiplari. Masalan, compileSdk string emas, Int ni qabul qiladi. Bu noto'g'ri tip bilan bog'liq xatolarni istisno qiladi: Groovy da compileSdk 34 va compileSdk “34” bir xil ishlaydi, KTS da faqat birinchi variant. Bunday qat'iylik konfiguratsiyani oldindan bashorat qilish mumkin va hujjatlashtirilgan qiladi.

Gradle KTS vs Groovy: taqqoslash

Groovy Gradle uchun original DSL edi va to'liq qo'llab-quvvatlanmoqda. Biroq, KTS uni yangi loyihalar uchun tavsiya etiladigan qiladigan bir qator afzalliklarni taklif etadi. Statik tiplashtirish, IDE da yaxshiroq tahrirlash samaradorligi va qat'iyroq sintaksis — KTS ga o'tishning asosiy sabablari. Shu bilan birga, Groovy oddiy konfiguratsiyalar uchun ixchamlik afzalligini saqlab qoladi.

KTS va Groovy da qurish samaradorligi skriptlarning kompilyatsiyasidan keyin deyarli bir xil. KTS skriptlari birinchi ishga tushirishda yoki keshni tozalashdan keyin uzoqroq kompilyatsiya qilinadi, ammo keyingi qurishlar Groovy skriptlari bilan bir xil tezlikda ishlaydi. Gradle kompilyatsiya qilingan KTS skriptlarini build katalogida keshlaydi, shuning uchun qayta kompilyatsiya faqat skript o'zgarganda sodir bo'ladi.

2026 yilda KTS va Groovy o'rtasida tanlov aniq: yangi loyihalar uchun — KTS. Google, JetBrains va Gradle barcha yangi loyihalar uchun KTS ni tavsiya qiladi. Groovy, konfiguratsiyalar hajmi yoki KTS bilan mos kelmaydigan o'ziga xos plaginlar tufayli migratsiya maqsadga muvofiq bo'lmagan eski loyihalarni qo'llab-quvvatlash uchun dolzarb bo'lib qolmoqda.

Kod misollari: KTS da build-skriptlar

Android, Kotlin Multiplatform va Compose Multiplatform uchun KTS dagi odatiy konfiguratsiya bloklarini ko'rib chiqamiz. Android loyihasi KTS bilan buildTypes va productFlavors konfiguratsiyasida tiplarni aniq ko'rsatishni talab qiladi. Quyidagi misol ikkita flavour'li ilova konfiguratsiyasini ko'rsatadi.

android {
    buildTypes {
        val release = getByName("release") {
            isMinifyEnabled = true
            proguardFiles(
                getDefaultProguardFile("proguard-android-optimize.txt"),
                "proguard-rules.pro"
            )
        }
        getByName("debug") {
            applicationIdSuffix = ".debug"
        }
    }

    flavorDimensions += "version"
    productFlavors {
        register("demo") {
            dimension = "version"
            versionNameSuffix = "-demo"
        }
        register("full") {
            dimension = "version"
        }
    }
}

Kotlin Multiplatform uchun KTS majburiy — Groovy ko'p platformali modullar konfiguratsiyasini to'g'ri qo'llab-quvvatlamaydi. KMM modulining konfiguratsiyasi maqsadli platformalar va source set'larni sozlashni o'z ichiga oladi. Quyidagi misol iOS va Android bilan shared modulining konfiguratsiyasini ko'rsatadi.

kotlin {
    androidTarget {
        compilations.all {
            kotlinOptions {
                jvmTarget = "17"
            }
        }
    }

    listOf(
        iosX64(),
        iosArm64(),
        iosSimulatorArm64()
    ).forEach { iosTarget ->
        iosTarget.binaries.framework {
            baseName = "Shared"
            isStatic = true
        }
    }

    sourceSets {
        commonMain.dependencies {
            implementation("org.jetbrains.kotlinx:kotlinx-coroutines-core:1.9.0")
        }
        androidMain.dependencies {
            implementation("org.jetbrains.kotlinx:kotlinx-coroutines-android:1.9.0")
        }
    }
}

Yordamchi funksiyalar va maxsus vazifalar

KTS build-skript ichida yordamchi Kotlin funksiyalarini e'lon qilish imkonini beradi. Bu signing configs yoki versiya boshqaruvi kabi takrorlanuvchi konfiguratsiyalar uchun ayniqsa qulaydir. Statik tiplashtirish tufayli bunday funksiyalarni kompilyatsiya bosqichida parametrlarni tekshirish bilan chaqirish mumkin, bu Google Play da nashr qilishdan oldin signing konfiguratsiyalaridagi xatolarni istisno qiladi.

fun Project.configureSigning() {
    android {
        signingConfigs {
            register("release") {
                storeFile = file("release.keystore")
                storePassword = System.getenv("KEYSTORE_PASSWORD")
                keyAlias = System.getenv("KEY_ALIAS")
                keyPassword = System.getenv("KEY_PASSWORD")
            }
        }
    }
}

// build.gradle.kts da foydalanish
configureSigning()

Groovy dan KTS ga migratsiya

Migratsiya Groovy dan KTS ga — bosqichma-bosqich amalga oshirilishi mumkin bo'lgan jarayondir. Gradle aralash loyihalarni qo'llab-quvvatlaydi, bunda modullarning bir qismi Groovy (build.gradle), bir qismi esa KTS (build.gradle.kts) dan foydalanadi. settings.gradle va root build.gradle birinchi bo'lib o'zgartirilishi mumkin, chunki ular modul plaginlariga bog'liq emas. Google migratsiyani settings.gradle.kts, keyin ildiz build.gradle.kts va faqat keyin modullar bilan boshlashni tavsiya qiladi.

Migratsiyaning asosiy bosqichlari: closures sintaksisini lambdalar bilan almashtirish, belgilash uchun = belgilarini qo'shish, string kalitlarni tipli konstantalar bilan almashtirish va o'zgaruvchilarni aniq tiplashtirish. Android Studio oddiy bloklar uchun avtomatik Groovy → KTS konvertatsiyasini ta'minlaydi, ammo ichki closures bilan murakkab konfiguratsiyalar qo'lda qayta yozishni talab qiladi.

Migratsiyadagi odatiy muammolar Kotlin ekvivalentiga ega bo'lmagan Groovy metodlarining yashirin chaqiruvlari va Kotlin-dostona API ni ta'minlamaydigan plaginlarni o'z ichiga oladi. Birinchi muammoni hal qilish uchun Gradle withGroovyBuilder orqali moslikni ta'minlaydi — KTS dan Groovy metodlarini chaqirish imkonini beruvchi mexanizm. Ikkinchisi uchun — plagin yangilanishini kutish yoki to'liq migratsiyagacha uni Groovy modulida ishlatish kerak.

Kotlin Multiplatform uchun Gradle KTS

Kotlin Multiplatform — KTS majburiy talab bo'lgan asosiy loyihadir. kotlin multiplatform plagini maqsadli platformalar, source set'lar va framework binar fayllarini konfiguratsiya qilish uchun faqat Kotlin DSL orqali mavjud bo'lgan kengaytmalarni taqdim etadi. Groovy ko'p platformali konfiguratsiyani to'g'ri qo'llab-quvvatlamaydi, shuning uchun KMM loyihalari faqat KTS dan foydalanadi.

KTS da KMM konfiguratsiyasi nostandart bloklarni o'z ichiga oladi: platformalarni ko'rsatish uchun kotlin.target, umumiy va platforma kodini tashkil qilish uchun kotlin.sourceSets, CocoaPods bilan integratsiya uchun kotlin.cocoapods va JDK tanlash uchun kotlin.jvmToolchain. Har bir blok Android Studio da avtomatik to'ldirish bilan qat'iy tipli API ga ega, bu bir nechta platformali murakkab KMM loyihasining konfiguratsiyasi uchun ayniqsa qimmatlidir.

kotlin {
    iosArm64()
    iosSimulatorArm64()
    iosX64()

    cocoapods {
        summary = "Shared Kotlin module"
        homepage = "https://itsectr.com"
        framework {
            baseName = "Shared"
            isStatic = false
        }
        pod("Alamofire") {
            version = "5.9"
        }
    }
}

KTS ning statik tiplashtirishi tufayli KMM ishlab chiquvchilari source set'lar va bog'liqliklar uchun avtomatik to'ldirish, framework konfiguratsiyasining tip tekshiruvi va platforma nomlarini refaktoring qilish imkoniyatiga ega bo'ladilar. KTS shuningdek disk raskadrovkani osonlashtiradi: KMM konfiguratsiyasidagi xatolar, xatolar Gradle vazifasi bajarilgunga qadar yashirin bo'lishi mumkin bo'lgan Groovy dan farqli o'laroq, tushunarli xabarlar bilan Kotlin kompilyatsiya xatolari sifatida ko'rsatiladi.