[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
@@ -20,8 +22,10 @@ import com.threegap.bitnagil.data.report.datasource.ReportDataSource
 import com.threegap.bitnagil.data.report.datasourceImpl.ReportDataSourceImpl
 import com.threegap.bitnagil.data.routine.datasource.RoutineRemoteDataSource
 import com.threegap.bitnagil.data.routine.datasourceImpl.RoutineRemoteDataSourceImpl
-import com.threegap.bitnagil.data.user.datasource.UserDataSource
-import com.threegap.bitnagil.data.user.datasourceImpl.UserDataSourceImpl
+import com.threegap.bitnagil.data.user.datasource.UserLocalDataSource
+import com.threegap.bitnagil.data.user.datasource.UserRemoteDataSource
+import com.threegap.bitnagil.data.user.datasourceImpl.UserLocalDataSourceImpl
+import com.threegap.bitnagil.data.user.datasourceImpl.UserRemoteDataSourceImpl
 import com.threegap.bitnagil.data.version.datasource.VersionDataSource
 import com.threegap.bitnagil.data.version.datasourceImpl.VersionDataSourceImpl
 import dagger.Binds
@@ -52,11 +56,19 @@ abstract class DataSourceModule {
 
     @Binds
     @Singleton
-    abstract fun bindEmotionDataSource(emotionDataSourceImpl: EmotionDataSourceImpl): EmotionDataSource
+    abstract fun bindEmotionLocalDataSource(emotionLocalDataSourceImpl: EmotionLocalDataSourceImpl): EmotionLocalDataSource
 
     @Binds
     @Singleton
-    abstract fun bindUserDataSource(userDataSourceImpl: UserDataSourceImpl): UserDataSource
+    abstract fun bindEmotionRemoteDataSource(emotionRemoteDataSourceImpl: EmotionRemoteDataSourceImpl): EmotionRemoteDataSource
+
+    @Binds
+    @Singleton
+    abstract fun bindUserLocalDataSource(userLocalDataSourceImpl: UserLocalDataSourceImpl): UserLocalDataSource
+
+    @Binds
+    @Singleton
+    abstract fun bindUserRemoteDataSource(userRemoteDataSourceImpl: UserRemoteDataSourceImpl): UserRemoteDataSource
 
     @Binds
     @Singleton

data/build.gradle.kts

@@ -20,4 +20,7 @@ dependencies {
     implementation(libs.bundles.retrofit)
     implementation(libs.play.services.location)
     implementation(libs.kotlinx.coroutines.play)
+
+    testImplementation(libs.androidx.junit)
+    testImplementation(libs.kotlin.coroutines.test)
 }

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 emotionLocalDataSource: 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(
+            emotionLocalDataSource.dailyEmotion
+                .filterNotNull()
+                .map { Result.success(it) },
+        )
+    }
+
+    override fun clearCache() {
+        emotionLocalDataSource.clearCache()
+    }
+
+    private suspend fun fetchAndSaveDailyEmotion(
+        today: LocalDate,
+        forceRefresh: Boolean = false,
+    ): Result<DailyEmotion> {
+        if (!forceRefresh) {
+            val currentLocalData = emotionLocalDataSource.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 = emotionLocalDataSource.dailyEmotion.value
+                if (doubleCheckData != null && !doubleCheckData.isStale(today)) {
+                    return@withLock Result.success(doubleCheckData)
+                }
+            }
+            emotionRemoteDataSource.fetchDailyEmotion(today.toString())
+                .onSuccess { emotionLocalDataSource.saveDailyEmotion(it.toDomain(today)) }
+                .map { it.toDomain(today) }
+        }
+    }
 }

data/src/main/java/com/threegap/bitnagil/data/user/datasource/UserLocalDataSource.kt

@@ -0,0 +1,10 @@
+package com.threegap.bitnagil.data.user.datasource
+
+import com.threegap.bitnagil.domain.user.model.UserProfile
+import kotlinx.coroutines.flow.StateFlow
+
+interface UserLocalDataSource {
+    val userProfile: StateFlow<UserProfile?>
+    fun saveUserProfile(userProfile: UserProfile)
+    fun clearCache()
+}

data/src/main/java/com/threegap/bitnagil/data/user/datasource/UserDataSource.kt → data/src/main/java/com/threegap/bitnagil/data/user/datasource/UserRemoteDataSource.kt

@@ -2,6 +2,6 @@ package com.threegap.bitnagil.data.user.datasource
 
 import com.threegap.bitnagil.data.user.model.response.UserProfileResponse
 
-interface UserDataSource {
+interface UserRemoteDataSource {
     suspend fun fetchUserProfile(): Result<UserProfileResponse>
 }

data/src/main/java/com/threegap/bitnagil/data/user/datasourceImpl/UserLocalDataSourceImpl.kt

@@ -0,0 +1,24 @@
+package com.threegap.bitnagil.data.user.datasourceImpl
+
+import com.threegap.bitnagil.data.user.datasource.UserLocalDataSource
+import com.threegap.bitnagil.domain.user.model.UserProfile
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.flow.asStateFlow
+import kotlinx.coroutines.flow.update
+import javax.inject.Inject
+import javax.inject.Singleton
+
+@Singleton
+class UserLocalDataSourceImpl @Inject constructor() : UserLocalDataSource {
+    private val _userProfile = MutableStateFlow<UserProfile?>(null)
+    override val userProfile: StateFlow<UserProfile?> = _userProfile.asStateFlow()
+
+    override fun saveUserProfile(userProfile: UserProfile) {
+        _userProfile.update { userProfile }
+    }
+
+    override fun clearCache() {
+        _userProfile.update { null }
+    }
+}

data/src/main/java/com/threegap/bitnagil/data/user/datasourceImpl/UserDataSourceImpl.kt → data/src/main/java/com/threegap/bitnagil/data/user/datasourceImpl/UserRemoteDataSourceImpl.kt

@@ -1,16 +1,14 @@
 package com.threegap.bitnagil.data.user.datasourceImpl
 
 import com.threegap.bitnagil.data.common.safeApiCall
-import com.threegap.bitnagil.data.user.datasource.UserDataSource
+import com.threegap.bitnagil.data.user.datasource.UserRemoteDataSource
 import com.threegap.bitnagil.data.user.model.response.UserProfileResponse
 import com.threegap.bitnagil.data.user.service.UserService
 import javax.inject.Inject
 
-class UserDataSourceImpl @Inject constructor(
+class UserRemoteDataSourceImpl @Inject constructor(
     private val userService: UserService,
-) : UserDataSource {
+) : UserRemoteDataSource {
     override suspend fun fetchUserProfile(): Result<UserProfileResponse> =
-        safeApiCall {
-            userService.fetchUserProfile()
-        }
+        safeApiCall { userService.fetchUserProfile() }
 }

data/src/main/java/com/threegap/bitnagil/data/user/repositoryImpl/UserRepositoryImpl.kt

@@ -1,14 +1,59 @@
 package com.threegap.bitnagil.data.user.repositoryImpl
 
-import com.threegap.bitnagil.data.user.datasource.UserDataSource
+import com.threegap.bitnagil.data.user.datasource.UserLocalDataSource
+import com.threegap.bitnagil.data.user.datasource.UserRemoteDataSource
 import com.threegap.bitnagil.data.user.model.response.toDomain
 import com.threegap.bitnagil.domain.user.model.UserProfile
 import com.threegap.bitnagil.domain.user.repository.UserRepository
+import kotlinx.coroutines.flow.Flow
+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 javax.inject.Inject
+import javax.inject.Singleton
 
+@Singleton
 class UserRepositoryImpl @Inject constructor(
-    private val userDataSource: UserDataSource,
+    private val userLocalDataSource: UserLocalDataSource,
+    private val userRemoteDataSource: UserRemoteDataSource,
 ) : UserRepository {
-    override suspend fun fetchUserProfile(): Result<UserProfile> =
-        userDataSource.fetchUserProfile().map { it.toDomain() }
+    private val fetchMutex = Mutex()
+
+    override fun observeUserProfile(): Flow<Result<UserProfile>> = flow {
+        fetchAndCacheIfNeeded().onFailure {
+            emit(Result.failure(it))
+            return@flow
+        }
+
+        emitAll(
+            userLocalDataSource.userProfile
+                .filterNotNull()
+                .map { Result.success(it) },
+        )
+    }
+
+    override suspend fun getUserProfile(): Result<UserProfile> {
+        return fetchAndCacheIfNeeded()
+    }
+
+    override fun clearCache() {
+        userLocalDataSource.clearCache()
+    }
+
+    private suspend fun fetchAndCacheIfNeeded(): Result<UserProfile> {
+        userLocalDataSource.userProfile.value?.let { return Result.success(it) }
+
+        return fetchMutex.withLock {
+            userLocalDataSource.userProfile.value?.let { return@withLock Result.success(it) }
+
+            userRemoteDataSource.fetchUserProfile()
+                .onSuccess { response ->
+                    userLocalDataSource.saveUserProfile(response.toDomain())
+                }
+                .map { it.toDomain() }
+        }
+    }
 }