Optimize Android Gradle Build Configurations

This skill configures Android Gradle builds - modern build scripts, dependency management, build optimization, and advanced Gradle techniques, across both Groovy and Kotlin DSL, build variants, flavors, and signing configurations. Core principles: use Kotlin DSL (.gradle.kts) for type safety and IDE support, centralize dependencies with version catalogs, structure multi-module projects with clear separation, and apply plugins via the plugins {} block rather than legacy apply plugin. Build performance guidance: enable the Gradle daemon and parallel execution, use build and configuration cache, choose implementation over api dependency configurations correctly, and keep build scripts simple.

Use it when an Android project's Gradle setup needs version catalogs, product flavors, or signing configuration done correctly - not just a default single-module build.gradle.

android {
    namespace = "com.example.myapp"
    compileSdk = 34
    defaultConfig {
        applicationId = "com.example.myapp"
        minSdk = 24
        targetSdk = 34
    }
    buildTypes {
        release {
            isMinifyEnabled = true
            proguardFiles(getDefaultProguardFile("proguard-android-optimize.txt"), "proguard-rules.pro")
        }
    }
}

Project-level setup covers settings.gradle.kts with dependencyResolutionManagement and a version catalog loaded from gradle/libs.versions.toml. App-level configuration shows a full module with Compose/Hilt plugins, a release signingConfig reading credentials from environment variables, debug vs release build types (debuggable, minified, shrunk resources), environment/api flavor dimensions with per-flavor buildConfigField and resValue, Java 17 compile options, and Compose compiler options. Advanced patterns include a buildSrc object centralizing SDK version constants and a dynamic version-name function, forced dependency resolution, and variant-conditional dependencies (like adding Flipper only to debug variants). gradle.properties performance tuning covers JVM heap args, parallel/caching/configure-on-demand flags, and AndroidX/Kotlin incremental-build settings. Testing configuration wires JUnit, Mockito, and Robolectric for unit tests plus Espresso for instrumented tests, with unitTests.isReturnDefaultValues and disabled animations for stable CI runs.

Android developers setting up or modernizing a Gradle build who need concrete Kotlin DSL patterns for version catalogs, product flavors, signing, and R8 optimization - not just the default Android Studio-generated build script. Best practices tie the pieces together: never commit signing keys or passwords, use environment variables or CI/CD secrets instead, use Play App Signing for production releases, prefer implementation over compile for build performance, use api only when transitive dependencies genuinely need to be exposed, keep flavor dimension names meaningful, and test every variant combination in CI. On the performance side, enable R8 full mode for maximum code shrinking, apply ProGuard/R8 rules judiciously to avoid over-optimizing away code that's actually needed, and monitor build times regularly to catch new bottlenecks as the project grows.