Observer Vs Disposable

Great question! While the concepts of Observer and Disposable in RxJava (and by extension, Kotlin for Android) might seem similar, they serve very distinct purposes in reactive programming. Let’s take a detailed look at the differences and why both are important in the context of Kotlin for Android development.

1. What is an Observer in RxJava?

An Observer is a consumer that subscribes to an Observable or Flowable. It defines how to react to the three kinds of emissions from the observable source:

1. Data (onNext): The observer will receive a data emission when the observable produces a new item.

2. Error (onError): If something goes wrong during the emission process, the observer will receive an error.

3. Completion (onComplete): Once the observable has finished emitting all its items, it will notify the observer with a completion event.

Example of an Observer:

val observer = object : Observer<String> {
    override fun onNext(item: String) {
        println("Received: $item")
    }

    override fun onError(e: Throwable) {
        println("Error occurred: ${e.message}")
    }

    override fun onComplete() {
        println("All data received!")
    }

    override fun onSubscribe(d: Disposable) {
        // This is where the subscription is linked to a disposable
        println("Subscribed")
    }
}

The observer is what listens to the data that the Observable emits. In this example, the Observer:

• Reacts to the data when it's emitted via the onNext() method.

• Handles errors using onError().

• Handles completion events via onComplete().

2. What is a Disposable in RxJava?

A Disposable is a handle that represents a connection between an Observable and an Observer. When you subscribe an Observer to an Observable, a Disposable is returned that allows you to control the subscription. Specifically, it allows you to:

• Dispose of the connection between the observer and the observable when it’s no longer needed.

• Prevent memory leaks by stopping emissions when the observer should no longer receive updates.

The Disposable allows you to manage the subscription efficiently. It provides a method dispose(), which you can call to break the connection between the observable and observer, stopping any further emissions.

3. Difference Between Observer and Disposable

Though both Observer and Disposable are related to managing the lifecycle of observable subscriptions, their roles are fundamentally different:

• Observer: This is a consumer of the data emitted by an observable. It defines how to react to the data, errors, or completion of the observable stream. In other words, the observer listens to the stream of data emitted by the observable.

• Disposable: This is a control handle that lets you manage the subscription. It allows you to unsubscribe (or dispose) of the observable stream when it’s no longer needed. The purpose of a Disposable is to stop the emissions and to clean up resources used by the observable.

Why Do We Need Both?

You might wonder why we can’t just use the Observer alone and why we need Disposable as a separate concept. Here’s why:

1. Managing Subscriptions and Resource Cleanup:

   • The Observer only listens for emissions but has no control over when to stop the emissions or when to clean up resources. The Disposable gives you that control.

   • In Android, it's important to stop receiving emissions when an Activity or Fragment is no longer active (e.g., when the user navigates away from the screen). Failing to do so can lead to memory leaks because the observable continues emitting data that is no longer needed. The Disposable allows you to unsubscribe at the appropriate lifecycle events (e.g., onStop(), onDestroy()).

2. Decoupling Emissions from Subscription Management:

   • The observer focuses only on reacting to the data it receives, not managing when it should stop receiving data. The Disposable decouples this concern, allowing the subscription to be canceled when appropriate, without affecting the observer’s responsibilities.

4. How These Concepts Work Together in Android (Kotlin)

Here’s a real-world analogy:

• Observer: Imagine you’re watching a TV show (the TV is your observable source, and you’re the observer). You react to what’s being shown on the screen (data). If the show ends (onComplete), you stop watching. If the TV signal goes out (onError), you get frustrated and react to that.

• Disposable: Now, let’s say you get a phone call and need to leave the room. You can use a remote control (the disposable) to turn off the TV, stop receiving the show (unsubscribe), and conserve electricity. The TV is still functioning, but you’re no longer watching it.

In Android, Disposable works like the remote control—allowing you to stop watching (stop receiving emissions) when the user no longer needs it. If you don’t stop the emissions, the app may consume unnecessary resources or crash, even though the user has left the screen.

5. Practical Example: Adding Two Numbers with Observer and Disposable

Let’s revisit our earlier example of adding two numbers but this time, we’ll focus on how the Observer and Disposable work together.

1. Observable Source for Adding Two Numbers: We’ll create an observable that emits the result of adding two numbers when a button is clicked.

val observable = Observable.create<Int> { emitter ->
    addButton.setOnClickListener {
        try {
            val num1 = number1EditText.text.toString().toInt()
            val num2 = number2EditText.text.toString().toInt()
            emitter.onNext(num1 + num2)
        } catch (e: Exception) {
            emitter.onError(e)
        }
    }
}

1. Observer for Listening to the Emission: The Observer will react to the result of the addition. It will handle the emitted data, any errors, and completion.

val observer = object : Observer<Int> {
    override fun onSubscribe(d: Disposable) {
        // This is where we can save the disposable to manage the subscription later
        compositeDisposable.add(d)
    }

    override fun onNext(result: Int) {
        resultTextView.text = "Result: $result"
    }

    override fun onError(e: Throwable) {
        resultTextView.text = "Error: ${e.message}"
    }

    override fun onComplete() {
        println("Addition completed!")
    }
}

1. Subscription and Disposable Management: When we subscribe the Observer to the Observable, it returns a Disposable. This Disposable will be added to a CompositeDisposable so we can manage it later.

// Subscribe the observer to the observable
val disposable = observable.subscribeWith(observer)

// Add disposable to CompositeDisposable for efficient management
compositeDisposable.add(disposable)

1. Managing the Disposable in Android’s Lifecycle: Since this is an Android app, we’ll want to stop the emissions when the activity is no longer visible to the user (to avoid memory leaks).

override fun onStop() {
    super.onStop()
    // Clear all disposables to prevent memory leaks
    compositeDisposable.clear()
}

6. Summary of Key Differences

Concept	Role in RxJava	Functionality	Context in Android	When to Use
Observer	Listens to data emitted by an observable	Defines how to react to data (onNext, onError, onComplete)	Reacts to events, such as user input or API calls	Use when you need to process and react to data emitted by an observable
Disposable	Manages the connection between an observable and observer	Allows you to stop receiving emissions and clean up resources	Prevents memory leaks by stopping subscriptions when no longer needed	Use to efficiently stop emissions and free resources when a UI component is no longer visible

7. Conclusion

In summary:

• Observer is the part of the code that defines how to react to data emitted by an Observable. It listens to emissions and reacts accordingly.

• Disposable is the handle that allows you to control the subscription and stop it when necessary, thus preventing memory leaks or unnecessary operations.

Both are essential in writing clean, efficient, and responsive Android applications. By using Observer to define how your app should react to changes and Disposable to manage the lifecycle of these changes, you can ensure that your app uses resources effectively, responds to user input efficiently, and avoids common pitfalls like memory leaks.

Let me know if you need any further explanation or more examples!