Launch in + SavedStateHandle (#7)

* chore(refactor)

* update activity_add.xml

* wip

* wip

* done

* done

Author: hoc081098

.idea/gradle.xml

@@ -12,10 +12,12 @@ import org.koin.android.ext.koin.androidContext
 import org.koin.android.ext.koin.androidLogger
 import org.koin.core.context.startKoin
 import org.koin.core.logger.Level
+import kotlin.time.ExperimentalTime
 
 @Suppress("unused")
 @FlowPreview
 @ExperimentalCoroutinesApi
+@ExperimentalTime
 class App : Application() {
   override fun onCreate() {
     super.onCreate()

app/src/main/java/com/hoc/flowmvi/App.kt

@@ -35,6 +35,7 @@ object deps {
 
     const val viewModelKtx = "androidx.lifecycle:lifecycle-viewmodel-ktx:$version" // viewModelScope
     const val runtimeKtx = "androidx.lifecycle:lifecycle-runtime-ktx:$version" // lifecycleScope
+    const val commonJava8 = "androidx.lifecycle:lifecycle-common-java8:$version"
   }
 
   object squareup {
@@ -52,7 +53,7 @@ object deps {
   }
 
   object koin {
-    private const val version = "2.2.0-rc-4"
+    private const val version = "2.2.2"
 
     const val androidXViewModel = "org.koin:koin-androidx-viewmodel:$version"
     const val core = "org.koin:koin-core:$version"

buildSrc/src/main/kotlin/deps.kt

@@ -41,4 +41,7 @@ dependencies {
   implementation(deps.androidx.swipeRefreshLayout)
   implementation(deps.androidx.recyclerView)
   implementation(deps.androidx.material)
+
+  implementation(deps.lifecycle.commonJava8)
+  implementation(deps.lifecycle.runtimeKtx)
 }

core/build.gradle.kts

@@ -0,0 +1,16 @@
+package com.hoc.flowmvi.core
+
+sealed class Either<out L, out R> {
+  data class Left<L>(val l: L) : Either<L, Nothing>()
+  data class Right<R>(val r: R) : Either<Nothing, R>()
+
+  fun rightOrNull(): R? = when (this) {
+    is Left -> null
+    is Right -> r
+  }
+
+  fun leftOrNull(): L? = when (this) {
+    is Left -> l
+    is Right -> null
+  }
+}

core/src/main/java/com/hoc/flowmvi/core/Either.kt

@@ -0,0 +1,41 @@
+package com.hoc.flowmvi.core
+
+import androidx.lifecycle.DefaultLifecycleObserver
+import androidx.lifecycle.Lifecycle
+import androidx.lifecycle.LifecycleOwner
+import androidx.lifecycle.lifecycleScope
+import kotlinx.coroutines.Job
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.launchIn
+
+fun <T> Flow<T>.launchWhenStartedUntilStopped(owner: LifecycleOwner) {
+  if (owner.lifecycle.currentState == Lifecycle.State.DESTROYED) {
+    // ignore
+    return
+  }
+  owner.lifecycle.addObserver(LifecycleBoundObserver(this))
+}
+
+private class LifecycleBoundObserver(private val flow: Flow<*>) : DefaultLifecycleObserver {
+  private var job: Job? = null
+
+  override fun onStart(owner: LifecycleOwner) {
+    job = flow.launchIn(owner.lifecycleScope)
+  }
+
+  override fun onStop(owner: LifecycleOwner) {
+    cancelJob()
+  }
+
+  override fun onDestroy(owner: LifecycleOwner) {
+    super.onDestroy(owner)
+    owner.lifecycle.removeObserver(this)
+    cancelJob()
+  }
+
+  @Suppress("NOTHING_TO_INLINE")
+  private inline fun cancelJob() {
+    job?.cancel()
+    job = null
+  }
+}

core/src/main/java/com/hoc/flowmvi/core/Flow+LaunchIn.kt

@@ -0,0 +1,31 @@
+package com.hoc.flowmvi.core
+
+import kotlinx.coroutines.delay
+import kotlin.time.Duration
+import kotlin.time.ExperimentalTime
+
+@ExperimentalTime
+suspend inline fun <T> retrySuspend(
+  times: Int,
+  initialDelay: Duration,
+  factor: Double,
+  maxDelay: Duration = Duration.INFINITE,
+  shouldRetry: (Throwable) -> Boolean = { true },
+  block: (times: Int) -> T,
+): T {
+  var currentDelay = initialDelay
+  repeat(times - 1) {
+    try {
+      return block(it)
+    } catch (e: Throwable) {
+      if (!shouldRetry(e)) {
+        throw e
+      }
+      // you can log an error here and/or make a more finer-grained
+      // analysis of the cause to see if retry is needed
+    }
+    delay(currentDelay)
+    currentDelay = (currentDelay * factor).coerceAtMost(maxDelay)
+  }
+  return block(times - 1) // last attempt
+}

core/src/main/java/com/hoc/flowmvi/core/SuspendRetry.kt

@@ -17,9 +17,11 @@ import org.koin.core.qualifier.named
 import org.koin.dsl.module
 import retrofit2.Retrofit
 import retrofit2.converter.moshi.MoshiConverterFactory
+import kotlin.time.ExperimentalTime
 
 private const val BASE_URL = "BASE_URL"
 
+@ExperimentalTime
 @ExperimentalCoroutinesApi
 @FlowPreview
 val dataModule = module {

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

@@ -3,6 +3,7 @@ package com.hoc.flowmvi.data
 import android.util.Log
 import com.hoc.flowmvi.core.Mapper
 import com.hoc.flowmvi.core.dispatchers.CoroutineDispatchers
+import com.hoc.flowmvi.core.retrySuspend
 import com.hoc.flowmvi.data.remote.UserApiService
 import com.hoc.flowmvi.data.remote.UserBody
 import com.hoc.flowmvi.data.remote.UserResponse
@@ -18,7 +19,10 @@ import kotlinx.coroutines.flow.flow
 import kotlinx.coroutines.flow.onEach
 import kotlinx.coroutines.flow.scan
 import kotlinx.coroutines.withContext
+import kotlin.time.ExperimentalTime
+import kotlin.time.milliseconds
 
+@ExperimentalTime
 @ExperimentalCoroutinesApi
 internal class UserRepositoryImpl constructor(
   private val userApiService: UserApiService,
@@ -34,11 +38,18 @@ internal class UserRepositoryImpl constructor(
     class Added(val user: User) : Change()
   }
 
-  private val changesFlow = MutableSharedFlow<Change>()
+  private val changesFlow = MutableSharedFlow<Change>(extraBufferCapacity = 64)
 
   private suspend fun getUsersFromRemote(): List<User> {
     return withContext(dispatchers.io) {
-      userApiService.getUsers().map(responseToDomain)
+      retrySuspend(
+        times = 3,
+        initialDelay = 500.milliseconds,
+        factor = 2.0,
+      ) {
+        Log.d("###", "[USER_REPO] Retry times=$it")
+        userApiService.getUsers().map(responseToDomain)
+      }
     }
   }
 

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

@@ -12,25 +12,25 @@ import androidx.transition.AutoTransition
 import androidx.transition.TransitionManager
 import com.hoc.flowmvi.core.clicks
 import com.hoc.flowmvi.core.firstChange
+import com.hoc.flowmvi.core.launchWhenStartedUntilStopped
 import com.hoc.flowmvi.core.navigator.IntentProviders
 import com.hoc.flowmvi.core.textChanges
 import com.hoc.flowmvi.core.toast
 import com.hoc.flowmvi.ui.add.databinding.ActivityAddBinding
 import kotlinx.coroutines.ExperimentalCoroutinesApi
 import kotlinx.coroutines.FlowPreview
 import kotlinx.coroutines.flow.Flow
-import kotlinx.coroutines.flow.catch
-import kotlinx.coroutines.flow.collect
 import kotlinx.coroutines.flow.launchIn
 import kotlinx.coroutines.flow.map
 import kotlinx.coroutines.flow.merge
 import kotlinx.coroutines.flow.onEach
 import org.koin.androidx.viewmodel.ext.android.viewModel
+import org.koin.androidx.viewmodel.scope.emptyState
 
 @FlowPreview
 @ExperimentalCoroutinesApi
 class AddActivity : AppCompatActivity() {
-  private val addVM by viewModel<AddVM>()
+  private val addVM by viewModel<AddVM>(state = emptyState())
   private val addBinding by lazy { ActivityAddBinding.inflate(layoutInflater) }
 
   override fun onCreate(savedInstanceState: Bundle?) {
@@ -51,16 +51,14 @@ class AddActivity : AppCompatActivity() {
 
   private fun bindVM(addVM: AddVM) {
     // observe view model
-    lifecycleScope.launchWhenStarted {
-      addVM.viewState
-        .onEach { render(it) }
-        .collect()
-    }
-    lifecycleScope.launchWhenStarted {
-      addVM.singleEvent
-        .onEach { handleSingleEvent(it) }
-        .collect()
-    }
+    addVM.viewState
+      .onEach { render(it) }
+      .launchWhenStartedUntilStopped(this)
+
+    // observe single event
+    addVM.singleEvent
+      .onEach { handleSingleEvent(it) }
+      .launchWhenStartedUntilStopped(this)
 
     // pass view intent to view model
     intents()
@@ -124,7 +122,15 @@ class AddActivity : AppCompatActivity() {
     addBinding.addButton.isInvisible = viewState.isLoading
   }
 
-  private fun setupViews() = Unit
+  private fun setupViews() {
+    val state = addVM.viewState.value
+
+    addBinding.run {
+      emailEditText.editText!!.setText(state.email)
+      firstNameEditText.editText!!.setText(state.firstName)
+      lastNameEditText.editText!!.setText(state.lastName)
+    }
+  }
 
   private fun intents(): Flow<ViewIntent> = addBinding.run {
     merge(

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

@@ -11,17 +11,29 @@ internal enum class ValidationError {
 internal data class ViewState(
   val errors: Set<ValidationError>,
   val isLoading: Boolean,
+  //
   val emailChanged: Boolean,
   val firstNameChanged: Boolean,
   val lastNameChanged: Boolean,
+  //
+  val email: String?,
+  val firstName: String?,
+  val lastName: String?
 ) {
   companion object {
-    fun initial() = ViewState(
+    fun initial(
+      email: String?,
+      firstName: String?,
+      lastName: String?
+    ) = ViewState(
       errors = emptySet(),
       isLoading = false,
       emailChanged = false,
       firstNameChanged = false,
       lastNameChanged = false,
+      email = email,
+      firstName = firstName,
+      lastName = lastName,
     )
   }
 }
@@ -72,6 +84,20 @@ internal sealed class PartialStateChange {
       }
     }
   }
+
+  sealed class FormValueChange : PartialStateChange() {
+    override fun reduce(viewState: ViewState): ViewState {
+      return when (this) {
+        is EmailChanged -> viewState.copy(email = email)
+        is FirstNameChanged -> viewState.copy(firstName = firstName)
+        is LastNameChanged -> viewState.copy(lastName = lastName)
+      }
+    }
+
+    data class EmailChanged(val email: String?) : FormValueChange()
+    data class FirstNameChanged(val firstName: String?) : FormValueChange()
+    data class LastNameChanged(val lastName: String?) : FormValueChange()
+  }
 }
 
 internal sealed class SingleEvent {

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

@@ -9,7 +9,12 @@ import org.koin.dsl.module
 @ExperimentalCoroutinesApi
 @FlowPreview
 val addModule = module {
-  viewModel { AddVM(addUser = get()) }
+  viewModel {
+    AddVM(
+      addUser = get(),
+      savedStateHandle = it.get(),
+    )
+  }
 
   single<IntentProviders.Add> { AddActivity.IntentProvider() }
 }