emit() is a suspend function that wraps a call to set the value: override suspend fun emit(value: T) { this.value = value } So the difference is that value lets you set the value even when not in a coroutine. emit() exists so MutableStateFlow can inherit from MutableSharedFlow. Source code here.
For callbackFlow: You cannot use emit() as the simple Flow (because it’s a suspend function) inside a callback. Therefore the callbackFlow offers you a synchronized way to do it with the trySend() option. Example: fun observeData() = flow { myAwesomeInterface.addListener{ result -> emit(result) // NOT ALLOWED } } So, coroutines offer you the option of … Read more
You can use StateFlow or SharedFlow APIs for such use case. Here’s a sample code with the usage of StateFlow. import kotlinx.coroutines.* import kotlinx.coroutines.flow.* val chatFlow = MutableStateFlow<String>(“”) fun main() = runBlocking { // Observe values val job = launch { chatFlow.collect { print(“$it “) } } // Change values arrayOf(“Hey”, “Hi”, “Hello”).forEach { delay(100) … Read more
You can create your own CoroutineScope with a SupervisorJob that you can cancel in the onDestroy() method. The coroutines created with this scope will live as long as your Service is being used. Once onDestroy() of your service is called, all coroutines started with this scope will be cancelled. class YourService : Service() { private … Read more
val one = async { one() } val two = async { two() } val int1 = one.await() val int2 = two.await() What this does: spawn task one spawn task two await on task one await on task two val one = async { one() }.await() val two = async { two() }.await() What this … Read more
Closing a channel conceptually works by sending a special “close token” over this channel. You close a channel when you have a finite sequence of elements to be processed by consumers and you must signal to the consumers that this sequence is over. You don’t have to close a channel otherwise. Channels are not tied … Read more
As a general rule of thumb, you should only declare your function suspend if the compiler forces you to. One possible exception to this rule would be if you’re defining this function as an open method (for instance in an interface) and you expect that some implementations/overrides will need to call suspending functions themselves. It’s … Read more