.doOnNext Operator

The .doOnNext operator in RxJava allows you to perform a side effect for each item emitted by an Observable before that item is passed on to the next operator in the chain or to the subscriber (observer). It doesn’t alter the emitted item or modify the data stream in any way; instead, it provides a way to react to each emission as it's being processed.

1. What is .doOnNext?

• Purpose: The .doOnNext operator allows you to execute an action for every item emitted by the observable without consuming or modifying the item itself. This is called a side effect, and it’s typically used for logging, debugging, or performing additional operations like saving data, updating a UI element, or triggering analytics.

• Side Effect: A side effect in this context is some additional operation that you want to perform that doesn't affect the observable's core purpose (like logging or displaying some message).

The emitted item flows through the operator chain without being modified. .doOnNext acts as an interceptor between the emission of data and its eventual consumption by an observer.

2. Syntax of .doOnNext in Kotlin (RxJava 2/3)

Here’s a simple syntax for .doOnNext in Kotlin:

observable
    .doOnNext { item ->
        // Perform side-effect action here
    }
    .subscribe { result ->
        // Handle the emitted result here
    }

3. When and Why to Use .doOnNext?

• Logging: You might want to log every item that flows through the observable chain.

• Debugging: If you want to see what's happening at a certain point in your chain of operators, you can use .doOnNext to inspect the emitted items.

• Saving Data: You can use .doOnNext to store some data locally (e.g., saving an emitted result to a database).

• UI Updates: You might want to update some part of your UI based on each emission (e.g., showing a loading message or updating a progress bar).

4. Practical Example: Using .doOnNext for Logging

Let’s say we have an observable that emits a list of integers, and we want to log each number before passing it to the next operation. The .doOnNext operator can be used for this purpose.

import io.reactivex.Observable
import io.reactivex.android.schedulers.AndroidSchedulers
import io.reactivex.schedulers.Schedulers

fun main() {
    // Create an Observable that emits numbers 1 to 5
    val numbersObservable = Observable.just(1, 2, 3, 4, 5)

    // Use .doOnNext to log the emitted numbers
    numbersObservable
        .doOnNext { number ->
            println("Logging number: $number")  // Log each emitted number
        }
        .subscribeOn(Schedulers.io())  // Perform on background thread
        .observeOn(AndroidSchedulers.mainThread())  // Observe on main thread
        .subscribe(
            { result -> println("Received: $result") },  // onNext
            { error -> println("Error: ${error.message}") },  // onError
            { println("All numbers processed!") }  // onComplete
        )
}

Output:

Logging number: 1
Received: 1
Logging number: 2
Received: 2
Logging number: 3
Received: 3
Logging number: 4
Received: 4
Logging number: 5
Received: 5
All numbers processed!

In this example:

• doOnNext logs each number as it is emitted by the observable.

• The actual processing of the numbers (in subscribe) remains unchanged.

• You can see that .doOnNext provides a side effect that logs the numbers, but the flow of data and the results aren’t altered.

5. More Use Cases for .doOnNext

A. Storing Data Using .doOnNext

Let’s say you want to store each emitted number in a database before displaying it. You can use .doOnNext to perform the database operation without interrupting the emission flow.

import io.reactivex.Observable
import io.reactivex.schedulers.Schedulers
import io.reactivex.android.schedulers.AndroidSchedulers

fun main() {
    val numbersObservable = Observable.just(1, 2, 3, 4, 5)

    numbersObservable
        .doOnNext { number ->
            // Store the number in a database (simulated here by a print statement)
            println("Storing number $number in the database")
        }
        .subscribeOn(Schedulers.io())
        .observeOn(AndroidSchedulers.mainThread())
        .subscribe(
            { result -> println("Displaying: $result") },  // Actual handling of the data
            { error -> println("Error: ${error.message}") },  // onError
            { println("All numbers processed!") }  // onComplete
        )
}

Output:

Storing number 1 in the database
Displaying: 1
Storing number 2 in the database
Displaying: 2
Storing number 3 in the database
Displaying: 3
Storing number 4 in the database
Displaying: 4
Storing number 5 in the database
Displaying: 5
All numbers processed!

Here:

• .doOnNext is used to simulate storing each number in a database before it is displayed.

• The observable continues emitting the data normally, but now we have a side effect where each number is "stored" before being processed further.

B. Updating a Progress Bar in Android Using .doOnNext

If you are processing a large set of data and want to update a progress bar in the UI after each item is processed, .doOnNext is perfect for this scenario.

import android.os.Bundle
import android.widget.ProgressBar
import androidx.appcompat.app.AppCompatActivity
import io.reactivex.Observable
import io.reactivex.android.schedulers.AndroidSchedulers
import io.reactivex.schedulers.Schedulers

class MainActivity : AppCompatActivity() {

    lateinit var progressBar: ProgressBar

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

        val numbersObservable = Observable.just(1, 2, 3, 4, 5)

        numbersObservable
            .doOnNext { number ->
                // Update progress bar based on the emitted number
                progressBar.progress = number * 20
            }
            .subscribeOn(Schedulers.io())
            .observeOn(AndroidSchedulers.mainThread())
            .subscribe(
                { result -> println("Processed: $result") },
                { error -> println("Error: ${error.message}") },
                { println("All numbers processed!") }
            )
    }
}

Here’s what’s happening:

• Each time a number is emitted by the observable, the progress bar is updated in the .doOnNext block.

• The core flow of the observable (emitting numbers) remains the same, but the UI (progress bar) is updated as a side effect.

6. Difference Between .doOnNext and .map

A common question is the difference between .doOnNext and .map. Here’s a comparison:

• .doOnNext: Executes a side effect for each emitted item but does not modify the item. It's mainly used for actions like logging, saving data, or updating a UI element.

• .map: Transforms each emitted item. It modifies the item before passing it down the chain.

Example of .map:

observable
    .map { item -> item * 2 }  // Modifies the item
    .subscribe { result -> println("Received: $result") }

In this case, the .map operator transforms the emitted items, while .doOnNext simply performs an action (side effect) without altering the item.

7. Using .doOnNext with Error Handling

If you want to log each item but also handle any errors, you can use .doOnNext alongside error-handling operators like .doOnError or .onErrorReturn.

val numbersObservable = Observable.just(1, 2, 3, 4, 5)

numbersObservable
    .doOnNext { number ->
        println("Processing number: $number")
    }
    .doOnError { error ->
        println("An error occurred: ${error.message}")
    }
    .subscribe(
        { result -> println("Processed: $result") },
        { error -> println("Error: ${error.message}") },
        { println("All numbers processed!") }
    )

In this example, .doOnNext logs each number, and .doOnError logs any errors that might occur during the stream.

8. Conclusion

The .doOnNext operator in RxJava allows you to insert side effects into your reactive streams. It’s incredibly useful for actions that don’t modify the data but are important for logging, debugging, saving data, or updating the UI. Unlike .map, which transforms data, .doOnNext simply observes each emitted item and performs some action without affecting the flow of data.

To recap:

• Purpose: Perform actions (like logging, saving data, updating UI) without modifying the data emitted by the observable.

• Use Cases: Logging, updating progress bars, saving data to a database, etc.

• Common Pattern: You can use .doOnNext for inspecting emissions at different points in your operator chain without altering the behavior or data itself.

Let me know if you need further clarification or more examples!