Network Calls with Kotlin Coroutines

Most of the apps we use on our phones fetch data that is hosted online on a server. As such, we developers have to understand how to request and send data to the servers too. In this chapter, we will learn how to send and request data that is hosted online and display it in our apps.

In this chapter, we will learn how to perform network calls with a networking library, Retrofit. We will learn how to consume application programming interfaces (APIs) using this library. Moreso, we will learn how to take advantage of Kotlin coroutines to perform asynchronous network requests in our app.

In this chapter, we’re going to cover the following main topics:

• Setting up Retrofit
• Introduction to Kotlin coroutines
• Using Kotlin coroutines for network calls

Technical requirements

To follow the instructions in this chapter, you will need to have Android Studio Hedgehog or later (https://developer.android.com/studio) downloaded.

You can find the code for this chapter at https://github.com/PacktPublishing/Mastering-Kotlin-for-Android/tree/main/chaptersix.

Setting up Retrofit

Retrofit is a type-safe REST client for Android, Java, and Kotlin developed by Square. The library provides a powerful framework for authenticating and interacting with APIs and sending network requests with OkHttp. In this book, we will be using Retrofit to perform our network requests.

To begin with, we will add the Retrofit dependencies using our newly created version catalog. Let’s define the versions in the libs.versions.toml file as follows:

retrofit = "2.9.0"
retrofitSerializationConverter = "1.0.0"
serializationJson = "1.5.1"
coroutines = "1.7.3"
okhttp3 = "4.11.0"

Next, let’s define the libraries in the libs.versions.toml file in the libraries section of our versions catalog as follows:

retrofit = { module = "com.squareup.retrofit2:retrofit" , version.ref = "retrofit" }
retrofit-serialization = { module = "com.jakewharton.retrofit:retrofit2-kotlinx-serialization...

Introduction to Kotlin coroutines

Coroutines, introduced by JetBrains for Kotlin, provide a way to write asynchronous code in a more readable and synchronous manner. We can use them to perform background tasks and they are a great way to perform network requests and long-running tasks such as reading and writing to a database. They do these tasks off the main thread and ensure that we don’t block our main thread while performing these operations. The main benefits of using coroutines are as follows:

• They are lightweight and easy to use.
• They have built-in cancellation support.
• They lower the chances of apps having memory leaks.
• As mentioned in earlier chapters, Jetpack libraries also support and use coroutines.

We have already added the core and Android coroutines libraries in our app. Let us understand some coroutines basics before proceeding to use coroutines in our project.

Coroutine basics

In this section, we will be looking at different...

Using Kotlin coroutines for network calls

In this section, we will refactor our repository to use coroutines. We will use StateFlow to emit data from ViewModel to the view layer. We will also use the Dispatchers.IO dispatcher to perform our network requests on a background thread.

Let us start by creating a NetworkResult sealed class, which will represent the different states of our network request:

sealed class NetworkResult<out T> {
    data class Success<out T>(val data: T) : NetworkResult<T>()
    data class Error(val error: String) : NetworkResult<Nothing>()
}

The NetworkResult class is a sealed class that has two subclasses. We have the Success data class that will be used to represent a successful network request. It has a data property that will be used to hold the data returned from the network request. We also have the Error class, which will be used to represent a failed network request. It has an error...

Summary

In this chapter, we learned how to perform network calls with Retrofit. Moreso, we learned how to take advantage of Kotlin coroutines to perform asynchronous network requests in our app and refactored our app to fetch some cute cats with Kotlin coroutines.

In the next chapter, we will be looking at another Jetpack library, Jetpack Navigation, to handle navigation in our app.