RxJava and RxAndroid

Rx stands for Reactive Extensions, a programming paradigm that models data as asynchronous streams and uses operators to handle data flow and transformation. It combines principles from the Observer Pattern, Iterator Pattern, and Functional Programming.

RxJava is a Java-based library for reactive programming. RxAndroid is its Android-specific extension that provides schedulers tied to Android’s main thread or any given Looper. This allows developers to shift work across threads and update the UI in a clean, non-blocking way.

In reactive programming, everything is treated as a stream—button clicks, network responses, GPS changes, sensor updates, etc. These streams can be filtered, combined, and transformed through operators to drive application behavior in a more declarative way.

Key Concepts in RxJava

Observable: Emits a stream of data.
Observer (or Subscriber): Consumes and reacts to the data emitted.
Operators: Modify or transform the emitted data (e.g., map, filter, merge).
Schedulers: Define the threads where the work and UI updates should occur.
Disposable: Manages the lifecycle of the stream to avoid memory leaks.

RxAndroid Example in Kotlin

User.kt

data class User(val name: String)

UserService.kt

class UserService {
    fun getUsers(): Observable> {
        return Observable.fromCallable {
            listOf(User("A"), User("B"), User("C"))
        }.delay(2, TimeUnit.SECONDS)
    }
}

MainActivity.kt

class MainActivity : AppCompatActivity() {

    private lateinit var nameTextView: TextView
    private var disposable: Disposable? = null

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)

        nameTextView = findViewById(R.id.nameTextView)

        val userService = UserService()

        disposable = userService.getUsers()
            .subscribeOn(Schedulers.io())
            .observeOn(AndroidSchedulers.mainThread())
            .subscribe(
                { users -> nameTextView.text = users.firstOrNull()?.name },
                { error -> Toast.makeText(this, "Error: ${error.message}", Toast.LENGTH_SHORT).show() }
            )
    }

    override fun onDestroy() {
        super.onDestroy()
        disposable?.dispose()
    }
}

This example fetches user data asynchronously and displays the first user's name in a TextView. It uses Schedulers.io() for background execution and AndroidSchedulers.mainThread() to update the UI.

RxJava vs Kotlin Coroutines & Flow

Kotlin introduced Coroutines and Flow as official tools for asynchronous and reactive programming. While RxJava remains powerful and flexible, Kotlin’s Coroutines and Flow offer simpler, more idiomatic solutions for many modern use cases.

Aspect	RxJava / RxAndroid	Coroutines / Flow
Language Origin	Java-based	Built into Kotlin
Thread Management	Schedulers (observeOn, subscribeOn)	Dispatchers (Main, IO, Default)
Data Stream	Observable / Flowable	Flow / SharedFlow / StateFlow
Backpressure Handling	Yes (Flowable)	Built-in with Flow
Learning Curve	Steep	Simpler, especially for Kotlin devs
Interop with XML/Android Views	Excellent (via RxBinding)	Requires integration / boilerplate

When to Prefer RxJava/RxAndroid

If an existing project already using Rx.
When there is need of complex stream operations (retryWhen, debounce, combineLatest, etc.).
When there is need of reactive integration with Android views (e.g., RxBinding).
When building cross-platform app where already use of RxJava/RxAndroid.

When to Prefer Coroutines & Flow

When starting a new project using Kotlin and want clean, readable async code.
When there is need of structured concurrency and easier lifecycle management.
When there is need to reduce boilerplate and dependencies.