Refactor: DailyEmotion 데이터 흐름을 Flow 기반 관찰 방식으로 변경

Author: wjdrjs00

data/src/main/java/com/threegap/bitnagil/data/emotion/model/response/DailyEmotionResponse.kt

@@ -4,6 +4,7 @@ import com.threegap.bitnagil.domain.emotion.model.DailyEmotion
 import com.threegap.bitnagil.domain.emotion.model.EmotionMarbleType
 import kotlinx.serialization.SerialName
 import kotlinx.serialization.Serializable
+import java.time.LocalDate
 
 @Serializable
 data class DailyEmotionResponse(
@@ -23,4 +24,5 @@ fun DailyEmotionResponse.toDomain(): DailyEmotion =
         name = emotionMarbleName,
         imageUrl = imageUrl,
         homeMessage = emotionMarbleHomeMessage,
+        fetchedDate = LocalDate.now(),
     )

data/src/main/java/com/threegap/bitnagil/data/emotion/repositoryImpl/EmotionRepositoryImpl.kt

@@ -4,17 +4,24 @@ import com.threegap.bitnagil.data.emotion.datasource.EmotionDataSource
 import com.threegap.bitnagil.data.emotion.model.response.toDomain
 import com.threegap.bitnagil.domain.emotion.model.DailyEmotion
 import com.threegap.bitnagil.domain.emotion.model.Emotion
-import com.threegap.bitnagil.domain.emotion.model.EmotionChangeEvent
 import com.threegap.bitnagil.domain.emotion.model.EmotionRecommendRoutine
 import com.threegap.bitnagil.domain.emotion.repository.EmotionRepository
 import kotlinx.coroutines.flow.Flow
-import kotlinx.coroutines.flow.MutableSharedFlow
-import kotlinx.coroutines.flow.asSharedFlow
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.onSubscription
+import java.time.LocalDate
 import javax.inject.Inject
 
 class EmotionRepositoryImpl @Inject constructor(
     private val emotionDataSource: EmotionDataSource,
 ) : EmotionRepository {
+
+    private val _dailyEmotionFlow = MutableStateFlow(DailyEmotion.INIT)
+    override val dailyEmotionFlow: Flow<DailyEmotion> = _dailyEmotionFlow
+        .onSubscription {
+            if (_dailyEmotionFlow.value.isStale) fetchDailyEmotion()
+        }
+
     override suspend fun getEmotions(): Result<List<Emotion>> {
         return emotionDataSource.getEmotions().map { response ->
             response.map { it.toDomain() }
@@ -23,20 +30,18 @@ class EmotionRepositoryImpl @Inject constructor(
 
     override suspend fun registerEmotion(emotionMarbleType: String): Result<List<EmotionRecommendRoutine>> {
         return emotionDataSource.registerEmotion(emotionMarbleType).map {
-            it.recommendedRoutines.map {
-                    emotionRecommendedRoutineDto ->
+            it.recommendedRoutines.map { emotionRecommendedRoutineDto ->
                 emotionRecommendedRoutineDto.toEmotionRecommendRoutine()
             }
         }.also {
-            if (it.isSuccess) {
-                _emotionChangeEventFlow.emit(EmotionChangeEvent.ChangeEmotion(emotionMarbleType))
-            }
+            if (it.isSuccess) fetchDailyEmotion()
         }
     }
 
-    override suspend fun fetchDailyEmotion(currentDate: String): Result<DailyEmotion> =
-        emotionDataSource.fetchDailyEmotion(currentDate).map { it.toDomain() }
-
-    private val _emotionChangeEventFlow = MutableSharedFlow<EmotionChangeEvent>()
-    override suspend fun getEmotionChangeEventFlow(): Flow<EmotionChangeEvent> = _emotionChangeEventFlow.asSharedFlow()
+    override suspend fun fetchDailyEmotion(): Result<Unit> {
+        val currentDate = LocalDate.now().toString()
+        return emotionDataSource.fetchDailyEmotion(currentDate).map {
+            _dailyEmotionFlow.value = it.toDomain()
+        }
+    }
 }

domain/src/main/java/com/threegap/bitnagil/domain/emotion/model/DailyEmotion.kt

@@ -1,8 +1,24 @@
 package com.threegap.bitnagil.domain.emotion.model
 
+import java.time.LocalDate
+
 data class DailyEmotion(
     val type: EmotionMarbleType?,
     val name: String?,
     val imageUrl: String?,
     val homeMessage: String?,
-)
+    val fetchedDate: LocalDate = LocalDate.MIN,
+) {
+    val isStale: Boolean
+        get() = fetchedDate != LocalDate.now()
+
+    companion object {
+        val INIT = DailyEmotion(
+            type = null,
+            name = null,
+            imageUrl = null,
+            homeMessage = null,
+            fetchedDate = LocalDate.MIN,
+        )
+    }
+}

domain/src/main/java/com/threegap/bitnagil/domain/emotion/model/EmotionChangeEvent.kt

@@ -2,13 +2,12 @@ package com.threegap.bitnagil.domain.emotion.repository
 
 import com.threegap.bitnagil.domain.emotion.model.DailyEmotion
 import com.threegap.bitnagil.domain.emotion.model.Emotion
-import com.threegap.bitnagil.domain.emotion.model.EmotionChangeEvent
 import com.threegap.bitnagil.domain.emotion.model.EmotionRecommendRoutine
 import kotlinx.coroutines.flow.Flow
 
 interface EmotionRepository {
+    val dailyEmotionFlow: Flow<DailyEmotion>
     suspend fun getEmotions(): Result<List<Emotion>>
     suspend fun registerEmotion(emotionMarbleType: String): Result<List<EmotionRecommendRoutine>>
-    suspend fun fetchDailyEmotion(currentDate: String): Result<DailyEmotion>
-    suspend fun getEmotionChangeEventFlow(): Flow<EmotionChangeEvent>
+    suspend fun fetchDailyEmotion(): Result<Unit>
 }

domain/src/main/java/com/threegap/bitnagil/domain/emotion/repository/EmotionRepository.kt

@@ -2,14 +2,11 @@ package com.threegap.bitnagil.domain.emotion.usecase
 
 import com.threegap.bitnagil.domain.emotion.model.DailyEmotion
 import com.threegap.bitnagil.domain.emotion.repository.EmotionRepository
-import java.time.LocalDate
+import kotlinx.coroutines.flow.Flow
 import javax.inject.Inject
 
-class FetchDailyEmotionUseCase @Inject constructor(
+class ObserveDailyEmotionUseCase @Inject constructor(
     private val emotionRepository: EmotionRepository,
 ) {
-    suspend operator fun invoke(): Result<DailyEmotion> {
-        val currentDate = LocalDate.now().toString()
-        return emotionRepository.fetchDailyEmotion(currentDate)
-    }
+    operator fun invoke(): Flow<DailyEmotion> = emotionRepository.dailyEmotionFlow
 }

domain/src/main/java/com/threegap/bitnagil/domain/emotion/usecase/GetEmotionChangeEventFlowUseCase.kt

@@ -2,8 +2,7 @@ package com.threegap.bitnagil.presentation.screen.home
 
 import android.util.Log
 import androidx.lifecycle.ViewModel
-import com.threegap.bitnagil.domain.emotion.usecase.FetchDailyEmotionUseCase
-import com.threegap.bitnagil.domain.emotion.usecase.GetEmotionChangeEventFlowUseCase
+import com.threegap.bitnagil.domain.emotion.usecase.ObserveDailyEmotionUseCase
 import com.threegap.bitnagil.domain.onboarding.usecase.GetOnBoardingRecommendRoutineEventFlowUseCase
 import com.threegap.bitnagil.domain.routine.model.RoutineCompletionInfo
 import com.threegap.bitnagil.domain.routine.model.RoutineCompletionInfos
@@ -34,12 +33,11 @@ import javax.inject.Inject
 
 @HiltViewModel
 class HomeViewModel @Inject constructor(
+    private val observeDailyEmotionUseCase: ObserveDailyEmotionUseCase,
     private val fetchWeeklyRoutinesUseCase: FetchWeeklyRoutinesUseCase,
     private val fetchUserProfileUseCase: FetchUserProfileUseCase,
-    private val fetchDailyEmotionUseCase: FetchDailyEmotionUseCase,
     private val routineCompletionUseCase: RoutineCompletionUseCase,
     private val getWriteRoutineEventFlowUseCase: GetWriteRoutineEventFlowUseCase,
-    private val getEmotionChangeEventFlowUseCase: GetEmotionChangeEventFlowUseCase,
     private val getOnBoardingRecommendRoutineEventFlowUseCase: GetOnBoardingRecommendRoutineEventFlowUseCase,
     private val toggleRoutineUseCase: ToggleRoutineUseCase,
 ) : ContainerHost<HomeState, HomeSideEffect>, ViewModel() {
@@ -51,6 +49,17 @@ class HomeViewModel @Inject constructor(
 
     init {
         initialize()
+        observeDailyEmotion()
+    }
+
+    private fun observeDailyEmotion() {
+        intent {
+            repeatOnSubscription {
+                observeDailyEmotionUseCase()
+                    .map { it.toUiModel() }
+                    .collect { reduce { state.copy(dailyEmotion = it) } }
+            }
+        }
     }
 
     fun selectDate(data: LocalDate) {
@@ -186,10 +195,8 @@ class HomeViewModel @Inject constructor(
         intent {
             coroutineScope {
                 launch { fetchUserProfile() }
-                launch { fetchDailyEmotion() }
                 launch { fetchWeeklyRoutines(state.currentWeeks) }
                 launch { observeWriteRoutineEvent() }
-                launch { observeEmotionChangeEvent() }
                 launch { observeRecommendRoutineEvent() }
                 launch { observeWeekChanges() }
                 launch { observeRoutineUpdates() }
@@ -205,14 +212,6 @@ class HomeViewModel @Inject constructor(
         }
     }
 
-    private suspend fun observeEmotionChangeEvent() {
-        subIntent {
-            getEmotionChangeEventFlowUseCase().collect {
-                fetchDailyEmotion()
-            }
-        }
-    }
-
     private suspend fun observeRecommendRoutineEvent() {
         subIntent {
             getOnBoardingRecommendRoutineEventFlowUseCase().collect {
@@ -278,21 +277,6 @@ class HomeViewModel @Inject constructor(
         }
     }
 
-    private suspend fun fetchDailyEmotion() {
-        subIntent {
-            reduce { state.copy(loadingCount = state.loadingCount + 1) }
-            fetchDailyEmotionUseCase().fold(
-                onSuccess = {
-                    reduce { state.copy(dailyEmotion = it.toUiModel(), loadingCount = state.loadingCount - 1) }
-                },
-                onFailure = {
-                    Log.e("HomeViewModel", "나의 감정 실패: ${it.message}")
-                    reduce { state.copy(loadingCount = state.loadingCount - 1) }
-                },
-            )
-        }
-    }
-
     private fun syncRoutineChangesForDate(dateKey: String) {
         intent {
             val dateChanges = pendingChangesByDate.remove(dateKey)

…tion/usecase/FetchDailyEmotionUseCase.kt …on/usecase/ObserveDailyEmotionUseCase.ktdomain/src/main/java/com/threegap/bitnagil/domain/emotion/usecase/FetchDailyEmotionUseCase.kt renamed to domain/src/main/java/com/threegap/bitnagil/domain/emotion/usecase/ObserveDailyEmotionUseCase.kt domain/src/main/java/com/threegap/bitnagil/domain/emotion/usecase/FetchDailyEmotionUseCase.kt renamed to domain/src/main/java/com/threegap/bitnagil/domain/emotion/usecase/ObserveDailyEmotionUseCase.kt

@@ -1,8 +1,7 @@
 package com.threegap.bitnagil.presentation.screen.recommendroutine
 
 import androidx.lifecycle.ViewModel
-import androidx.lifecycle.viewModelScope
-import com.threegap.bitnagil.domain.emotion.usecase.GetEmotionChangeEventFlowUseCase
+import com.threegap.bitnagil.domain.emotion.usecase.ObserveDailyEmotionUseCase
 import com.threegap.bitnagil.domain.recommendroutine.model.RecommendCategory
 import com.threegap.bitnagil.domain.recommendroutine.model.RecommendLevel
 import com.threegap.bitnagil.domain.recommendroutine.usecase.FetchRecommendRoutinesUseCase
@@ -12,25 +11,32 @@ import com.threegap.bitnagil.presentation.screen.recommendroutine.model.Recommen
 import com.threegap.bitnagil.presentation.screen.recommendroutine.model.RecommendRoutinesUiModel
 import com.threegap.bitnagil.presentation.screen.recommendroutine.model.toUiModel
 import dagger.hilt.android.lifecycle.HiltViewModel
-import kotlinx.coroutines.launch
+import kotlinx.coroutines.flow.distinctUntilChanged
+import kotlinx.coroutines.flow.map
 import org.orbitmvi.orbit.Container
 import org.orbitmvi.orbit.ContainerHost
 import org.orbitmvi.orbit.viewmodel.container
 import javax.inject.Inject
 
 @HiltViewModel
 class RecommendRoutineViewModel @Inject constructor(
+    private val observeDailyEmotionUseCase: ObserveDailyEmotionUseCase,
     private val fetchRecommendRoutinesUseCase: FetchRecommendRoutinesUseCase,
-    private val getEmotionChangeEventFlowUseCase: GetEmotionChangeEventFlowUseCase,
 ) : ContainerHost<RecommendRoutineState, RecommendRoutineSideEffect>, ViewModel() {
 
     override val container: Container<RecommendRoutineState, RecommendRoutineSideEffect> =
-        container(initialState = RecommendRoutineState.INIT)
-
-    init {
-        loadRecommendRoutines()
-        observeEmotionChangeEvent()
-    }
+        container(
+            initialState = RecommendRoutineState.INIT,
+            buildSettings = { repeatOnSubscribedStopTimeout = 5_000L },
+            onCreate = {
+                repeatOnSubscription {
+                    observeDailyEmotionUseCase()
+                        .map { it.type }
+                        .distinctUntilChanged()
+                        .collect { loadRecommendRoutines() }
+                }
+            },
+        )
 
     private var recommendRoutines: RecommendRoutinesUiModel = RecommendRoutinesUiModel.INIT
 
@@ -80,14 +86,6 @@ class RecommendRoutineViewModel @Inject constructor(
         }
     }
 
-    private fun observeEmotionChangeEvent() {
-        viewModelScope.launch {
-            getEmotionChangeEventFlowUseCase().collect {
-                loadRecommendRoutines()
-            }
-        }
-    }
-
     private fun loadRecommendRoutines() {
         intent {
             reduce { state.copy(isLoading = true) }