You can think of yield() as “return, and next time start from where you stopped“: val sequence = sequence { val start = 0 yield(start) // first return yieldAll(1..5 step 2) // if called again, will start from here yieldAll(generateSequence(8) { it * 3 }) // if called more that six times, start from here … Read more
You should scope your concurrency appropriately using structured concurrency. Your coroutines can leak if you don’t do this. In your case, scoping them to the processing of a single message seems appropriate. Here’s an example: /* I don’t know Kafka, but let’s pretend this function gets * called when you receive a new message */ … Read more
Create a coroutines scope, tied to the lifecycle of your composable, and use that scope to call your suspending function suspend fun getLocation(): Location? { /* … */ } @Composable fun F() { // Returns a scope that’s cancelled when F is removed from composition val coroutineScope = rememberCoroutineScope() val (location, setLocation) = remember { … Read more
You should subclass IOException and use that to send information from your interceptors to your calling code. We consider other exceptions like IllegalStateException to be application crashes and do not send them over thread boundaries because we don’t want to burden most callers with catching them.
You can use awaitAll for that purpose: import kotlinx.coroutines.* suspend fun sendDataAndAwaitAcknowledge() = coroutineScope { awaitAll(async { awaitAcknowledge() }, async { sendData() }) } fun sendData() = true fun awaitAcknowledge() = false fun main() { runBlocking { println(sendDataAndAwaitAcknowledge()) // [false, true] } }
for now its in alpha, so please update your gradle to use the following dependencies: implementation “androidx.lifecycle:lifecycle-viewmodel-ktx:2.2.0”
AsyncTask is an Android API, not a language feature that is provided by Java nor Kotlin. You can just use them like this if you want: class someTask() : AsyncTask<Void, Void, String>() { override fun doInBackground(vararg params: Void?): String? { // … } override fun onPreExecute() { super.onPreExecute() // … } override fun onPostExecute(result: String?) … Read more
runBlocking is the way to bridge synchronous and asynchronous code I keep bumping into this phrase and it’s very misleading. runBlocking is almost never a tool you use in production. It undoes the asynchronous, non-blocking nature of coroutines. You can use it if you happen to already have some coroutine-based code that you want to … Read more
Lambda’s suspend modifier should be placed after the colon character, not in front. Example: fun MyModel.onBG(bar: suspend () -> Unit) { launch { withContext(Dispatchers.IO) { bar() } } }
Coroutines are a completely separate thing from any scheduling policy that you describe. A coroutine is basically a call chain of suspend funs. Suspension is totally under your control: you just have to call suspendCoroutine. You’ll get a callback object so you can call its resume method and get back to where you suspended. Here’s … Read more