more more 🔥

Author: hoc081098

sample/app/src/main/java/com/hoc081098/channeleventbus/sample/android/ui/home/detail/DetailScreen.kt

@@ -17,12 +17,14 @@ import androidx.compose.material3.Text
 import androidx.compose.runtime.Composable
 import androidx.compose.runtime.getValue
 import androidx.compose.runtime.remember
+import androidx.compose.runtime.rememberUpdatedState
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.text.input.ImeAction
 import androidx.compose.ui.text.style.TextAlign
 import androidx.compose.ui.unit.dp
 import androidx.lifecycle.compose.collectAsStateWithLifecycle
+import com.hoc081098.channeleventbus.sample.android.common.CollectWithLifecycleEffect
 import kotlinx.coroutines.Dispatchers
 import org.koin.androidx.compose.koinViewModel
 
@@ -32,6 +34,13 @@ fun DetailScreen(
   modifier: Modifier = Modifier,
   vm: DetailVM = koinViewModel(),
 ) {
+  val currentNavigateBack by rememberUpdatedState(navigateBack)
+  vm.singleEventFlow.CollectWithLifecycleEffect { event ->
+    when (event) {
+      DetailSingleEvent.Complete -> currentNavigateBack()
+    }
+  }
+
   val text by vm
     .textStateFlow
     .collectAsStateWithLifecycle(context = Dispatchers.Main.immediate)
@@ -70,10 +79,7 @@ fun DetailScreen(
 
       ElevatedButton(
         enabled = text.isNotBlank(),
-        onClick = {
-          vm.sendResultToHome()
-          navigateBack()
-        },
+        onClick = remember { vm::sendResultToHome },
       ) {
         Text(text = "Send to home screen")
       }

sample/app/src/main/java/com/hoc081098/channeleventbus/sample/android/ui/home/detail/DetailVM.kt

@@ -1,31 +1,67 @@
 package com.hoc081098.channeleventbus.sample.android.ui.home.detail
 
+import androidx.compose.runtime.Immutable
 import androidx.lifecycle.SavedStateHandle
 import androidx.lifecycle.ViewModel
+import androidx.lifecycle.viewModelScope
 import com.hoc081098.channeleventbus.ChannelEventBus
+import com.hoc081098.channeleventbus.sample.android.common.HasSingleEventFlow
 import com.hoc081098.channeleventbus.sample.android.common.SafeSavedStateHandle
 import com.hoc081098.channeleventbus.sample.android.common.SavedStateHandleKey
+import com.hoc081098.channeleventbus.sample.android.common.SingleEventChannel
 import com.hoc081098.channeleventbus.sample.android.ui.home.DetailResultToHomeEvent
 import com.hoc081098.channeleventbus.sample.android.utils.NonBlankString.Companion.toNonBlankString
+import com.hoc081098.channeleventbus.sample.android.utils.launchNowIn
+import com.hoc081098.flowext.flowFromSuspend
+import kotlinx.coroutines.ExperimentalCoroutinesApi
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.MutableSharedFlow
 import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.flow.flatMapLatest
+import kotlinx.coroutines.launch
+import timber.log.Timber
 
+@Immutable
+sealed interface DetailSingleEvent {
+  data object Complete : DetailSingleEvent
+}
+
+@OptIn(ExperimentalCoroutinesApi::class)
 class DetailVM(
   private val channelEventBus: ChannelEventBus,
+  private val singleEventChannel: SingleEventChannel<DetailSingleEvent>,
   savedStateHandle: SavedStateHandle,
-) : ViewModel() {
+) : ViewModel(singleEventChannel),
+  HasSingleEventFlow<DetailSingleEvent> by singleEventChannel {
   private val safeSavedStateHandle = SafeSavedStateHandle(savedStateHandle)
+  private val sendResultFlow = MutableSharedFlow<Unit>(extraBufferCapacity = 1)
 
   internal val textStateFlow: StateFlow<String> = safeSavedStateHandle.getStateFlow(TextKey)
 
+  init {
+    fun process(): Flow<Unit> = flowFromSuspend {
+      delay(500) // simulate a long-running task
+
+      textStateFlow.value
+        .toNonBlankString()
+        .map(::DetailResultToHomeEvent)
+        .onSuccess(channelEventBus::send)
+        .onSuccess { singleEventChannel.sendEvent(DetailSingleEvent.Complete) }
+        .onFailure { Timber.e(it, "Error while sending result to home") }
+    }
+
+    sendResultFlow
+      .flatMapLatest { process() }
+      .launchNowIn(viewModelScope)
+  }
+
   internal fun onTextChanged(text: String) {
     safeSavedStateHandle[TextKey] = text
   }
 
   internal fun sendResultToHome() {
-    textStateFlow.value
-      .toNonBlankString()
-      .map(::DetailResultToHomeEvent)
-      .onSuccess(channelEventBus::send)
+    viewModelScope.launch { sendResultFlow.emit(Unit) }
   }
 
   private companion object {

sample/app/src/main/java/com/hoc081098/channeleventbus/sample/android/utils/launchNow.kt

@@ -0,0 +1,28 @@
+package com.hoc081098.channeleventbus.sample.android.utils
+
+import kotlinx.coroutines.CoroutineDispatcher
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.CoroutineStart
+import kotlinx.coroutines.Job
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.collect
+import kotlinx.coroutines.launch
+
+/**
+ * Launch a coroutine immediately to collect the flow.
+ * It is a shortcut for `scope.launch(CoroutineStart.UNDISPATCHED) { flow.collect() }`.
+ *
+ * This differs from [kotlinx.coroutines.flow.launchIn] in that the collection is started immediately _in the current thread_
+ * until the first suspension point, without dispatching to the [CoroutineDispatcher] of the scope context.
+ * However, when the coroutine is resumed from suspension, it is dispatched according to the [CoroutineDispatcher] in its context.
+ *
+ * This is useful when collecting a [kotlinx.coroutines.flow.SharedFlow] which does not replay or buffer values,
+ * and you don't want to miss any values due to the dispatching to the [CoroutineDispatcher].
+ *
+ * @see kotlinx.coroutines.flow.launchIn
+ * @see CoroutineStart.UNDISPATCHED
+ */
+fun <T> Flow<T>.launchNowIn(scope: CoroutineScope): Job =
+  scope.launch(start = CoroutineStart.UNDISPATCHED) {
+    collect() // tail-call
+  }