Edit: note that the API suggested in the original answer is now marked @ObsoleteCoroutineApi: Ticker channels are not currently integrated with structured concurrency and their api will change in the future. You can now use the Flow API to create your own ticker flow: import kotlin.time.Duration import kotlin.time.Duration.Companion.seconds import kotlinx.coroutines.* import kotlinx.coroutines.flow.* fun tickerFlow(period: Duration, … Read more
I don’t understand how coroutineScope and runBlocking are different here? coroutineScope looks like its blocking since it only gets to the last line when it is done. There are two separate worlds: the suspendable world (within a coroutine) and the non-suspendable one. As soon as you enter the body of runBlocking, you are in the … Read more
In this particular case you can use a general approach to convert a callback-based API to a suspending function via suspendCoroutine function: suspend fun CameraManager.openCamera(cameraId: String): CameraDevice? = suspendCoroutine { cont -> val callback = object : CameraDevice.StateCallback() { override fun onOpened(camera: CameraDevice) { cont.resume(camera) } override fun onDisconnected(camera: CameraDevice) { cont.resume(null) } override fun … Read more
The warning is about methods that block current thread and coroutine cannot be properly suspended. This way, you lose all benefits of coroutines and downgrade to one job per thread again. Each case should be handled in a different way. For suspendable http calls you can use ktor http client. But sometimes there is no … Read more
launch is used to fire and forget coroutine. It is like starting a new thread. If the code inside the launch terminates with exception, then it is treated like uncaught exception in a thread — usually printed to stderr in backend JVM applications and crashes Android applications. join is used to wait for completion of … Read more
First, add org.jetbrains.kotlinx:kotlinx-coroutines-jdk8 module to your dependencies. In your Kotlin file define the following async function that corresponds to Java style of writing async APIs: fun doSomethingAsync(): CompletableFuture<List<MyClass>> = GlobalScope.future { doSomething() } Now use doSomethingAsync from Java in the same way as you are using other asynchronous APIs in the Java world.
Suspending functions are at the center of everything coroutines. A suspending function is simply a function that can be paused and resumed at a later time. They can execute a long running operation and wait for it to complete without blocking. The syntax of a suspending function is similar to that of a regular function … 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
private WeakReference<MyActivity> activityReference; Good riddance that it’s deprecated, because the WeakReference<Context> was always a hack, and not a proper solution. Now people will have the opportunity to sanitize their code. AsyncTask<String, Void, MyPojo> Based on this code, Progress is actually not needed, and there is a String input + MyPojo output. This is actually quite … Read more