Merge branch 'feature/ui_state' into develop

# Conflicts:
#	build.gradle.kts
#	buildSrc/src/main/kotlin/Dep.kt
#	gradle/wrapper/gradle-wrapper.properties
#	presentation/build.gradle.kts

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
+}

data/src/main/java/io/github/shinhyo/brba/data/repository/CharactersRepositoryImpl.kt

@@ -22,20 +22,50 @@ import io.github.shinhyo.brba.data.mapper.toCharacterEntity
 import io.github.shinhyo.brba.data.remote.api.BaBrApi
 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.combine
-import kotlinx.coroutines.flow.flow
-import kotlinx.coroutines.flow.flowOf
-import kotlinx.coroutines.flow.map
+import io.github.shinhyo.brba.domain.result.Result
+import kotlinx.coroutines.flow.*
+import java.util.*
 import javax.inject.Inject
+import kotlin.random.Random
 
 open class CharactersRepositoryImpl @Inject constructor(
     private val api: BaBrApi,
     private val db: AppDatabase
 ) : CharactersRepository {
 
-    override fun getCharacterList(): Flow<List<Character>> = flow { emit(api.getCharacters()) }
-        .map { it.map { r -> r.toCharacter() } }
+    companion object {
+        const val MIN_RATIO = 1.2f
+    }
+
+    private val random: Random by lazy { Random(Calendar.getInstance().timeInMillis) }
+
+    override fun getCharacterList(): Flow<Result<List<Character>>> {
+
+        fun changeRatio(list: List<Character>) =
+            list.map { c ->
+                val nextInt = random.nextInt(4) * 0.15f
+                c.copy(ratio = MIN_RATIO + nextInt)
+            }
+
+        fun addFavoriteToList(list: List<Character>) =
+            db.characterDao().getAll()
+                .map { dblist ->
+                    list.toMutableList().map {
+                        it.copy(
+                            favorite = dblist.find { i ->
+                                it.charId == i.charId
+                            }?.favorite ?: false
+                        )
+                    }
+                }
+
+        return flow { emit(api.getCharacters()) }
+            .map { it.map { r -> r.toCharacter() } }
+            .map { changeRatio(it) }
+            .flatMapConcat { addFavoriteToList(it) }
+            .map { Result.Success(it) }
+    }
+
 
     override fun getFavoriteList(isAsc: Boolean): Flow<List<Character>> =
         db.characterDao().getFavorite(isAsc = isAsc)
@@ -51,16 +81,6 @@ open class CharactersRepositoryImpl @Inject constructor(
                 res.copy(favorite = entity?.favorite ?: false)
             }
 
-    override fun addFavoriteStatus(listCharacter: List<Character>): Flow<List<Character>> =
-        flowOf(listCharacter)
-            .combine(
-                db.characterDao().getAll()
-            ) { list: List<Character>, db: List<CharacterEntity> ->
-                list.toMutableList().map {
-                    it.copy(favorite = db.find { i -> it.charId == i.charId }?.favorite ?: false)
-                }
-            }
-
     override fun updateFavorite(character: Character): Flow<Boolean> = flowOf(character)
         .map { it.toCharacterEntity().copy(favorite = !character.favorite) }
         .map { db.characterDao().insert(it) }

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/repository/CharactersRepository.kt

@@ -16,12 +16,12 @@
 package io.github.shinhyo.brba.domain.repository
 
 import io.github.shinhyo.brba.domain.model.Character
+import io.github.shinhyo.brba.domain.result.Result
 import kotlinx.coroutines.flow.Flow
 
 interface CharactersRepository {
-    fun getCharacterList(): Flow<List<Character>>
+    fun getCharacterList(): Flow<Result<List<Character>>>
     fun getFavoriteList(isAsc: Boolean = false): Flow<List<Character>>
     fun getCharacterById(id: Long): Flow<Character>
-    fun addFavoriteStatus(listCharacter: List<Character>): Flow<List<Character>>
     fun updateFavorite(character: Character): Flow<Boolean>
 }

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>>
+}

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

@@ -0,0 +1,19 @@
+package io.github.shinhyo.brba.domain.usecase
+
+import io.github.shinhyo.brba.domain.di.IoDispatcher
+import io.github.shinhyo.brba.domain.model.Character
+import io.github.shinhyo.brba.domain.repository.CharactersRepository
+import io.github.shinhyo.brba.domain.result.Result
+import kotlinx.coroutines.CoroutineDispatcher
+import kotlinx.coroutines.flow.Flow
+import javax.inject.Inject
+
+class GetCharacterListUseCase @Inject constructor(
+    private val charactersRepository: CharactersRepository,
+    @IoDispatcher dispatcher: CoroutineDispatcher,
+) : FlowUseCase<Unit, List<Character>>(dispatcher) {
+
+    override fun execute(parameters: Unit): Flow<Result<List<Character>>> =
+        charactersRepository.getCharacterList()
+
+}

presentation/src/main/java/io/github/shinhyo/brba/presentation/ui/NavGraph.kt

@@ -18,6 +18,7 @@ package io.github.shinhyo.brba.presentation.ui
 import androidx.activity.compose.BackHandler
 import androidx.compose.foundation.layout.navigationBarsPadding
 import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.lazy.rememberLazyListState
 import androidx.compose.foundation.rememberScrollState
 import androidx.compose.material.*
 import androidx.compose.runtime.Composable
@@ -100,17 +101,19 @@ fun NavScreen(
     ) {
         val modifier = Modifier.padding(it)
         val listScrollState = rememberScrollState()
+        val favoriteScrollState = rememberLazyListState()
         when (selectedTab.value) {
             BottomNavTabs.LIST -> ListScreen(
-                hiltViewModel(),
-                actions.moveDetail,
-                listScrollState,
-                modifier
+                modifier = modifier,
+                viewModel = hiltViewModel(),
+                scrollState = listScrollState,
+                select = actions.moveDetail,
             )
             BottomNavTabs.FAVORITE -> FavoriteScreen(
-                hiltViewModel(),
-                actions.moveDetail,
-                modifier
+                modifier = modifier,
+                viewModel = hiltViewModel(),
+                scrollState = favoriteScrollState,
+                select = actions.moveDetail,
             )
         }
     }

presentation/src/main/java/io/github/shinhyo/brba/presentation/ui/favorite/FavoriteScreen.kt

@@ -19,6 +19,7 @@ import androidx.compose.foundation.background
 import androidx.compose.foundation.clickable
 import androidx.compose.foundation.layout.*
 import androidx.compose.foundation.lazy.LazyColumn
+import androidx.compose.foundation.lazy.LazyListState
 import androidx.compose.foundation.lazy.items
 import androidx.compose.material.Card
 import androidx.compose.material.Icon
@@ -47,27 +48,51 @@ import io.github.shinhyo.brba.presentation.ui.common.IconFavorite
 
 @Composable
 fun FavoriteScreen(
+    modifier: Modifier = Modifier,
     viewModel: FavoriteViewModel,
+    scrollState: LazyListState,
+    select: (Character) -> Unit,
+) {
+    Body(
+        modifier = modifier,
+        viewModel = viewModel,
+        scrollState = scrollState,
+        select = select,
+    )
+}
+
+@Composable
+private fun Body(
+    modifier: Modifier,
+    viewModel: FavoriteViewModel,
+    scrollState: LazyListState,
     select: (Character) -> Unit,
-    modifier: Modifier = Modifier
 ) {
     val list = viewModel.list.collectAsState()
     if (list.value.isEmpty()) {
         EmptyScreen()
     } else {
-        ListScreen(modifier, list, select, viewModel)
+        ListScreen(
+            modifier = modifier,
+            list = list,
+            select = select,
+            viewModel = viewModel,
+            state = scrollState
+        )
     }
 }
 
 @Composable
 private fun ListScreen(
     modifier: Modifier,
+    viewModel: FavoriteViewModel,
     list: State<List<Character>>,
+    state: LazyListState,
     select: (Character) -> Unit,
-    viewModel: FavoriteViewModel
 ) {
     LazyColumn(
         modifier = modifier,
+        state = state,
         contentPadding = PaddingValues(start = 8.dp, top = 32.dp, end = 8.dp, bottom = 32.dp),
         verticalArrangement = Arrangement.spacedBy(8.dp),
     ) {