Retrofit with Kotlin Coroutines
Tags: kotlin, android
Published: 2022-10-09 03:52:44

---
title: Retrofit with Kotlin Coroutines
published: true
description: In this blog, we will learn how to use Retrofit with Kotlin Coroutines.
tags: kotlin, android
cover_image: https://dev-to-uploads.s3.amazonaws.com/uploads/articles/nqv5q3mzby14gi95y7my.png
canonical_url: https://amitshekhar.me/blog/retrofit-with-kotlin-coroutines
---

I am [**Amit Shekhar**](https://amitshekhar.me), a mentor helping developers in getting high-paying tech jobs.

In this blog, we will learn how to use `Retrofit` with Kotlin `Coroutines` in Android. We will learn to write the code inside the `ViewModel` with Kotlin `Coroutines` that follows a basic MVVM Architecture.

**This article was originally published at [amitshekhar.me](https://amitshekhar.me/blog/retrofit-with-kotlin-coroutines).**

I will be using the following project for the implementation part. The project follows a basic MVVM Architecture for simplicity. You can find the complete code for the implementation mentioned in this blog in the project itself.

GitHub Project: [Learn Kotlin Coroutines](https://github.com/amitshekhariitbhu/Learn-Kotlin-Coroutines)

First, we need to set up our dependencies for the Retrofit as below:

```groovy
implementation 'com.squareup.retrofit2:retrofit:2.9.0'
implementation 'com.squareup.retrofit2:converter-gson:2.9.0'
```

Note: Always check for the latest available version.

As I am using the Gson to parse JSON into Java and Kotlin classes, I have added the dependency for the Gson. You can add based on your requirement.

Now, create the `data` class `ApiUser` as below:

```kotlin
data class ApiUser(
    @SerializedName("id")
    val id: Int = 0,
    @SerializedName("name")
    val name: String = "",
    @SerializedName("email")
    val email: String = "",
    @SerializedName("avatar")
    val avatar: String = ""
)
```

Now, we need to create the `ApiService` interface required for Retrofit.

```kotlin
interface ApiService {

    @GET("users")
    suspend fun getUsers(): List<ApiUser>

    @GET("more-users")
    suspend fun getMoreUsers(): List<ApiUser>

    @GET("error")
    suspend fun getUsersWithError(): List<ApiUser>

}
```

**Note**: We have used `suspend` keyword to support Coroutines so that we can call it from a Coroutine or another `suspend` function.

After this, we will be needing a class `RetrofitBuilder` which will be a `Singleton`.

```kotlin
object RetrofitBuilder {

    private const val BASE_URL = "https://5e510330f2c0d300147c034c.mockapi.io/"

    private fun getRetrofit(): Retrofit {
        return Retrofit.Builder()
            .baseUrl(BASE_URL)
            .addConverterFactory(GsonConverterFactory.create())
            .build()
    }

    val apiService: ApiService = getRetrofit().create(ApiService::class.java)

}
```

Then, we will create an interface `ApiHelper`.

```kotlin
interface ApiHelper {

    suspend fun getUsers(): List<ApiUser>

    suspend fun getMoreUsers(): List<ApiUser>

    suspend fun getUsersWithError(): List<ApiUser>

}
```

**Note**: Again, we have used `suspend` keyword to support Coroutines so that we can call it from a Coroutine or another `suspend` function.

After that, we will create a class `ApiHelperImpl` that implements the `ApiHelper` interface.

```kotlin
class ApiHelperImpl(private val apiService: ApiService) : ApiHelper {

    override suspend fun getUsers() = apiService.getUsers()

    override suspend fun getMoreUsers() = apiService.getMoreUsers()

    override suspend fun getUsersWithError() = apiService.getUsersWithError()

}
```

Once we've done that, we can create the instance of `ApiHelper` as below:

```kotlin
val apiHelper = ApiHelperImpl(RetrofitBuilder.apiService)
```

Finally, we can pass this instance wherever required, for example to the `ViewModel`, and make the network call to get the `users` from the network as below:

```kotlin
class SingleNetworkCallViewModel(private val apiHelper: ApiHelper, private val dbHelper: DatabaseHelper) : ViewModel() {

    init {
        fetchUsers()
    }

    private fun fetchUsers() {
        viewModelScope.launch {
            try {
                val usersFromApi = apiHelper.getUsers()
                // list of users from the network
            } catch (e: Exception) {
                // handle exception
            }
        }
    }

}
```

This way, we are able to fetch the data from the network using Retrofit with Kotlin `Coroutines` in Android.

I must mention that you can learn much more from the GitHub repository that I mentioned above in this blog. You can learn the following:

- Making network calls in series using Retrofit with Kotlin Coroutines.
- Making multiple network calls in parallel using Retrofit with Kotlin Coroutines.

This is how we can use Retrofit with Kotlin Coroutines in Android.

Master Kotlin Coroutines from here: [Mastering Kotlin Coroutines](https://amitshekhar.me/blog/kotlin-coroutines)

That's it for now.

Thanks

[**Amit Shekhar**](https://amitshekhar.me)

You can connect with me on:

- [Twitter](https://twitter.com/amitiitbhu)
- [LinkedIn](https://www.linkedin.com/in/amit-shekhar-iitbhu)
- [GitHub](https://github.com/amitshekhariitbhu)
- [Facebook](https://www.facebook.com/amit.shekhar.iitbhu)

[**Read all of my high-quality blogs here.**](https://amitshekhar.me/blog)