build.gradle: apa itu, sintaksis dan konfigurasi di Android

Apa itu build.gradle?

build.gradle adalah skrip build dalam bahasa Groovy (ekstensi .gradle) atau Kotlin (.gradle.kts) yang mengelola semua aspek kompilasi aplikasi Android. Gradle adalah sistem build otomatis yang diadopsi Google pada tahun 2013 sebagai standar untuk Android. build.gradle menjelaskan: plugin apa yang diterapkan (Android, Kotlin, pustaka), dependensi apa yang terhubung, versi SDK apa yang digunakan, cara menandatangani aplikasi, dan di mana mempublikasikannya.

Proses build mencakup tiga fase: Initialization (penentuan modul), Configuration (eksekusi skrip build.gradle), Execution (eksekusi tugas). build.gradle dieksekusi pada fase Configuration, ketika Gradle membuat grafik tugas. Pada titik ini, Build Variants ditentukan, dependensi dihitung, dan tugas dikonfigurasi. Penting: build.gradle adalah kode, bukan hanya konfigurasi. Di dalamnya dapat menggunakan kondisi, perulangan, pemanggilan metode, dan skrip eksternal.

File Gradle disimpan di root modul (app/build.gradle) dan root proyek (build.gradle). Selain itu, Gradle mendukung apply from — menghubungkan skrip Gradle eksternal. Ini memungkinkan mengekstrak logika berulang ke file dengan pengaturan bersama. Dengan munculnya Convention Plugins (AGP 7+), apply from dianggap usang — Convention Plugins menyediakan cara type-safe dan komposit untuk menggunakan kembali konfigurasi antar modul.

Evolusi build.gradle

Sejak 2013, sintaksis build.gradle telah mengalami perubahan signifikan: dari Groovy dengan konfigurasi dinamis hingga Kotlin DSL dengan pemeriksaan waktu kompilasi. AGP telah berevolusi dari versi 1.0 ke 8.7 (2025). Tonggak penting: AGP 3.0 (Java 8 desugar, new variant API), AGP 4.0 (view binding, Java 11), AGP 7.0 (Kotlin DSL default, Java 11 min), AGP 8.0 (non-transitive R classes, konfigurasi build di Kotlin), AGP 8.7 (KSP sebagai pengganti kapt, konfigurasi cepat).

Project-level dan Module-level build.gradle

Project-level build.gradle (root) menentukan plugin, repositori, dan konfigurasi yang umum untuk semua modul. Blok utama: plugins (menghubungkan plugin Gradle), repositories (sumber dependensi: mavenCentral, google, jitpack). Di root build.gradle biasanya tidak ada blok android — ia muncul di modul. Project-level juga dapat berisi blok subprojects untuk konfigurasi umum semua subproyek, meskipun Convention Plugins lebih disukai.

Module-level build.gradle (misalnya, app/build.gradle) mendeskripsikan modul tertentu. Jika modul adalah aplikasi, ia menerapkan plugin com.android.application. Jika pustaka — com.android.library. Di module-level terdapat: blok android (compileSdk, defaultConfig, buildTypes, productFlavors), blok dependencies (dependensi modul), dan blok opsional untuk konfigurasi tes dan build. Module-level dieksekusi setelah project-level dan dapat menimpa pengaturan umum.

Mulai AGP 8.0, root build.gradle dapat menggunakan version catalogs (libs.versions.toml) untuk manajemen terpusat versi dependensi. Version catalog adalah file di direktori gradle/ yang berisi versi, pustaka, dan plugin. Di build.gradle, dependensi dihubungkan melalui libs: implementation(libs.retrofit). Version catalogs wajib untuk proyek baru dan direkomendasikan untuk semua proyek dengan tiga modul atau lebih.

// settings.gradle.kts — root proyek
pluginManagement {
    repositories {
        google()
        mavenCentral()
        gradlePluginPortal()
    }
}

// build.gradle.kts (tingkat proyek)
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 (tingkat modul)
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 adalah bahasa JVM dinamis yang merupakan sintaksis asli Gradle. Skrip Groovy (.gradle) menggunakan pengetikan dinamis: tipe dapat dihilangkan, tanda kutip dapat digunakan atau tidak, metode yang tidak ada pada fase kompilasi dapat dipanggil. Fleksibilitas Groovy juga merupakan kelemahannya: IDE tidak dapat memeriksa sintaksis dan tipe sebelum eksekusi skrip, yang menyebabkan kesalahan runtime pada nama parameter atau tipe yang salah.

Kotlin DSL (.gradle.kts) menggunakan pengetikan statis Kotlin. IDE memeriksa tipe, menyarankan parameter yang tersedia melalui pelengkapan otomatis, dan menyoroti kesalahan pada fase pengeditan. Kotlin DSL lebih lambat pada fase Configuration (karena kompilasi file .kts ke bytecode), tetapi Google terus meningkatkan kinerja: AGP 8.5+ menggunakan Gradle Configuration Cache dan Caching Kotlin DSL compilation, yang mengurangi perbedaan menjadi 1-2 detik.

Google merekomendasikan Kotlin DSL untuk semua proyek baru dan migrasi bertahap proyek yang ada. Migrasi dari Groovy ke Kotlin DSL sederhana: tanda kutip diganti dengan kurung, tipe ditambahkan, operator diubah menjadi fungsi. Sebagian besar pustaka menyediakan contoh Kotlin DSL di dokumentasi. Untuk kasus kompleks (Custom Plugin, Task Graph), Kotlin DSL menyediakan API type-safe dan mencegah kesalahan yang di Groovy hanya ditemukan di runtime. Version catalogs (libs.versions.toml) bekerja sama dengan kedua sintaksis.

Blok android: konfigurasi aplikasi

compileSdk, minSdk dan targetSdk

Blok android — elemen sentral dari module-level build.gradle. Di dalamnya dikonfigurasi: namespace (untuk R dan BuildConfig), compileSdk, defaultConfig, buildTypes, productFlavors, sourceSets, compileOptions, packaging, bundle. Semua parameter blok android hanya berlaku untuk modul Android. Jika modul adalah pustaka, plugin pustaka digunakan sebagai pengganti aplikasi, dan tidak ada applicationId di blok android.

compileSdk — versi SDK tempat kode dikompilasi. Harus sama dengan Android API terbaru (pada saat penulisan — 35). minSdk — versi API minimum untuk dukungan. targetSdk — versi yang menjadi target aplikasi (perubahan perilaku versi ini diterapkan). Perbedaan antara compileSdk dan targetSdk: compileSdk menentukan API yang tersedia, targetSdk — perilaku runtime. Rekomendasi: compileSdk = latest, targetSdk = latest - 1 (untuk menguji adaptasi terhadap perubahan baru).

compileOptions mengatur kompatibilitas Java: sourceCompatibility dan targetCompatibility. AGP 8+ memerlukan Java 17+ untuk kompilasi. packaging mengelola penyertaan file dari pustaka: exclude, merge, pickFirst untuk menyelesaikan konflik META-INF. buildFeatures mengaktifkan/menonaktifkan ViewBinding, DataBinding, Compose. aaptOptions mengonfigurasi pemrosesan sumber daya: ignoreAssetsPattern, cruncherEnabled. Setiap elemen blok android mengoptimalkan aspek build tertentu.

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

Manajemen dependensi

BOM (Bill of Materials)

Dependensi di build.gradle adalah pustaka dan modul yang terhubung ke proyek. Blok dependencies berada pada tingkat yang sama dengan blok android. Gradle mendukung beberapa konfigurasi: implementation (pustaka tersedia di modul ini, tidak transitif), api (pustaka tersedia secara transitif untuk modul dependen), compileOnly (hanya untuk kompilasi, tidak disertakan dalam APK), runtimeOnly (hanya saat runtime), annotationProcessor / ksp (pemroses anotasi), testImplementation (hanya untuk tes), androidTestImplementation (hanya untuk tes instrumental).

Mulai AGP 8.0, Non-Transitive R classes — setiap pustaka memiliki kelas R sendiri, yang mencegah konflik sumber daya. Di blok dependencies, penting untuk menggunakan konfigurasi yang benar: implementation tidak mengungkapkan dependensi transitif, yang mempercepat build. api mengungkapkan — digunakan ketika pustaka mengekspor tipe dari pustaka lain (misalnya, Retrofit menggunakan tipe OkHttp di API publiknya).

Untuk manajemen versi, disarankan menggunakan BOM (Bill of Materials) — file build yang menentukan versi pustaka yang kompatibel. Firebase BOM: implementation(platform("com.google.firebase:firebase-bom:33.0.0")). Setelah menghubungkan BOM, hanya nama pustaka tanpa versi yang perlu ditentukan — BOM akan secara otomatis memilih versi yang kompatibel. Ini menghilangkan konflik antara dependensi transitif dari berbagai pustaka. BOM tersedia untuk Firebase, Compose, Kotlin, Ktor, AndroidX.

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

    // AndroidX dan 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 (versi dari BOM)
    implementation("com.google.firebase:firebase-firestore")
    implementation("com.google.firebase:firebase-crashlytics")

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

build.gradle dalam proyek multi-modul

Dalam proyek multi-modul, setiap modul memiliki build.gradle sendiri. Untuk menghubungkan satu modul ke modul lain, digunakan sintaksis implementation(project(":module-name")). Gradle secara otomatis membangun modul jika konfigurasinya berubah. Arsitektur multi-modul meningkatkan waktu build (build inkremental, paralelisme) dan membagi tanggung jawab antara modul fitur, modul inti, dan pustaka.

Masalah utama proyek multi-modul — duplikasi konfigurasi. Jika 10 modul memiliki minSdk, compileSdk, dan dependensi Compose yang sama, itu adalah 10 salinan di berbagai build.gradle. Solusinya — Convention Plugins (sebelumnya buildSrc). Convention Plugin adalah plugin Gradle yang ditulis dalam Kotlin yang diterapkan ke modul: plugins { id("myapp.android.library") }. Plugin berisi konfigurasi bersama, dan perubahan segera diterapkan ke semua modul.

Untuk mengatur Convention Plugins, digunakan direktori build-logic/ di root proyek. Ini berisi includeBuild di settings.gradle dan plugin Kotlin. Convention Plugins dapat dipublikasikan di repositori maven untuk digunakan kembali antar proyek. Google merekomendasikan Convention Plugins sebagai standar untuk proyek multi-modul, menggantikan subprojects { } dan apply from. Transisi ke Convention Plugins mengurangi build.gradle modul menjadi 10-15 baris.

// 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 — setelah Convention Plugin
plugins {
    id("myapp.android.library")
}

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