feat: add FlowUseCase

Author: shinhyo

app/src/main/java/io/github/shinhyo/brba/app/di/CoroutinesModule.kt

@@ -0,0 +1,32 @@
+package io.github.shinhyo.brba.app.di
+
+import dagger.Module
+import dagger.Provides
+import dagger.hilt.InstallIn
+import dagger.hilt.components.SingletonComponent
+import io.github.shinhyo.brba.domain.di.DefaultDispatcher
+import io.github.shinhyo.brba.domain.di.IoDispatcher
+import io.github.shinhyo.brba.domain.di.MainDispatcher
+import io.github.shinhyo.brba.domain.di.MainImmediateDispatcher
+import kotlinx.coroutines.CoroutineDispatcher
+import kotlinx.coroutines.Dispatchers
+
+@InstallIn(SingletonComponent::class)
+@Module
+internal object CoroutinesModule {
+    @DefaultDispatcher
+    @Provides
+    fun providesDefaultDispatcher(): CoroutineDispatcher = Dispatchers.Default
+
+    @IoDispatcher
+    @Provides
+    fun providesIoDispatcher(): CoroutineDispatcher = Dispatchers.IO
+
+    @MainDispatcher
+    @Provides
+    fun providesMainDispatcher(): CoroutineDispatcher = Dispatchers.Main
+
+    @MainImmediateDispatcher
+    @Provides
+    fun providesMainImmediateDispatcher(): CoroutineDispatcher = Dispatchers.Main.immediate
+}

domain/src/main/java/io/github/shinhyo/brba/domain/di/CoroutinesQualifiers.kt

@@ -0,0 +1,19 @@
+package io.github.shinhyo.brba.domain.di
+
+import javax.inject.Qualifier
+
+@Retention(AnnotationRetention.BINARY)
+@Qualifier
+annotation class DefaultDispatcher
+
+@Retention(AnnotationRetention.BINARY)
+@Qualifier
+annotation class IoDispatcher
+
+@Retention(AnnotationRetention.BINARY)
+@Qualifier
+annotation class MainDispatcher
+
+@Retention(AnnotationRetention.BINARY)
+@Qualifier
+annotation class MainImmediateDispatcher

domain/src/main/java/io/github/shinhyo/brba/domain/result/Result.kt

@@ -0,0 +1,45 @@
+package io.github.shinhyo.brba.domain.result
+
+import io.github.shinhyo.brba.domain.result.Result.Success
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.map
+
+/**
+ * A generic class that holds a value with its loading status.
+ * @param <T>
+ */
+sealed class Result<out R> {
+
+    data class Success<out T>(val data: T) : Result<T>()
+    data class Error(val exception: Exception) : Result<Nothing>()
+
+    override fun toString(): String {
+        return when (this) {
+            is Success<*> -> "Success[data=$data]"
+            is Error -> "Error[exception=$exception]"
+        }
+    }
+}
+
+/**
+ * `true` if [Result] is of type [Success] & holds non-null [Success.data].
+ */
+val Result<*>.succeeded
+    get() = this is Success && data != null
+
+fun <T> Result<T>.successOr(fallback: T): T {
+    return (this as? Success<T>)?.data ?: fallback
+}
+
+inline fun <R, T> Result<T>.mapTransform(transform: (T) -> R): Result<R> = when (this) {
+    is Result.Success -> Result.Success(transform(data))
+    is Result.Error -> Result.Error(exception)
+}
+
+inline fun <R, T> Flow<Result<T>>.mapTransform(crossinline transform: (T) -> R): Flow<Result<R>> =
+    this.map {
+        when (it) {
+            is Result.Success -> Result.Success(transform(it.data))
+            is Result.Error -> Result.Error(it.exception)
+        }
+    }

domain/src/main/java/io/github/shinhyo/brba/domain/usecase/CharactersUseCase.kt

@@ -18,19 +18,7 @@ package io.github.shinhyo.brba.domain.usecase
 import io.github.shinhyo.brba.domain.model.Character
 import io.github.shinhyo.brba.domain.repository.CharactersRepository
 import kotlinx.coroutines.flow.Flow
-import kotlinx.coroutines.flow.map
-import java.util.Calendar
 import javax.inject.Inject
-import kotlin.random.Random
-
-class GetCharacterListUseCase @Inject constructor(
-    private val repo: CharactersRepository
-) {
-    private val random: Random by lazy { Random(Calendar.getInstance().timeInMillis) }
-
-    fun execute(): Flow<List<Character>> = repo.getCharacterList()
-        .map { it.map { c -> c.copy(ratio = random.nextInt(4).let { r -> 1.4f + r * 0.15f }) } }
-}
 
 class GetFavoriteListUseCase @Inject constructor(
     private val repo: CharactersRepository
@@ -44,12 +32,6 @@ class GetCharacterUseCase @Inject constructor(
     fun execute(id: Long): Flow<Character> = repo.getCharacterById(id)
 }
 
-class AddFavoriteToListUseCase @Inject constructor(
-    private val repo: CharactersRepository
-) {
-    fun execute(list: List<Character>): Flow<List<Character>> = repo.addFavoriteStatus(list)
-}
-
 class UpdateFavoriteUseCase @Inject constructor(
     private val repo: CharactersRepository
 ) {

domain/src/main/java/io/github/shinhyo/brba/domain/usecase/FlowUseCase.kt

@@ -0,0 +1,21 @@
+package io.github.shinhyo.brba.domain.usecase
+
+import io.github.shinhyo.brba.domain.result.Result
+import kotlinx.coroutines.CoroutineDispatcher
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.catch
+import kotlinx.coroutines.flow.flowOn
+
+/**
+ * Executes business logic in its execute method and keep posting updates to the result as
+ * [Result<R>].
+ * Handling an exception (emit [Result.Error] to the result) is the subclasses's responsibility.
+ */
+abstract class FlowUseCase<in P, R>(private val coroutineDispatcher: CoroutineDispatcher) {
+    operator fun invoke(parameters: P): Flow<Result<R>> = execute(parameters)
+        .catch { e -> emit(Result.Error(Exception(e))) }
+        .flowOn(coroutineDispatcher)
+
+
+    protected abstract fun execute(parameters: P): Flow<Result<R>>
+}

presentation/build.gradle.kts

@@ -25,6 +25,7 @@ dependencies {
     implementation(Dep.AndroidX.Compose.material)
     implementation(Dep.AndroidX.Compose.materialIcons)
 
+    implementation(Dep.AndroidX.Lifecycle.runtime)
     implementation(Dep.AndroidX.Lifecycle.viewModelCompose)
     implementation(Dep.AndroidX.Navigation.navigationCompose)
     implementation(Dep.AndroidX.ConstraintLayout.compose)
@@ -39,6 +40,8 @@ dependencies {
     implementation(Dep.AndroidX.Hilt.navigationFragment)
     implementation(Dep.AndroidX.Hilt.navigationCompose)
 
+    implementation(Dep.timber)
+
     testImplementation(Dep.Test.junit)
     androidTestImplementation(Dep.Test.junitExt)
     androidTestImplementation(Dep.Test.espresso)

presentation/src/main/java/io/github/shinhyo/brba/presentation/utils/Flow.kt

@@ -0,0 +1,41 @@
+package io.github.shinhyo.brba.presentation.utils
+
+import android.annotation.SuppressLint
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.State
+import androidx.compose.runtime.collectAsState
+import androidx.compose.runtime.remember
+import androidx.compose.ui.platform.LocalLifecycleOwner
+import androidx.lifecycle.Lifecycle
+import androidx.lifecycle.LifecycleOwner
+import androidx.lifecycle.flowWithLifecycle
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.StateFlow
+import kotlin.coroutines.CoroutineContext
+import kotlin.coroutines.EmptyCoroutineContext
+
+@Composable
+fun <T> rememberFlow(
+    flow: Flow<T>,
+    lifecycleOwner: LifecycleOwner = LocalLifecycleOwner.current
+): Flow<T> {
+    return remember(
+        key1 = flow,
+        key2 = lifecycleOwner
+    ) { flow.flowWithLifecycle(lifecycleOwner.lifecycle, Lifecycle.State.STARTED) }
+}
+
+@Composable
+fun <T : R, R> Flow<T>.collectAsStateLifecycleAware(
+    initial: R,
+    context: CoroutineContext = EmptyCoroutineContext
+): State<R> {
+    val lifecycleAwareFlow = rememberFlow(flow = this)
+    return lifecycleAwareFlow.collectAsState(initial = initial, context = context)
+}
+
+@SuppressLint("StateFlowValueCalledInComposition")
+@Composable
+fun <T> StateFlow<T>.collectAsStateLifecycleAware(
+    context: CoroutineContext = EmptyCoroutineContext
+): State<T> = collectAsStateLifecycleAware(value, context)