如何使用rxjava在存储库中提出改造请求，并使用LiveData将其传递给ViewModel？

Question

I'm trying to make an Android app that uses Google's architecture components. I'm making a request to the TasteDive API using retrofit and rxjava in a Repository class. The problem that I'm facing is that I can't find a way to pass the outcome of the retrofit request to the ViewModel using LiveData. What I'm currently doing is I have a sealed class called Outcome that keeps track of the state of the request and in this sealed class i have a data class that holds the data of a successful request. However, since rxjava's observable is a callback, I can't figure out a way to assign the outcome of the request to LiveData and pass it to the ViewModel. When I try to assign the outcome to LiveData, it returns null, unsurprisingly, since the observable is a callback. Can any of you help me figure out a way to store the outcome of the retrofit request into LiveData in order to pass it to the ViewModel? I have looked all over the internet for a solution to this and have not found anything helpful. Here's my repository class:

class GetSimilarDataRepository {
    private var mAdapter: TasteDiveAdapter? = null
    private lateinit var mResultsList: ArrayList<Result>

    private var observable: Observable<Response<TasteDive>>? = null

    private var liveData = MutableLiveData<Outcome<List<Result>>>()

    fun getSimilarData(map: LinkedHashMap<String, String>): LiveData<Outcome<List<Result>>> {
        mAdapter?.clear()

        val builder = Retrofit.Builder()
                .baseUrl("https://www.tastedive.com/api/")
                .addCallAdapterFactory(RxJava2CallAdapterFactory.create())
                .addConverterFactory(GsonConverterFactory.create())

        val retrofit = builder.build()


        val client = retrofit.create(TasteDiveClient::class.java)

        observable = client.getSimilarData(map)

        observable?.filter { it.code() == 200 }
                ?.map { Observable.just(it.body()) }
                ?.subscribeOn(Schedulers.io())
                ?.observeOn(AndroidSchedulers.mainThread())
                ?.doOnNext {
                    liveData.value = Outcome.loading(true)
                }?.doOnError {
                    liveData.value = Outcome.failure(it)
                }?.subscribeBy (
                        onError = {
                            liveData.value = Outcome.failure(it)
                        },

                        onNext = {
                            it.subscribe {
                                var similar = it?.Similar
                                var results = similar?.Results
                                if(results!!.isEmpty()) {
                                    liveData.value = Outcome.failure(Throwable("No results for that request"))
                                } else {
                                    mResultsList = ArrayList(results)
                                    liveData.value = Outcome.success(mResultsList)
                                }
                            }
                        },

                        onComplete = { Log.v("onComplete", "onComplete")}
                )

        observable?.filter{ it.code() == 403 }
                ?.map { Observable.just(it.body()) }
                ?.subscribeBy(
                        onNext = {
                            liveData.value = Outcome.failure(Throwable("403 Response Code"))
                        },
                        onError = { Log.v("onError403", "onError403") },
                        onComplete = { Log.v("onComplete403", "onComplete403") }
                )

        observable?.filter{ it.code() == 404 }
                ?.map { Observable.just(it.body()) }
                ?.subscribeBy(
                        onNext = {
                            liveData.value = Outcome.failure(Throwable("404 Response Code"))
                        },
                        onError = { Log.v("onError404", "onError404") },
                        onComplete = { Log.v("onComplete404", "onComplete404") }
                )

        observable?.filter{ it.code() == 400 }
                ?.map { Observable.just(it.body()) }
                ?.subscribeBy(
                        onNext = {
                            liveData.value = Outcome.failure(Throwable("400 Response Code"))
                        },
                        onError = { Log.v("onError400", "onError400") },
                        onComplete = { Log.v("onComplete400", "onComplete400") }
                )

        observable?.filter{ it.code() == 500 }
                ?.map { Observable.just(it.body()) }
                ?.subscribeBy(
                        onNext = {
                            liveData.value = Outcome.failure(Throwable("500 Response Code"))
                        },
                        onError = { Log.v("onError500", "onError500") },
                        onComplete = { Log.v("onComplete500", "onComplete500") }
                )
        return liveData
    }
}

The request is working, because mResultsList is giving me the correct results, but LiveData is returning null.

Here is the sealed class Outcome:

sealed class Outcome<T> {
    data class Progress<T>(var loading: Boolean) : Outcome<T>()
    data class Success<T>(var data: T) : Outcome<T>()
    data class Failure<T>(val e: Throwable) : Outcome<T>()

    companion object {
        fun <T> loading(isLoading: Boolean): Outcome<T> = Progress(isLoading)

        fun <T> success(data: T): Outcome<T> = Success(data)

        fun <T> failure(e: Throwable): Outcome<T> = Failure(e)
    }
}

Thanks for your time.

Answer 1

The issue is with the need for a Lifecycle Owner used for observations of LiveData in the Repository.

First, you don't want to do all networking actions inside the ViewModel. I think you have the right idea with the Repository , but you have to remember that the Repository will have to communicate only with the ViewModel . Best case, you would want the function getSimilarData(...) do some something like this:

Repository{
    val repositoryItems = BehaviorSubject.create<Outcome<List<Result>>>()

    fun observeRepositoryItems(): Observable<Outcome<List<Result>>> {
        return repositoryItems 
    }

    fun getSimilarData(map: LinkedHashMap<String, String>){
        // Pseudo code for actually items

        // Result goes into repositoryItems.onNext(...)
    }
}

However, you will have the issue of observing the status from the ViewModel as it itself is not a Lifecycle implementation, so it cannot easily observe the LiveData from the Repository.

My suggestion would be something like this:

Repository{
    val repositoryItems = BehaviorSubject.create<Outcome<List<Result>>>()

    fun observeRepositoryItems(): Observable<Outcome<List<Result>>> {
        return repositoryItems 
    }

    fun getSimilarData(map: LinkedHashMap<String, String>){
        // Pseudo code for actually items

        // Result goes into repositoryItems.onNext(...)
    }
}

ViewModel{
    val items: MutableLiveData<Outcome<List<Result>>>

    init{
        repository.observeRepositoryItems()
            .subscribe( items -> items.postValue(items ))
    }

    fun getData(){
        repository.getSimilarData(someMap)
    }
}

Fragment{
    viewModel.items.observe() // <-- Here you observe items loaded
}

Note that you will have to dispose the subscription in the ViewModel onCleared.
Note that all of this is pseudo code and it should be done a lot cleaner than this.