Tuesday, May 28, 2024

Gradle Tutorial for Android: Getting Began – Half 1

Must read


Replace notice: Ricardo Costeira up to date this tutorial for Android Studio 2023.1.1. Irina Galata wrote the unique.

On this tutorial, you’ll study Gradle and how one can set it up in a maintainable and scalable method. By the top of this tutorial, you’ll be capable to:

  1. Construct your Android apps from the command line.
  2. Learn each Groovy and Kotlin Gradle construct recordsdata.
  3. Handle dependencies with Gradle.
Be aware: This tutorial assumes you’re already acquainted with the fundamentals of Android improvement. In case you’re fully new to Android improvement, learn our Starting Android Improvement tutorials to familiarize your self with the fundamentals.

What’s Gradle?

Gradle is an open-source build-automation system. It has the comfort of a Groovy- or Kotlin-based DSL and the benefits of Ant and Maven. With Gradle, you’ll be able to simply manipulate the construct course of and its logic to create a number of variations of your app. It’s a lot simpler to make use of and much more concise and versatile when in comparison with Ant or Maven alone.

Getting Began

Obtain the starter venture by clicking the Obtain Supplies hyperlink on the high or backside of the tutorial.

Open the venture in Android Studio, and try its construction within the Undertaking pane in Android Studio:

Take note of the recordsdata with the Gradle elephant icon and .gradle extension. These recordsdata are generated by Android Studio mechanically throughout venture creation. They’re written in Groovy and accountable for processing your venture’s construct. They comprise the required information about venture construction, library dependencies, library variations and the app variations you’ll get on account of the construct course of.

Ranging from Android Studio Giraffe, Kotlin would be the default language for construct configuration. Gradle recordsdata written in Kotlin have the .gradle.kts extension. You possibly can see that there are already a number of within the venture, however they have been manually added. These are the Kotlin equal to the .gradle ones. Effectively, kind of — they’re pretty completely different in habits at this level, however you’ll perceive why as you progress by means of the tutorial.

Exploring the Undertaking-Stage Recordsdata

Discover the construct.gradle file within the root listing of the venture. It’s referred to as a top-level (project-level) construct.gradle file. It comprises the settings which are utilized to all modules of the venture.

Open the file, and also you’ll see the next code:


// 1
buildscript {
    // 2
    repositories {
        google()
        mavenCentral()
    }
    // 3
    dependencies {
        classpath "com.android.instruments.construct:gradle:8.2.2"
        classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:1.9.20"
    }
}
// 4
allprojects {
    repositories {
        google()
        mavenCentral()
    }
}
// 5
duties.register('clear', Delete) {
    delete rootProject.buildDir
}

Right here’s what’s occurring, step-by-step:

  1. Within the buildscript block, you outline settings wanted to construct your venture.
  2. Within the repositories block, you add names of the repositories the place Gradle ought to seek for the plugins you employ.
  3. The dependencies block comprises essential plugin dependencies — on this case the Gradle and Kotlin plugins. Don’t put your module dependencies on this block.
  4. The construction of the allprojects block is just like the buildscript block, however right here you outline repositories for your entire modules, not for Gradle itself. Normally you don’t outline the dependencies part for allprojects. The dependencies for every module are completely different and will reside within the module-level construct.gradle.
  5. A process represents a bit of labor within the construct course of. This easy one cleans up the construct recordsdata when executed. You’ll study extra about duties later on this tutorial.

Shifting on to Module-level Recordsdata

Now, go to the construct.gradle file within the app module listing. It comprises dependencies — libraries {that a} module depends on — and directions for the construct course of. Every module defines its personal construct.gradle file.


// 1
plugins {
    id "com.android.utility"
    id "kotlin-android"
}
// 2
android {
    // 3
    namespace "com.kodeco.socializify"
    // 4
    compileSdk 34
    // 5
    defaultConfig {
        // 6
        applicationId "com.kodeco.socializify"
        // 7
        minSdkVersion 23
        // 8
        targetSdkVersion 34
        // 9
        versionCode 1
        // 10
        versionName "1.0"
    }
    // 11
    buildFeatures {
        viewBinding true
    }
    // 12
    kotlin {
        jvmToolchain(17)
    }
}
// 13
dependencies {
    implementation fileTree(embody: ["*.jar"], dir: "libs")
    implementation "androidx.appcompat:appcompat:1.6.1"
    implementation "com.google.android.materials:materials:1.9.0"
}

The code above does the next:

  1. Specifies an inventory of plugins wanted to construct the module. The com.android.utility plugin is critical in an effort to arrange the Android-specific settings of the construct course of. Right here, you can even use com.android.library for those who’re making a library module. The kotlin-android plugin means that you can use the Kotlin language in your module.
  2. Within the android block, you place all platform-specific choices of the module.
  3. Defining a namespace is critical for issues like useful resource entry. This was once within the AndroidManifest.xml file underneath the bundle property, however has now migrated.
  4. The compileSdk possibility signifies the API degree your app shall be compiled with. In different phrases, you’ll be able to’t use options from an API increased than this worth. Right here, you’ve set the worth to make use of APIs from Android Tiramisu.
  5. The defaultConfig block comprises choices that shall be utilized to all construct variations (e.g., debug, launch, and many others) of your app by default.
  6. The applicationId is the identifier of your app. It needs to be distinctive in order to efficiently publish or replace your app on the Google Play Retailer. In case you go away it undefined, the construct system will use the namespace as applicationId.
  7. In an effort to set the bottom API degree supported, use minSdkVersion. Your app won’t be obtainable within the Play Retailer for the units working on decrease API ranges.
  8. Be aware: To get extra acquainted with the Android SDK variations, learn our tutorial masking that subject.
  9. The targetSdkVersion parameter defines the utmost API degree your app has been examined on. That’s to say, you’re certain your app works correctly on the units with this SDK model, and it doesn’t require any backward-compatibility habits. One of the best method is to totally take a look at an app utilizing the newest API, preserving your targetSdkVersion worth equal to compileSdk.
  10. versionCode is a numeric worth for the app model.
  11. versionName is a user-friendly string for the app model.
  12. The buildFeatures block permits you to allow sure options, like View binding or Compose. On this case, it’s doing the previous.
  13. Be aware: If you wish to study extra about View binding, try our tutorial on it.
  14. Gradle 8.2 helps JVM 17 by default, so that you drive the venture to make use of Java 17 by means of Gradle’s Java toolchain assist.
  15. The dependencies block comprises all dependencies wanted for this module. Later on this tutorial, you’ll discover out extra about managing your venture’s dependencies.
Be aware: To get extra acquainted with the Android SDK variations, learn our tutorial masking that subject.
Be aware: If you wish to study extra about View binding, try our tutorial on it.



Supply hyperlink

More articles

LEAVE A REPLY

Please enter your comment!
Please enter your name here

Latest article