Understanding the settings.gradle.kts and build.gradle.kts Files in an Android Project

• When working on Android app development, especially with Kotlin DSL (Domain-Specific Language), you'll often encounter two key files: settings.gradle.kts and build.gradle.kts. These files are the backbone of your Android project, helping you manage plugins, dependencies, and build configurations. This blog will explain the role of each file and how the code inside these files helps build your Android app.

What is settings.gradle.kts?

The settings.gradle.kts file sets up the structure of your project, including the modules it contains and where Gradle should look for plugins and libraries.

pluginManagement {
    repositories {
        google {
            content {
                includeGroupByRegex("com\\.android.*")
                includeGroupByRegex("com\\.google.*")
                includeGroupByRegex("androidx.*")
            }
        }
        mavenCentral()
        gradlePluginPortal()
    }
}
dependencyResolutionManagement {
    repositoriesMode.set(RepositoriesMode.FAIL_ON_PROJECT_REPOS)
    repositories {
        google()
        mavenCentral()
    }
}

rootProject.name = "exampleapp"
include(":app")        

Line-by-line explanation:

• pluginManagement:

This block specifies where Gradle should look for plugins that are used in the project. Think of it as telling Gradle, "Here’s where to find the tools you need to build my app."

• repositories:

1. Inside pluginManagement, this block lists the sources for these plugins.
2. google(): Refers to Google’s repository, which contains Android SDK and other Google libraries.
3. mavenCentral(): A central repository for many open-source libraries.
4. gradlePluginPortal(): The default Gradle plugin repository.

• includeGroupByRegex:

This tells Gradle to include plugins that match a specific pattern. For instance, com.android.* will include all Android SDK-related plugins, com.google.* includes Google-related plugins, and androidx.* includes AndroidX libraries.

• dependencyResolutionManagement:

This block defines how dependencies (libraries) are resolved across the entire project.

repositoriesMode.set(RepositoriesMode.FAIL_ON_PROJECT_REPOS): This means that all repositories are declared at the global level. No module should declare its own repositories.

• rootProject.name = "exampleapp":

This sets the name of your main project. In this case, it’s "exampleapp".

• include("app"):

This line includes the app module. In most Android projects, this module contains all the code for your application.

Explanation of build.gradle.kts (Project-Level Build Script)

The build.gradle.kts file in the project-level configuration defines configurations and plugins that are common to all modules in the project.

Breakdown of project-level build.gradle.kts:

• plugins { ... }: This block specifies plugins used at the project level.

alias(libs.plugins.android.application) apply false: Refers to the Android application plugin but doesn’t apply it at the project level. It's applied at the module level.

alias(libs.plugins.kotlin.android) apply false: Refers to the Kotlin plugin for Android but also doesn’t apply it at the project level.

By applying false, it means that the plugin is available but won't be applied automatically at this level. It will be applied in module-level build.gradle.kts files.

Explanation of build.gradle.kts (App-Level Build Script)

This is the module-level build script for the app module. This file contains configurations specific to building the Android application.

Breakdown of app-level build.gradle.kts:

plugins { ... }:

• alias(libs.plugins.android.application): Applies the Android application plugin, which allows you to build and package your Android app.
• alias(libs.plugins.kotlin.android): Applies the Kotlin plugin for Android, enabling Kotlin support.

android { ... }: This block contains Android-specific configuration for the project.

This block contains Android-specific configuration for the project.

• namespace = "com.example.jettipapp": Defines the Android package name (namespace) of your app. It's how your app is uniquely identified on the Play Store and within Android.
• compileSdk = 34: Specifies the SDK version used to compile your app. SDK version 34 is Android 14 (API level 34).

defaultConfig { ... }:

• applicationId = "com.example.exampleapp": Specifies the unique identifier for your app when it’s installed on an Android device.
• minSdk = 30: Minimum SDK version that your app supports (Android 11, API level 30).
• targetSdk = 34: Specifies the version of Android your app is optimized for (Android 14, API level 34).
• versionCode = 1: The internal version number used for updates on the Play Store.
• versionName = "1.0": The user-facing version name of the app.
• testInstrumentationRunner: Specifies the test runner to use for Android tests.
• vectorDrawables { useSupportLibrary = true }: Enables backward compatibility for vector drawables in Android.

buildTypes { ... }: Defines different build types for the project.

• release: This block is for the release build configuration, where you specify settings like:
• isMinifyEnabled = false: Disables code shrinking and obfuscation for the release build.
• proguardFiles: Specifies ProGuard rules for optimizing and shrinking the APK

compileOptions { ... }: Configures the Java compatibility for your project.

• kotlinOptions { jvmTarget = "1.8" }: Sets the target JVM version for Kotlin code.
• buildFeatures { compose = true }: Enables Jetpack Compose for building UIs in your Android app.

composeOptions { ... }:

kotlinCompilerExtensionVersion = "1.5.1": Specifies the version of Kotlin compiler extensions used for Jetpack Compose.

packaging { resources { excludes += "/META-INF/{AL2.0,LGPL2.1}" } }: Excludes certain license files from being packaged into the APK to reduce its size.

dependencies { ... }: The dependencies block lists the libraries and modules your project depends on.