[Refactor/#192] DailyEmotion 데이터 흐름 개선

app/src/main/java/com/threegap/bitnagil/di/data/DataSourceModule.kt

@@ -8,8 +8,10 @@ import com.threegap.bitnagil.data.auth.datasource.AuthLocalDataSource
 import com.threegap.bitnagil.data.auth.datasource.AuthRemoteDataSource
 import com.threegap.bitnagil.data.auth.datasourceimpl.AuthLocalDataSourceImpl
 import com.threegap.bitnagil.data.auth.datasourceimpl.AuthRemoteDataSourceImpl
-import com.threegap.bitnagil.data.emotion.datasource.EmotionDataSource
-import com.threegap.bitnagil.data.emotion.datasourceImpl.EmotionDataSourceImpl
+import com.threegap.bitnagil.data.emotion.datasource.EmotionLocalDataSource
+import com.threegap.bitnagil.data.emotion.datasource.EmotionRemoteDataSource
+import com.threegap.bitnagil.data.emotion.datasourceImpl.EmotionLocalDataSourceImpl
+import com.threegap.bitnagil.data.emotion.datasourceImpl.EmotionRemoteDataSourceImpl
 import com.threegap.bitnagil.data.file.datasource.FileDataSource
 import com.threegap.bitnagil.data.file.datasourceImpl.FileDataSourceImpl
 import com.threegap.bitnagil.data.onboarding.datasource.OnBoardingDataSource
@@ -52,7 +54,11 @@ abstract class DataSourceModule {
 
     @Binds
     @Singleton
-    abstract fun bindEmotionDataSource(emotionDataSourceImpl: EmotionDataSourceImpl): EmotionDataSource
+    abstract fun bindEmotionLocalDataSource(emotionLocalDataSourceImpl: EmotionLocalDataSourceImpl): EmotionLocalDataSource
+
+    @Binds
+    @Singleton
+    abstract fun bindEmotionRemoteDataSource(emotionRemoteDataSourceImpl: EmotionRemoteDataSourceImpl): EmotionRemoteDataSource
 
     @Binds
     @Singleton

data/src/main/java/com/threegap/bitnagil/data/emotion/datasource/EmotionLocalDataSource.kt

@@ -0,0 +1,10 @@
+package com.threegap.bitnagil.data.emotion.datasource
+
+import com.threegap.bitnagil.domain.emotion.model.DailyEmotion
+import kotlinx.coroutines.flow.StateFlow
+
+interface EmotionLocalDataSource {
+    val dailyEmotion: StateFlow<DailyEmotion?>
+    fun saveDailyEmotion(dailyEmotion: DailyEmotion)
+    fun clearCache()
+}

data/src/main/java/com/threegap/bitnagil/data/emotion/datasource/EmotionDataSource.kt → data/src/main/java/com/threegap/bitnagil/data/emotion/datasource/EmotionRemoteDataSource.kt

@@ -4,7 +4,7 @@ import com.threegap.bitnagil.data.emotion.model.dto.EmotionDto
 import com.threegap.bitnagil.data.emotion.model.response.DailyEmotionResponse
 import com.threegap.bitnagil.data.emotion.model.response.RegisterEmotionResponse
 
-interface EmotionDataSource {
+interface EmotionRemoteDataSource {
     suspend fun getEmotions(): Result<List<EmotionDto>>
     suspend fun registerEmotion(emotion: String): Result<RegisterEmotionResponse>
     suspend fun fetchDailyEmotion(currentDate: String): Result<DailyEmotionResponse>

data/src/main/java/com/threegap/bitnagil/data/emotion/datasourceImpl/EmotionLocalDataSourceImpl.kt

@@ -0,0 +1,22 @@
+package com.threegap.bitnagil.data.emotion.datasourceImpl
+
+import com.threegap.bitnagil.data.emotion.datasource.EmotionLocalDataSource
+import com.threegap.bitnagil.domain.emotion.model.DailyEmotion
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.flow.asStateFlow
+import kotlinx.coroutines.flow.update
+import javax.inject.Inject
+
+class EmotionLocalDataSourceImpl @Inject constructor() : EmotionLocalDataSource {
+    private val _dailyEmotion = MutableStateFlow<DailyEmotion?>(null)
+    override val dailyEmotion: StateFlow<DailyEmotion?> = _dailyEmotion.asStateFlow()
+
+    override fun saveDailyEmotion(dailyEmotion: DailyEmotion) {
+        _dailyEmotion.update { dailyEmotion }
+    }
+
+    override fun clearCache() {
+        _dailyEmotion.update { null }
+    }
+}

data/src/main/java/com/threegap/bitnagil/data/emotion/datasourceImpl/EmotionDataSourceImpl.kt → data/src/main/java/com/threegap/bitnagil/data/emotion/datasourceImpl/EmotionRemoteDataSourceImpl.kt

@@ -1,17 +1,17 @@
 package com.threegap.bitnagil.data.emotion.datasourceImpl
 
 import com.threegap.bitnagil.data.common.safeApiCall
-import com.threegap.bitnagil.data.emotion.datasource.EmotionDataSource
+import com.threegap.bitnagil.data.emotion.datasource.EmotionRemoteDataSource
 import com.threegap.bitnagil.data.emotion.model.dto.EmotionDto
 import com.threegap.bitnagil.data.emotion.model.request.RegisterEmotionRequest
 import com.threegap.bitnagil.data.emotion.model.response.DailyEmotionResponse
 import com.threegap.bitnagil.data.emotion.model.response.RegisterEmotionResponse
 import com.threegap.bitnagil.data.emotion.service.EmotionService
 import javax.inject.Inject
 
-class EmotionDataSourceImpl @Inject constructor(
+class EmotionRemoteDataSourceImpl @Inject constructor(
     private val emotionService: EmotionService,
-) : EmotionDataSource {
+) : EmotionRemoteDataSource {
     override suspend fun getEmotions(): Result<List<EmotionDto>> {
         return safeApiCall {
             emotionService.getEmotions()

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(
@@ -17,10 +18,11 @@ data class DailyEmotionResponse(
     val emotionMarbleHomeMessage: String?,
 )
 
-fun DailyEmotionResponse.toDomain(): DailyEmotion =
+fun DailyEmotionResponse.toDomain(fetchedDate: LocalDate): DailyEmotion =
     DailyEmotion(
         type = emotionMarbleType,
         name = emotionMarbleName,
         imageUrl = imageUrl,
         homeMessage = emotionMarbleHomeMessage,
+        fetchedDate = fetchedDate,
     )

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

@@ -1,42 +1,84 @@
 package com.threegap.bitnagil.data.emotion.repositoryImpl
 
-import com.threegap.bitnagil.data.emotion.datasource.EmotionDataSource
+import com.threegap.bitnagil.data.emotion.datasource.EmotionLocalDataSource
+import com.threegap.bitnagil.data.emotion.datasource.EmotionRemoteDataSource
 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.emitAll
+import kotlinx.coroutines.flow.filterNotNull
+import kotlinx.coroutines.flow.flow
+import kotlinx.coroutines.flow.map
+import kotlinx.coroutines.sync.Mutex
+import kotlinx.coroutines.sync.withLock
+import java.time.LocalDate
 import javax.inject.Inject
 
 class EmotionRepositoryImpl @Inject constructor(
-    private val emotionDataSource: EmotionDataSource,
+    private val emotionRemoteDataSource: EmotionRemoteDataSource,
+    private val emotionLocalDateSource: EmotionLocalDataSource,
 ) : EmotionRepository {
+
+    private val fetchMutex = Mutex()
+
     override suspend fun getEmotions(): Result<List<Emotion>> {
-        return emotionDataSource.getEmotions().map { response ->
+        return emotionRemoteDataSource.getEmotions().map { response ->
             response.map { it.toDomain() }
         }
     }
 
     override suspend fun registerEmotion(emotionMarbleType: String): Result<List<EmotionRecommendRoutine>> {
-        return emotionDataSource.registerEmotion(emotionMarbleType).map {
-            it.recommendedRoutines.map {
-                    emotionRecommendedRoutineDto ->
+        return emotionRemoteDataSource.registerEmotion(emotionMarbleType).map {
+            it.recommendedRoutines.map { emotionRecommendedRoutineDto ->
                 emotionRecommendedRoutineDto.toEmotionRecommendRoutine()
             }
         }.also {
-            if (it.isSuccess) {
-                _emotionChangeEventFlow.emit(EmotionChangeEvent.ChangeEmotion(emotionMarbleType))
-            }
+            if (it.isSuccess) fetchAndSaveDailyEmotion(today = LocalDate.now(), forceRefresh = true)
         }
     }
 
-    override suspend fun fetchDailyEmotion(currentDate: String): Result<DailyEmotion> =
-        emotionDataSource.fetchDailyEmotion(currentDate).map { it.toDomain() }
+    override fun observeDailyEmotion(): Flow<Result<DailyEmotion>> = flow {
+        fetchAndSaveDailyEmotion(LocalDate.now())
+            .onFailure {
+                emit(Result.failure(it))
+                return@flow
+            }
+
+        emitAll(
+            emotionLocalDateSource.dailyEmotion
+                .filterNotNull()
+                .map { Result.success(it) },
+        )
+    }
+
+    override fun clearCache() {
+        emotionLocalDateSource.clearCache()
+    }
+
+    private suspend fun fetchAndSaveDailyEmotion(
+        today: LocalDate,
+        forceRefresh: Boolean = false,
+    ): Result<DailyEmotion> {
+        if (!forceRefresh) {
+            val currentLocalData = emotionLocalDateSource.dailyEmotion.value
+            if (currentLocalData != null && !currentLocalData.isStale(today)) {
+                return Result.success(currentLocalData)
+            }
+        }
 
-    private val _emotionChangeEventFlow = MutableSharedFlow<EmotionChangeEvent>()
-    override suspend fun getEmotionChangeEventFlow(): Flow<EmotionChangeEvent> = _emotionChangeEventFlow.asSharedFlow()
+        return fetchMutex.withLock {
+            if (!forceRefresh) {
+                val doubleCheckData = emotionLocalDateSource.dailyEmotion.value
+                if (doubleCheckData != null && !doubleCheckData.isStale(today)) {
+                    return@withLock Result.success(doubleCheckData)
+                }
+            }
+            emotionRemoteDataSource.fetchDailyEmotion(today.toString())
+                .onSuccess { emotionLocalDateSource.saveDailyEmotion(it.toDomain(today)) }
+                .map { it.toDomain(today) }
+        }
+    }
 }

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

@@ -1,8 +1,23 @@
 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,
+) {
+    fun isStale(today: LocalDate): Boolean = fetchedDate != today
+
+    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/repository/EmotionRepository.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 {
     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>
+    fun observeDailyEmotion(): Flow<Result<DailyEmotion>>
+    fun clearCache()
 }

domain/src/main/java/com/threegap/bitnagil/domain/emotion/usecase/FetchDailyEmotionUseCase.kt → domain/src/main/java/com/threegap/bitnagil/domain/emotion/usecase/ObserveDailyEmotionUseCase.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<Result<DailyEmotion>> = emotionRepository.observeDailyEmotion()
 }

presentation/src/main/java/com/threegap/bitnagil/presentation/screen/home/HomeViewModel.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,23 +33,42 @@ 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() {
 
-    override val container: Container<HomeState, HomeSideEffect> = container(initialState = HomeState.INIT)
+    override val container: Container<HomeState, HomeSideEffect> =
+        container(
+            initialState = HomeState.INIT,
+            buildSettings = { repeatOnSubscribedStopTimeout = 5_000L },
+        )
 
     private val pendingChangesByDate = mutableMapOf<String, MutableMap<String, RoutineCompletionInfo>>()
     private val routineSyncTrigger = MutableSharedFlow<String>(extraBufferCapacity = 64)
 
     init {
         initialize()
+        observeDailyEmotion()
+    }
+
+    private fun observeDailyEmotion() {
+        intent {
+            repeatOnSubscription {
+                observeDailyEmotionUseCase().collect { result ->
+                    result.fold(
+                        onSuccess = { dailyEmotion ->
+                            reduce { state.copy(dailyEmotion = dailyEmotion.toUiModel()) }
+                        },
+                        onFailure = {},
+                    )
+                }
+            }
+        }
     }
 
     fun selectDate(data: LocalDate) {
@@ -186,10 +204,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 +221,6 @@ class HomeViewModel @Inject constructor(
         }
     }
 
-    private suspend fun observeEmotionChangeEvent() {
-        subIntent {
-            getEmotionChangeEventFlowUseCase().collect {
-                fetchDailyEmotion()
-            }
-        }
-    }
-
     private suspend fun observeRecommendRoutineEvent() {
         subIntent {
             getOnBoardingRecommendRoutineEventFlowUseCase().collect {
@@ -278,21 +286,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)