sync code (#55)

Author: hoc081098

app/src/main/java/com/hoc/flowmvi/core/CoreModule.kt

@@ -1,6 +1,6 @@
 package com.hoc.flowmvi.core
 
-import com.hoc.flowmvi.core.dispatchers.CoroutineDispatchers
+import com.hoc.flowmvi.core.dispatchers.AppCoroutineDispatchers
 import dagger.Binds
 import dagger.Module
 import dagger.hilt.InstallIn
@@ -12,5 +12,5 @@ import javax.inject.Singleton
 internal abstract class CoreModule {
   @Binds
   @Singleton
-  abstract fun coroutineDispatchers(impl: DefaultCoroutineDispatchers): CoroutineDispatchers
+  abstract fun coroutineDispatchers(impl: DefaultCoroutineDispatchers): AppCoroutineDispatchers
 }

app/src/main/java/com/hoc/flowmvi/core/DefaultCoroutineDispatchers.kt

@@ -1,11 +1,13 @@
 package com.hoc.flowmvi.core
 
-import com.hoc.flowmvi.core.dispatchers.CoroutineDispatchers
+import com.hoc.flowmvi.core.dispatchers.AppCoroutineDispatchers
 import kotlinx.coroutines.CoroutineDispatcher
 import kotlinx.coroutines.Dispatchers
 import javax.inject.Inject
 
-internal class DefaultCoroutineDispatchers @Inject constructor() : CoroutineDispatchers {
-  override val main: CoroutineDispatcher = Dispatchers.Main
-  override val io: CoroutineDispatcher = Dispatchers.IO
+internal class DefaultCoroutineDispatchers @Inject constructor() : AppCoroutineDispatchers {
+  override val main: CoroutineDispatcher get() = Dispatchers.Main
+  override val io: CoroutineDispatcher get() = Dispatchers.IO
+  override val mainImmediate: CoroutineDispatcher get() = Dispatchers.Main.immediate
+  override val default: CoroutineDispatcher get() = Dispatchers.Default
 }

core/src/main/java/com/hoc/flowmvi/core/dispatchers/CoroutineDispatchers.kt renamed to core/src/main/java/com/hoc/flowmvi/core/dispatchers/AppCoroutineDispatchers.kt

@@ -2,7 +2,9 @@ package com.hoc.flowmvi.core.dispatchers
 
 import kotlinx.coroutines.CoroutineDispatcher
 
-interface CoroutineDispatchers {
+interface AppCoroutineDispatchers {
   val main: CoroutineDispatcher
   val io: CoroutineDispatcher
+  val mainImmediate: CoroutineDispatcher
+  val default: CoroutineDispatcher
 }

data/src/main/java/com/hoc/flowmvi/data/UserRepositoryImpl.kt

@@ -6,7 +6,7 @@ import arrow.core.leftWiden
 import arrow.core.right
 import arrow.core.valueOr
 import com.hoc.flowmvi.core.Mapper
-import com.hoc.flowmvi.core.dispatchers.CoroutineDispatchers
+import com.hoc.flowmvi.core.dispatchers.AppCoroutineDispatchers
 import com.hoc.flowmvi.core.retrySuspend
 import com.hoc.flowmvi.data.remote.UserApiService
 import com.hoc.flowmvi.data.remote.UserBody
@@ -33,7 +33,7 @@ import arrow.core.Either.Companion.catch as catchEither
 @ExperimentalTime
 internal class UserRepositoryImpl @Inject constructor(
   private val userApiService: UserApiService,
-  private val dispatchers: CoroutineDispatchers,
+  private val dispatchers: AppCoroutineDispatchers,
   private val responseToDomain: UserResponseToUserDomainMapperType,
   private val domainToBody: Mapper<User, UserBody>,
   private val errorMapper: Mapper<Throwable, UserError>,

data/src/test/java/com/hoc/flowmvi/data/UserRepositoryImplRealAPITest.kt

@@ -1,7 +1,7 @@
 package com.hoc.flowmvi.data
 
 import android.util.Log
-import com.hoc.flowmvi.core.dispatchers.CoroutineDispatchers
+import com.hoc.flowmvi.core.dispatchers.AppCoroutineDispatchers
 import com.hoc.flowmvi.domain.repository.UserRepository
 import com.hoc.flowmvi.test_utils.getOrThrow
 import kotlinx.coroutines.CoroutineDispatcher
@@ -34,10 +34,12 @@ class UserRepositoryImplRealAPITest : KoinTest {
     modules(
       dataModule,
       module {
-        factory<CoroutineDispatchers> {
-          object : CoroutineDispatchers {
+        factory<AppCoroutineDispatchers> {
+          object : AppCoroutineDispatchers {
             override val main: CoroutineDispatcher get() = Main
             override val io: CoroutineDispatcher get() = IO
+            override val mainImmediate: CoroutineDispatcher get() = Main.immediate
+            override val default: CoroutineDispatcher get() = IO
           }
         }
       }

feature-main/src/main/java/com/hoc/flowmvi/ui/main/MainVM.kt

@@ -2,11 +2,14 @@ package com.hoc.flowmvi.ui.main
 
 import androidx.lifecycle.viewModelScope
 import arrow.core.flatMap
+import com.hoc.flowmvi.core.dispatchers.AppCoroutineDispatchers
 import com.hoc.flowmvi.domain.usecase.GetUsersUseCase
 import com.hoc.flowmvi.domain.usecase.RefreshGetUsersUseCase
 import com.hoc.flowmvi.domain.usecase.RemoveUserUseCase
 import com.hoc.flowmvi.mvi_base.AbstractMviViewModel
+import com.hoc081098.flowext.defer
 import com.hoc081098.flowext.flatMapFirst
+import com.hoc081098.flowext.flowFromSuspend
 import com.hoc081098.flowext.startWith
 import dagger.hilt.android.lifecycle.HiltViewModel
 import kotlinx.coroutines.FlowPreview
@@ -15,13 +18,11 @@ import kotlinx.coroutines.flow.SharingStarted
 import kotlinx.coroutines.flow.StateFlow
 import kotlinx.coroutines.flow.asFlow
 import kotlinx.coroutines.flow.catch
-import kotlinx.coroutines.flow.emitAll
 import kotlinx.coroutines.flow.filter
 import kotlinx.coroutines.flow.filterIsInstance
 import kotlinx.coroutines.flow.filterNot
 import kotlinx.coroutines.flow.flatMapConcat
 import kotlinx.coroutines.flow.flatMapMerge
-import kotlinx.coroutines.flow.flow
 import kotlinx.coroutines.flow.map
 import kotlinx.coroutines.flow.merge
 import kotlinx.coroutines.flow.onEach
@@ -37,7 +38,8 @@ class MainVM @Inject constructor(
   private val getUsersUseCase: GetUsersUseCase,
   private val refreshGetUsers: RefreshGetUsersUseCase,
   private val removeUser: RemoveUserUseCase,
-) : AbstractMviViewModel<ViewIntent, ViewState, SingleEvent>() {
+  appCoroutineDispatchers: AppCoroutineDispatchers,
+) : AbstractMviViewModel<ViewIntent, ViewState, SingleEvent>(appCoroutineDispatchers) {
 
   override val viewState: StateFlow<ViewState>
 
@@ -117,11 +119,10 @@ class MainVM @Inject constructor(
           .log("Intent")
           .map { it.user }
           .flatMapMerge { userItem ->
-            flow {
+            flowFromSuspend {
               userItem
                 .toDomain()
                 .flatMap { removeUser(it) }
-                .let { emit(it) }
             }
               .map { result ->
                 result.fold(
@@ -134,5 +135,3 @@ class MainVM @Inject constructor(
       )
     }
 }
-
-private fun <T> defer(flowFactory: () -> Flow<T>): Flow<T> = flow { emitAll(flowFactory()) }

mvi/mvi-base/build.gradle.kts

@@ -38,6 +38,7 @@ dependencies {
   implementation(deps.coroutines.core)
 
   implementation(coreUi)
+  implementation(core)
   implementation(deps.timber)
 
   addUnitTest()

mvi/mvi-base/src/main/java/com/hoc/flowmvi/mvi_base/AbstractMviViewModel.kt

@@ -1,9 +1,12 @@
 package com.hoc.flowmvi.mvi_base
 
 import android.os.Build
+import androidx.annotation.CallSuper
 import androidx.lifecycle.ViewModel
 import androidx.lifecycle.viewModelScope
+import com.hoc.flowmvi.core.dispatchers.AppCoroutineDispatchers
 import kotlinx.coroutines.channels.Channel
+import kotlinx.coroutines.currentCoroutineContext
 import kotlinx.coroutines.flow.Flow
 import kotlinx.coroutines.flow.MutableSharedFlow
 import kotlinx.coroutines.flow.SharedFlow
@@ -13,12 +16,17 @@ import kotlinx.coroutines.flow.onEach
 import kotlinx.coroutines.flow.receiveAsFlow
 import kotlinx.coroutines.flow.shareIn
 import kotlinx.coroutines.flow.stateIn
+import kotlinx.coroutines.withContext
 import timber.log.Timber
+import kotlin.LazyThreadSafetyMode.PUBLICATION
+import kotlin.coroutines.ContinuationInterceptor
 
-abstract class AbstractMviViewModel<I : MviIntent, S : MviViewState, E : MviSingleEvent> :
+abstract class AbstractMviViewModel<I : MviIntent, S : MviViewState, E : MviSingleEvent>(
+  private val appCoroutineDispatchers: AppCoroutineDispatchers,
+) :
   MviViewModel<I, S, E>, ViewModel() {
-  protected val logTag by lazy(LazyThreadSafetyMode.PUBLICATION) {
-    this::class.java.simpleName.let { tag ->
+  protected val logTag by lazy(PUBLICATION) {
+    this::class.java.simpleName.let { tag: String ->
       // Tag length limit was removed in API 26.
       if (tag.length <= MAX_TAG_LENGTH || Build.VERSION.SDK_INT >= 26) {
         tag
@@ -34,9 +42,22 @@ abstract class AbstractMviViewModel<I : MviIntent, S : MviViewState, E : MviSing
   final override val singleEvent: Flow<E> get() = eventChannel.receiveAsFlow()
   final override suspend fun processIntent(intent: I) = intentMutableFlow.emit(intent)
 
+  @CallSuper
+  override fun onCleared() {
+    super.onCleared()
+    eventChannel.close()
+  }
+
   // Send event and access intent flow.
 
-  protected suspend fun sendEvent(event: E) = eventChannel.send(event)
+  protected suspend fun sendEvent(event: E) {
+    if (currentCoroutineContext()[ContinuationInterceptor] === appCoroutineDispatchers.mainImmediate) {
+      eventChannel.send(event)
+    } else {
+      withContext(appCoroutineDispatchers.mainImmediate) { eventChannel.send(event) }
+    }
+  }
+
   protected val intentFlow: SharedFlow<I> get() = intentMutableFlow
 
   // Extensions on Flow using viewModelScope.

test-utils/src/main/java/com/hoc/flowmvi/test_utils/TestDispatchers.kt

@@ -1,13 +1,15 @@
 package com.hoc.flowmvi.test_utils
 
-import com.hoc.flowmvi.core.dispatchers.CoroutineDispatchers
+import com.hoc.flowmvi.core.dispatchers.AppCoroutineDispatchers
 import kotlinx.coroutines.CoroutineDispatcher
 import kotlinx.coroutines.ExperimentalCoroutinesApi
 import kotlinx.coroutines.test.TestCoroutineDispatcher
 
 @ExperimentalCoroutinesApi
 class TestDispatchers(testCoroutineDispatcher: TestCoroutineDispatcher) :
-  CoroutineDispatchers {
+  AppCoroutineDispatchers {
   override val main: CoroutineDispatcher = testCoroutineDispatcher
   override val io: CoroutineDispatcher = testCoroutineDispatcher
+  override val mainImmediate: CoroutineDispatcher = testCoroutineDispatcher
+  override val default: CoroutineDispatcher = testCoroutineDispatcher
 }