Making API Requests Using RxJava in Android with Kotlin.

Introduction

In modern Android applications, efficiently handling API requests is essential for providing smooth and responsive user experiences. RxJava, combined with Kotlin, offers a powerful way to handle asynchronous operations, manage threading, and deal with complex API calls. In this article, we will explore how to use RxJava for API requests in Android, leveraging its ability to compose multiple operations and handle errors seamlessly.

Why RxJava?

RxJava is a library for reactive programming that helps manage asynchronous events by using observable sequences. Here’s why RxJava is an excellent choice for handling API requests:

- Threading Made Simple: With schedulers, you can easily manage background and main thread operations.

- Chaining Asynchronous Operations: RxJava allows you to chain multiple API requests together, creating complex workflows.

- Error Handling: With a robust error-handling mechanism, RxJava lets you manage errors in API requests gracefully.

- Functional Programming: RxJava fits naturally with Kotlin’s functional programming style, allowing you to write more readable and maintainable code.

Setting Up RxJava in Android

To start using RxJava in Android, you need to add the following dependencies to your build.gradle file:

gradle

dependencies {

    implementation 'io.reactivex.rxjava3:rxjava:3.1.3'  // Latest RxJava version

    implementation 'io.reactivex.rxjava3:rxandroid:3.0.0'

    implementation 'com.squareup.retrofit2:retrofit:2.9.0'

    implementation 'com.squareup.retrofit2:adapter-rxjava3:2.9.0'

    implementation 'com.squareup.retrofit2:converter-gson:2.9.0'

}        

The RxJava and RxAndroid libraries provide the core functionality and threading capabilities, while Retrofit makes API requests and converts the API response using Gson. The RxJava3CallAdapterFactory allows Retrofit to return RxJava types.

Creating the API Interface with Retrofit

We will start by creating an API service using Retrofit. For this example, we will be making a request to fetch a list of users from an endpoint.

kotlin

interface ApiService {

    @GET("users")

    fun getUsers(): Single<List<User>>

}        

In this case, getUsers() is returning a Single, which is an RxJava type that emits either a single success response or an error. RxJava also provides other observable types such as Observable, Flowable, Maybe, and Completable, which can be used depending on the nature of the operation.

Retrofit Setup

Next, you’ll need to set up your Retrofit instance and attach the RxJava adapter:

kotlin

val retrofit = Retrofit.Builder()

    .baseUrl("https://api.example.com/")  // Replace with your API base URL

    .addConverterFactory(GsonConverterFactory.create())  // Converts JSON to Kotlin objects

    .addCallAdapterFactory(RxJava3CallAdapterFactory.create())  // Adds RxJava support

    .build()

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

The GsonConverterFactory is used to parse the API response, while RxJava3CallAdapterFactory allows Retrofit to return RxJava types such as Single or Observable.

Making an API Request with RxJava

Once the API service and Retrofit instance are ready, we can make an API request. The following example shows how to use RxJava for the API request and handle its response:

kotlin

apiService.getUsers()

    .subscribeOn(Schedulers.io())    // Request will run on IO thread

    .observeOn(AndroidSchedulers.mainThread())  // Response handled on main thread

    .subscribe(

        { users -> handleSuccess(users) },   // On success

        { throwable -> handleError(throwable) }  // On error

    )        

- subscribeOn(Schedulers.io()): This tells RxJava to perform the network call on the IO thread, freeing up the main thread for UI updates.

- observeOn(AndroidSchedulers.mainThread()): The result (or error) will be delivered back on the main thread so that it can safely interact with the UI.

- subscribe(): Starts the asynchronous operation, and accepts two lambdas: one for handling the success and another for handling errors.

Handling API Responses

In the success callback, you will handle the data returned by the API:

kotlin

private fun handleSuccess(users: List<User>) {

    // Process the list of users, update UI or store in the database

    for (user in users) {

        println(user.name)

    }

}        

In the error callback, handle any exceptions:

kotlin

private fun handleError(error: Throwable) {

    // Handle different types of exceptions

    when (error) {

        is HttpException -> {

            // HTTP error (e.g., 404, 500)

            println("HTTP error: ${error.code()}")

        }

        is IOException -> {

            // Network error (e.g., no internet connection)

            println("Network error: ${error.message}")

        }

        else -> {

            // Other errors

            println("Unexpected error: ${error.message}")

        }

    }

}        

This way, you can process different types of errors appropriately, showing relevant messages to the user.

Chaining Multiple API Calls

RxJava allows you to chain multiple asynchronous operations, which is useful when you need to make several dependent API requests. Here’s how you can chain two API calls:

kotlin

apiService.getUsers()

    .flatMap { users ->

        // After getting the list of users, make another API request

        apiService.getUserDetails(users[0].id)

    }

    .subscribeOn(Schedulers.io())

    .observeOn(AndroidSchedulers.mainThread())

    .subscribe(

        { userDetails -> handleUserDetails(userDetails) },

        { throwable -> handleError(throwable) }

    )        

With flatMap(), you can chain multiple API requests in a seamless flow. This reduces code complexity compared to traditional nested callback approaches.

#### Using CompositeDisposable for Memory Management

To avoid memory leaks when using RxJava, it’s important to properly dispose of your subscriptions, especially in Android where activities and fragments can be destroyed and recreated. A CompositeDisposable is useful for this:

kotlin

val disposable = CompositeDisposable()

disposable.add(

    apiService.getUsers()

        .subscribeOn(Schedulers.io())

        .observeOn(AndroidSchedulers.mainThread())

        .subscribe(

            { users -> handleSuccess(users) },

            { error -> handleError(error) }

        )

)

// Dispose when the activity or fragment is destroyed

override fun onDestroy() {

    super.onDestroy()

    disposable.dispose()  // Dispose of all subscriptions

}        

By using CompositeDisposable, you can easily manage the lifecycle of your RxJava subscriptions.

Conclusion

RxJava, combined with Kotlin and Retrofit, provides an elegant solution for handling API requests in Android. It allows for cleaner code, better error handling, and easier management of background threads. Whether you are making simple API requests or chaining multiple calls, RxJava makes the process efficient and maintainable.