How to write rx concatArrayEager equivalent in Kotlin CoRoutine?

Question

I would like to convert my rxJava Code to Kotlin CoRoutine.

Below is the code makes both the api and db call and returns the data to UI whatever comes first. Let us say if DB response happens to be quicker than the api. In that case still, the api response would continue until it receives the data to sync with db though it could have done the UI update earlier.

How Would I do it?

class MoviesRepository @Inject constructor(val apiInterface: ApiInterface,
                                        val MoviesDao: MoviesDao) {

fun getMovies(): Observable<List<Movie>> {
    val observableFromApi = getMoviesFromApi()
    val observableFromDb = getMoviesFromDb()
    return Observable.concatArrayEager(observableFromApi, observableFromDb)
}

fun getMoviesFromApi(): Observable<List<Movie>> {

    return apiInterface.getMovies()
            .doOnNext { it ->
                it.data?.let { it1 -> MoviesDao.insertAllMovies(it1) }
                println("Size of Movies from API %d", it.data?.size)
            }
            .map({ r -> r.data })
}

fun getMoviesFromDb(): Observable<List<Movie>> {
    return MoviesDao.queryMovies()
            .toObservable()
            .doOnNext {
                //Print log it.size :)
            }
}

}

Marko Topolnik · Accepted Answer · 2018-09-05T14:29:42.453

As the first step you should create suspend funs for your ApiInterface and MovieDao calls. If they have some callback-based API, you can follow these official instructions.

You should now have

suspend fun ApiInterface.suspendGetMovies(): List<Movie>

and

suspend fun MoviesDao.suspendQueryMovies(): List<Movie>

Now you can write this code:

launch(UI) {
    val fromNetwork = async(UI) { apiInterface.suspendGetMovies() }
    val fromDb = async(UI) { MoviesDao.suspendQueryMovies() }
    select<List<Movie>> {
        fromNetwork.onAwait { it }
        fromDb.onAwait { it }
    }.also { movies ->
        // act on the movies
    }
}

The highlight is the select call which will simultaneously await on both Deferreds and act upon the one that gets completed first.

If you want to ensure you act upon the result from the network, you'll need some more code, for example:

    val action = { movies: List<Movie> ->
        // act on the returned movie list
    }
    var gotNetworkResult = false
    select<List<Movie>> {
        fromNetwork.onAwait { gotNetworkResult = true; it }
        fromDb.onAwait { it }
    }.also(action)
    if (!gotNetworkResult) {
        action(fromNetwork.await())
    }

This code will act upon the DB results only if they come in before the network results, which it will process in all cases.

score 0 · Answer 2 · answered Sep 04 '18 at 10:05

0

Something along those lines should work:

data class Result(val fromApi: ???, val fromDB: ???)

fun getMovies(): Result {
    val apiRes = getMoviesFromApiAsync()
    val dbRes = getMoviesFromDbAsync()
    return Result(apiRes.await(), dbRes.await())
}

fun getMoviesFromApiAsync() = async {

    return apiInterface.getMovies()
            .doOnNext { it ->
                it.data?.let { it1 -> MoviesDao.insertAllMovies(it1) }
                println("Size of Movies from API %d", it.data?.size)
            }
            .map({ r -> r.data })
}

fun getMoviesFromDbAsync() = async {
    return MoviesDao.queryMovies()           
}

I don't know what you're returning, so I just put ??? instead.

answered Sep 04 '18 at 10:05

Alexey Soshin

16,718
2
31
40

Hey mate, thanks for your reply. But when you do the await while on Result. It would wait for both the suspended functions to be completed. But in ArrayEager it would repond the earliest on in the result. Hope it is clear what I am after. – Bulu Sep 04 '18 at 11:23
Sorry, but that's quite far from what `concatArrayEager` does actually: http://reactivex.io/RxJava/javadoc/io/reactivex/Observable.html#concatArrayEager-io.reactivex.ObservableSource...- – Alexey Soshin Sep 04 '18 at 13:36

How to write rx concatArrayEager equivalent in Kotlin CoRoutine?

2 Answers2