CodeBlanks Logo Icon CodeBlanks
Login Register

Gradle

Learn build configuration with Gradle.

Gradle: Build tool

Gradle is the build tool that manages dependencies, compilation and tests in Kotlin projects. Settings are written in the build.gradle.kts file using the Kotlin DSL. The file has plugins, dependencies and repositories blocks.

plugins {
    kotlin("jvm")
}

dependencies {
    implementation("org.jetbrains.kotlinx:kotlinx-coroutines-core:1.8.0")
}

Here the JVM plugin and the kotlinx.coroutines dependency are added. The repositories block states where dependencies are downloaded from (usually Maven Central). Gradle reads this file, downloads dependencies and compiles the project. From the command line ./gradlew build runs the whole build.

The build.gradle.kts structure

The build.gradle.kts file describes the structure of the project. At the top the plugins block lists plugins (for example kotlin("jvm")). Then repositories specifies dependency sources, and dependencies lists the libraries used. implementation means the dependency is used at compile time and runtime.

repositories {
    mavenCentral()
}

dependencies {
    implementation(kotlin("test"))
}

Here the Maven Central repository and the Kotlin test library are added. Besides implementation there are testImplementation (only in tests) and api (exposed to users of this module). Choosing the right scope affects build time and visibility.

Practice Write a buildFile function

Define fun buildFile(): String. Its body returns "plugins { kotlin(\"jvm\") }\ndependencies { implementation(\"kotlinx-coroutines-core\") }" (use \n to separate two lines inside the string). In main print the output with println(buildFile()).

Starter code

Main.kt
// buildFile function: return a string containing plugins and dependencies blocks
// main: print buildFile() with println
fun main() {
    // write here
}

Sample solution

Main.kt
fun buildFile(): String {
    return "plugins { kotlin(\"jvm\") }\ndependencies { implementation(\"kotlinx-coroutines-core\") }"
}

fun main() {
    println(buildFile())
}

Expected output

plugins { kotlin("jvm") }
dependencies { implementation("kotlinx-coroutines-core") }

Questions and answers

Review the lesson questions together with their answers. To test yourself, solve the lesson interactively.

1 Match the Gradle blocks

Term Meaning
plugins Plugins
dependencies Libraries
repositories Download sources
build.gradle.kts Build file

2 The dependency block

Question 
____ {
    implementation("kotlinx-coroutines-core")
}
Answer 
dependencies {
    implementation("kotlinx-coroutines-core")
}

Explanation: The dependencies block lists libraries.

3 In build.gradle.kts, where do you add libraries?

  • The plugins block
  • The dependencies block Correct answer
  • The tasks block
  • The repositories block

Explanation: The dependencies block adds libraries with implementation.

All lessons in Intermediate

1 Classes in depth

  1. Primary constructor
  2. Secondary constructor
  3. Properties
  4. lateinit and lazy
  5. companion object
  6. Summary - Classes

2 Inheritance

  1. open
  2. override
  3. super
  4. abstract
  5. interface
  6. Summary - Inheritance

3 Data class

  1. data class
  2. copy
  3. equals and hashCode
  4. toString
  5. Destructuring
  6. Summary - Data class

4 Project: Helper library

  1. Module design
  2. String helpers
  3. Number helpers
  4. Date helpers
  5. Putting it together

5 Sealed class

  1. sealed class
  2. when with sealed
  3. Sealed and data
  4. Sealed and state
  5. Sealed and result
  6. Summary - Sealed class

6 Object declaration

  1. object
  2. companion object
  3. Object expression
  4. companion and interface
  5. object vs class
  6. Summary - Object declaration

7 Extension functions

  1. Extension functions
  2. Extension properties
  3. Nullable extensions
  4. companion extensions
  5. Standard library
  6. Summary - Extension functions

8 Project: Quiz app

  1. Quiz model
  2. Adding questions
  3. Running the quiz
  4. Score calculation
  5. Putting it together

9 Generics

  1. Generic class
  2. Generic functions
  3. Variance
  4. Type constraints
  5. Reified
  6. Summary - Generics

10 Higher-order functions

  1. Function types
  2. Lambda
  3. it
  4. inline
  5. Scope functions
  6. Summary - Higher-order functions

11 Project: Library app

  1. Model design
  2. Library class
  3. Checking out
  4. Search and filter
  5. Putting it together

12 Advanced collections

  1. map and filter
  2. fold and reduce
  3. groupBy and partition
  4. sortedBy and sortedWith
  5. associate and flatMap
  6. Summary - Advanced collections

13 Delegation

  1. by
  2. Delegated properties
  3. by map
  4. vetoable
  5. Custom delegates
  6. Summary - Delegation

14 Value class

  1. value class
  2. Type safety
  3. Methods
  4. Generic value class
  5. value class vs data class
  6. Summary - Value class

15 Coroutine basics

  1. What are coroutines?
  2. launch
  3. suspend
  4. runBlocking
  5. async/await
  6. Summary - Coroutine basics

16 Flow basics

  1. Flow
  2. flow builder
  3. collect
  4. map and filter
  5. flowOn
  6. Summary - Flow basics

17 File I/O

  1. File
  2. readText
  3. writeText
  4. readLines
  5. appendText
  6. Summary - File I/O

18 Packages and modules

  1. package
  2. import
  3. internal
  4. Gradle
  5. kotlinx
  6. Summary - Packages

19 Testing

  1. JUnit
  2. @Test
  3. Assertions
  4. @BeforeEach
  5. MockK
  6. Summary - Testing

20 Intermediate final

  1. Project design
  2. OOP model
  3. Collections
  4. File I/O
  5. Putting it together