what’s the recommended way of doing something like...

# coroutines

[matt tighe]

what’s the recommended way of doing something like this:

fun refreshData() {
        networkStatus = Status.ACTIVE // class member
        launch(CommonPool) {
            asyncAwait {
                remoteSource.fetchData().forEach {
                    roomDatabase.dao().insertData(it)
                }
                networkStatus = Status.INACTIVE
            }
        }
    }

i’d like to be able to unit test that the status is updated while the coroutine is running

[Jonathan Walsh]

I’m not a coroutine expert, but maybe checkout https://kotlin.github.io/kotlinx.coroutines/kotlinx-coroutines-core/kotlinx.coroutines.experimental.channels/-conflated-broadcast-channel/

[Jonathan Walsh]

having a channel will make it much easier to be notified when the status changes

[Jonathan Walsh]

and conflated channels only have the most recent value

[Dico]

are you looking for this:

runBlocking {
    remoteSource.fetchData().forEach {
        roomDatabase.dao().insertData(it)
    }
    networkStatus = Status.INACTIVE
}

[Dico]

it doesn't make very much sense to do this when you're already in a coroutine/suspend function, though. You can just inline the code..

[Dico]

Alternatively,

launch { 
    // code here
}.join()

[gildor]

What is asyncAwait? Shortcut for async{}.await()? If so, it doesn’t make any sense, there are not cases when you call async{} and await immidiately. Probably you can just call the function or use withContext instead

[gildor]

also CommonPool in probably redundant

[gildor]

In general such function is actually bad style in most cases, instead function should be suspend without launch(CommonPool) and asyncAwait so it allows you to wait (suspend) until function finish and check side effect after

It’s exactly the same bad style as launch thread in a function: you just cannot test it and have other problems with lifecycle of such function, concurrent updates and so on

[gildor]

One more issue with your code, that your Room method calls are blocking, so you block threads from CommonPool and it’s not good and can cause deadlocks and general performance problems with coroutine dispatching.
I recommend to wrap such calls to new IO coroutine dispatcher (like withContext(IO)).
or use async API of Room (there are adapters for RxJava and LiveData)

[gildor]

https://kotlinlang.slack.com/archives/C1CFAFJSK/p1536267046000100?thread_ts=1536257585.000100&cid=C1CFAFJSK
What is use case for such idiom? If you already inside coroutine (can use join), you don’t need launch, use withContext instead

[Dico]

Yeah, you are right. I was a bit confused by the question myself.

[Dico]

^^^ He brought up some good points