RxJava For Android

RxJava is a JVM library that uses observable sequences to perform asynchronous and event-based programming. Its primary building blocks are triple O’s, which stand for Operator, Observer, and Observables. And we use them to complete asynchronous tasks in our project. It greatly simplifies multithreading in our project. It assists us in determining which thread we want to run the task on.

GeekTip: RxJava, on the other hand, is designed primarily for Java projects. RxAndroid is required to use RxJava in Android.

What exactly is RxAndroid?

RxAndroid is a RxJava for Android extension that is only used in Android applications. RxAndroid added the Android-required Main Thread. We will need the Looper and Handler for Main Thread execution in order to work with multithreading in Android.

Note: AndroidSchedulers are provided by RxAndroid.

mainThread() returns a scheduler, which aids in performing tasks on the main UI thread, which is primarily used in the Android project. So, here we have AndroidSchedulers. mainThread() is used to gain access to the application’s main thread so that we can perform actions such as updating the UI. Because updating the UI from the background thread is technically not possible in Android, we can use AndroidSchedulers.mainThread() to update anything on the main thread. Internally, it makes use of the Handler and Looper concepts to perform the action on the main thread.

GeekTip: RxAndroid compiles and uses RxJava internally. However, while using RxAndroid in our project, we still include the RxJava dependency to work with, such as

implementation ‘io.reactivex.rxjava3:rxjava:2.5.0’

implementation ‘io.reactivex.rxjava3:rxandroid:3.0.0’

The reason for this is that RxAndroid may not have the most recent version of RxJava used in the project. As a result, we use RxJava dependency to override the versioning of the internal RxJava version used by RxAndroid.

The Actual Usage of this

RxJava harnesses the power of operators, and as the adage goes, “RxJava has an operator for almost everything.”

Example #1:

Consider the following scenario: we want to make an API call and save the result to some storage/file. It would be a long-running task, and doing a long-running task on the main thread could result in unexpected behavior, such as the App Not Responding. So, to complete the aforementioned task, we might consider using AsyncTask as our go-to solution. However, with Android R, AsyncTask will be deprecated, and libraries such as RxJava will be the solution. Using RxJava instead of AsyncTask allows us to write less code. It improves code management because AsyncTask can make code long and difficult to manage.

Example #2: 

Consider a scenario in which we want to retrieve user details from an API, and then using the user’s ID obtained from the previous API, we call another API to retrieve the user’s friend list. When using AsyncTask, we may need to use multiple AsyncTask and manage the results in a way that allows us to combine all of the AsyncTask and return the result as a single response.

Example #3: 

Consider the following scenario: we make an API call to obtain a list of users, and we only want the data that matches the given current condition. A general approach would be to make the API call, and then, from the Collection, filter the content of that specific user based on the condition and return the data. However, using RxJava, we can directly filter out the data while returning the API response by using the filter operator, and we do all of this while managing threads.

Conclusion

These are a few examples of RxJava for Android use cases and why we need RxAndroid in our project. There are also other articles at geeks for Geeks linking to other Rx Java Methods, that you can find here.