Three ways this can be resolved are To call the method in a launched effect block in your composable Or set the Context to Dispatchers.Main when setting value of the mutableState using withContext(Dispatchers.Main) Or change the mutable state in viewModel to mutableState flow and use collectAsState() in composable to collect it as a state.
Based on your sample code, you switch the coroutine context between MAIN and IO so when you set the breakpoint, make sure the suspend option is ALL To show the option of the breakpoint. Set a breakpoint with the left click of your mouse, and then right click your mouse on the breakpoint. If you … Read more
Here is a working example of an adapter, which automatically wraps a response to the Result wrapper. A GitHub sample is also available. // build.gradle … dependencies { implementation ‘com.squareup.retrofit2:retrofit:2.6.1’ implementation ‘com.squareup.retrofit2:converter-gson:2.6.1’ implementation ‘com.google.code.gson:gson:2.8.5’ } // test.kt … sealed class Result<out T> { data class Success<T>(val data: T?) : Result<T>() data class Failure(val statusCode: Int?) … Read more
Flow is a cold asynchronous stream, just like an Observable. All transformations on the flow, such as map and filter do not trigger flow collection or execution, only terminal operators (e.g. single) do trigger it. The onEach method is just a transformation. Therefore you should replace it with the terminal flow operator collect. Also you … Read more
Do not use both suspend and Flow<> on the same method! Like this @Query(“SELECT * FROM user”) suspend fun loadAll(): Flow<Array<User>> Just @Query(“SELECT * FROM user”) suspend fun loadAll(): Array<User> OR @Query(“SELECT * FROM user”) fun loadAll(): Flow<Array<User>>
The best way to explain the difference is to explain the mechanism of coroutineScope. Consider this code: suspend fun main() = println(compute()) suspend fun compute(): String = coroutineScope { val color = async { delay(60_000); “purple” } val height = async<Double> { delay(100); throw HttpException() } “A %s box %.1f inches tall”.format(color.await(), height.await()) } compute() … Read more
NO , GlobalScope will NOT be suitable for Application instance. As mention here in this article here: There are multiple reasons why you shouldn’t use GlobalScope: Promotes hard-coding values. It might be tempting to hardcode Dispatchers if you use GlobalScope straight-away. That’s a bad practice! It makes testing very hard. As your code is going … Read more
To answer your immediate question, you must simply launch the coroutine in the correct context: val call = ApiClient.getInterface().getRoute(request.getURL()) GlobalScope.launch(Dispatchers.Main) { try { success?.invoke(call.await()) } catch (t: Throwable) { fail?.invoke(t) } } However, this would be just the tip of the iceberg because your approach is the wrong way to use coroutines. Their key benefit … Read more
If you want to get the latest value on subscription/collection you should use a ConflatedBroadcastChannel: private val channel = ConflatedBroadcastChannel<Boolean>() This will replicate BehaviourSubject, to expose the channel as a Flow: // Repository fun observe() { return channel.asFlow() } Now to send an event/value to that exposed Flow simple send to this channel. // Repository … 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