Handling Responses with Retrofit’s `Call` and `Callback` in Kotlin

In modern Android development, handling network requests is crucial, and one of the most efficient ways is using Retrofit, a popular networking library. With Retrofit, making network calls and handling responses can be done seamlessly, particularly with Kotlin thanks to its coroutines and advanced type safety. This article provides a detailed guide on managing responses utilizing Retrofit's Call and Callback interfaces.

Setting Up Retrofit

Before diving into handling the responses, let's first discuss how to set up Retrofit.

// Add the following dependencies in your build.gradle file
implementation 'com.squareup.retrofit2:retrofit:2.9.0'
implementation 'com.squareup.retrofit2:converter-gson:2.9.0'

After adding the dependencies, configure Retrofit in your application:

val retrofit = Retrofit.Builder()
    .baseUrl("https://api.example.com/")
    .addConverterFactory(GsonConverterFactory.create())
    .build()

Creating the API Interface

The next step is to define a service interface where methods correspond to an HTTP endpoint.

interface ApiService {
    // Define a GET request
    @GET("users/{id}")
    fun getUser(@Path("id") userId: String): Call<User>
}

Handling Responses with Call and Callback

Once the interface is defined, you can create an instance of the API service and call its methods. Retrofit can execute the network calls asynchronously using Call.enqueue(Callback).

// Create an implementation of the API endpoints defined by the interface
val apiService = retrofit.create(ApiService::class.java)

// Call the API
val call = apiService.getUser("123")
call.enqueue(object : Callback<User> {
    override fun onResponse(call: Call<User>, response: Response<User>) {
        if (response.isSuccessful) {
            // Successfully received response
            val user = response.body()
            // Do something with the user
        } else {
            // Handle the failure scenario, e.g., when server returns errors
        }
    }

    override fun onFailure(call: Call<User>, t: Throwable) {
        // Handle the network error, maybe no connectivity
    }
})

Notice that two methods must be overridden:

• onResponse: Invoked when a network call has completed, be it in success or failure. Check the Response object for status code and body.
• onFailure: Invoked when a network problem occurred, like compromised connectivity.

Understanding the Response Object

The Response object has several key components:

• isSuccessful: Returns true if the status code is in the range of 200-299.
• body(): Contains the parsed body of this response if available.
• code(): Returns the HTTP status code.
• errorBody(): Returns the raw response body as a string that contains errors, which isn’t available in body().

Error Handling

Error handling is a critical part of network communication. Utilize onFailure to detect possible network or conversion errors. In onResponse, you might want to check the status code:

override fun onResponse(call: Call<User>, response: Response<User>) {
    if (response.isSuccessful) {
        val user = response.body() ?: return
        // Handle success scenario
    } else {
        // Log or handle the server returned errors here
        val error = response.errorBody()?.string()
    }
}

Conclusion

Retrofit’s Call and Callback interfaces offer a straightforward way to handle network responses, but you must remain mindful of potential errors and handle them gracefully. Understanding how to effectively implement these responses allows developers to create a resilient application that offers a seamless user experience even in poor network conditions.

Consider utilizing Kotlin Coroutines for a more modern approach to asynchronous programming, possibly even leading to cleaner and more concise code.