Probably, you are using the direct collect() function on Flow. For your syntax, you need to import the collect() extension function. (and I really wish that they did not name these the same…)
This page shows some general techniques. In short, run with enabled assertions (-ea JVM flag). kotlinx-coroutines-debug module is specifically designed for what its name says. This is how I use it in unit tests; runBlocking { DebugProbes.install() val deferred = async { methodUnderTest() } delay(3000) DebugProbes.dumpCoroutines() println(“\nDumping only deferred”) DebugProbes.printJob(deferred) DebugProbes.uninstall() cleanup() } There’s a … Read more
If you don’t want any delay, why don’t you simply resume the continuation in the schedule call?: class TestUiContext : CoroutineDispatcher(), Delay { override fun scheduleResumeAfterDelay(time: Long, unit: TimeUnit, continuation: CancellableContinuation<Unit>) { continuation.resume(Unit) } override fun dispatch(context: CoroutineContext, block: Runnable) { //CommonPool.dispatch(context, block) // dispatch on CommonPool block.run() // dispatch on calling thread } } … Read more
Formally, coroutineScope is a special case of withContext where you pass in the current context, avoiding any context switching. Schematically speaking, coroutineScope ≡ withContext(this.coroutineContext) Since switching contexts is just one of several features of withContext, this is a legitimate use case. withContext waits for all the coroutines you start within the block to complete. If … Read more
Pankaj’s answer is correct, StateFlow won’t emit the same value twice. As the documentation suggests: Values in state flow are conflated using Any.equals comparison in a similar way to distinctUntilChanged operator. It is used to conflate incoming updates to value in MutableStateFlow and to suppress emission of the values to collectors when new value is … Read more
Coroutine’s analog to ThreadLocal is CoroutineContext. To interoperate with ThreadLocal-using libraries you need to implement a custom ContinuationInterceptor that supports framework-specific thread-locals. Here is an example. Let us assume that we use some framework that relies on a specific ThreadLocal to store some application-specific data (MyData in this example): val myThreadLocal = ThreadLocal<MyData>() To use … Read more
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
According to this, use Response<Unit> in the retrofit method declaration. retrofit no content issue
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