Android：如何结合LiveData与RxJava处理错误？

Hey there! I totally get how frustrating it is to hit a wall with error handling when mixing LiveData and RxJava—been stuck on similar issues myself when starting out with Android Architecture Components. Let’s break this down and find a solid solution that works for you.

First, let’s clarify why your current setup isn’t handling errors: LiveDataReactiveStreams doesn’t have built-in support for propagating RxJava’s onError events directly to LiveData observers. If your Flowable emits an error, it’ll actually crash your app by default, since LiveData doesn’t expose an error callback.

Option 1: Wrap Your Data (Recommended) #

This is the most idiomatic approach because it aligns with LiveData’s design of holding state. You’ll create a wrapper class to encapsulate success, error, and even loading states all in one place.

Start by defining a sealed class (or a data class hierarchy) to represent your resource state:

sealed class Resource<out T> {
    data class Success<out T>(val data: T) : Resource<T>()
    data class Error(val exception: Throwable) : Resource<Nothing>()
    object Loading : Resource<Nothing>() // Optional, for loading states
}

Then modify your Flowable to emit instances of this wrapper instead of raw data. Use onErrorReturn to catch errors and convert them into an Error state:

livedata = LiveDataReactiveStreams.fromPublisher(
    bookRepository.getAll()
        .map { books ->
            // Convert your list of books to names, then wrap in Success
            val bookNames = books.map { it.name }
            Resource.Success(bookNames)
        }
        .onErrorReturn { throwable ->
            // Catch any errors and wrap them in Error
            Resource.Error(throwable)
        }
        .startWithItem(Resource.Loading) // Optional: Emit loading state first
)

Finally, when observing the LiveData, you can handle each state explicitly in your UI:

livedata.observe(this) { resource ->
    when (resource) {
        is Resource.Success -> {
            // Update your UI with the list of book names
            yourRecyclerViewAdapter.submitList(resource.data)
        }
        is Resource.Error -> {
            // Show an error message to the user
            Toast.makeText(this, "Failed to load books: ${resource.exception.message}", Toast.LENGTH_SHORT).show()
        }
        Resource.Loading -> {
            // Show a loading spinner or progress bar
            loadingProgressBar.visibility = View.VISIBLE
        }
    }
}

Option 2: Fixing the MediatorLiveData Approach #

You mentioned that the MediatorLiveData solution had an issue where onComplete never gets called. That’s probably because your Flowable (likely from Room) is an infinite stream—it keeps emitting new data whenever the database changes, so onComplete is never triggered.

To make this work, you can manually subscribe to the Flowable, handle success/error events, and post values to the MediatorLiveData. Just remember to manage the subscription lifecycle to avoid memory leaks:

// Create a MediatorLiveData for your book names
val bookNamesLiveData = MediatorLiveData<List<String>>()
// Optional: A separate LiveData for errors if you prefer
val errorLiveData = MutableLiveData<Throwable>()

// Subscribe to the Flowable
val disposable = bookRepository.getAll()
    .map { it.map { book -> book.name } }
    .subscribe(
        { names -> bookNamesLiveData.postValue(names) },
        { error -> errorLiveData.postValue(error) }
    )

// Make sure to dispose the subscription when the lifecycle ends
lifecycle.addObserver(object : LifecycleObserver {
    @OnLifecycleEvent(Lifecycle.Event.ON_DESTROY)
    fun cleanUp() {
        disposable.dispose()
    }
})

The downside here is that you’re splitting state across two LiveData instances (one for data, one for errors), which can make your UI logic more fragmented compared to the wrapped resource approach.

Which Should You Choose? #

Go with the wrapped resource approach (Option 1) for most cases. It keeps your state management centralized, aligns with LiveData’s philosophy, and makes your UI code cleaner by handling all states in a single observe block.

If you have a specific use case where separating data and error streams makes sense, the MediatorLiveData approach works—but just be diligent about managing subscriptions to avoid leaks.

内容的提问来源于stack exchange，提问作者ininmm