Skip to main content

How to use Moshi converter with Retrofit in Kotlin Android

How to use Moshi converter with Retrofit in Kotlin Android.

Here's a step-by-step tutorial on how to use Moshi converter with Retrofit in Kotlin for Android:

Step 1: Add dependencies​

First, we need to add the necessary dependencies to our project. Open your project's build.gradle file and add the following lines in the dependencies block:

implementation 'com.squareup.retrofit2:retrofit:2.9.0'
implementation 'com.squareup.retrofit2:converter-moshi:2.9.0'

Step 2: Create a Retrofit service interface​

Next, we need to create a service interface that defines the API endpoints we want to consume. Create a new Kotlin file and name it ApiService.kt. In this file, define your service interface as follows:

interface ApiService {
    @GET("users")
    suspend fun getUsers(): List<User>
}

Here, we have defined a single API endpoint getUsers() that returns a list of User objects. Note the use of the suspend keyword, indicating that this function is a coroutine.

Step 3: Create a data class​

In order to deserialize the JSON response into Kotlin objects, we need to create a corresponding data class. Create a new Kotlin file and name it User.kt. In this file, define your data class as follows:

data class User(
    val id: Int,
    val name: String,
    val email: String
)

Here, we have defined a simple User data class with three properties: id, name, and email.

Step 4: Create a Retrofit instance​

Now, we need to create a Retrofit instance with the Moshi converter factory. In your Kotlin file, create a function called createRetrofitInstance() as follows:

private fun createRetrofitInstance(): Retrofit {
    val moshi = Moshi.Builder()
        .add(KotlinJsonAdapterFactory())
        .build()

    return Retrofit.Builder()
        .baseUrl("https://api.example.com/")
        .addConverterFactory(MoshiConverterFactory.create(moshi))
        .build()
}

Here, we have created a Moshi instance and added the KotlinJsonAdapterFactory() to handle Kotlin-specific JSON serialization and deserialization. Then, we create a Retrofit instance with the base URL of your API and the Moshi converter factory.

Step 5: Make API calls​

Now, we can make API calls using the Retrofit service interface. In your activity or fragment, create an instance of the Retrofit service interface and make the API call as follows:

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

lifecycleScope.launch {
    try {
        val users = apiService.getUsers()
        // Use the list of users as needed
    } catch (e: Exception) {
        // Handle the exception
    }
}

Here, we create an instance of the Retrofit service interface using the create() method of the Retrofit instance. Then, we make the API call getUsers() inside a coroutine using lifecycleScope.launch. We can handle any exceptions that occur during the API call.

Step 6: Handle API response​

Finally, we can handle the API response in the calling code. In the example above, we retrieve a list of users and can use it as needed. You can modify the code to suit your specific use case, such as updating UI elements or storing the data locally.

That's it! You have successfully used Moshi converter with Retrofit in Kotlin for Android. You can now consume JSON APIs and deserialize the responses into Kotlin objects using Moshi and Retrofit.