Merge pull request #279 from YAPP-Github/bugfix/#278-fortune-create-status

[BUGFIX] 오늘의 운세 생성에 실패할 시 다음날이 되기 전까지 계속 운세 생성에 실패하는 문제

Author: DongChyeon

app/build.gradle.kts

@@ -64,8 +64,6 @@ dependencies {
 
     implementation(libs.compose.material)
     implementation(libs.kotlin.reflect)
-    implementation(libs.hilt.worker)
-    implementation(libs.androidx.work.runtime)
 
     implementation(platform(libs.firebase.bom))
     implementation(libs.firebase.analytics)

app/src/main/AndroidManifest.xml

@@ -80,14 +80,5 @@
             android:name="com.yapp.alarm.services.AlarmService"
             android:foregroundServiceType="mediaPlayback" />
 
-        <provider
-            android:name="androidx.startup.InitializationProvider"
-            android:authorities="${applicationId}.androidx-startup"
-            android:exported="false"
-            tools:node="merge">
-            <meta-data
-                android:name="androidx.work.WorkManagerInitializer"
-                tools:node="remove" />
-        </provider>
     </application>
 </manifest>

app/src/main/java/com/yapp/orbit/OrbitApplication.kt

@@ -1,24 +1,13 @@
 package com.yapp.orbit
 
 import android.app.Application
-import androidx.hilt.work.HiltWorkerFactory
-import androidx.work.Configuration
 import com.google.android.gms.ads.MobileAds
 import dagger.hilt.android.HiltAndroidApp
-import javax.inject.Inject
 
 @HiltAndroidApp
-class OrbitApplication() : Application(), Configuration.Provider {
-
-    @Inject lateinit var workerFactory: HiltWorkerFactory
-
+class OrbitApplication() : Application() {
     override fun onCreate() {
         super.onCreate()
         MobileAds.initialize(this)
     }
-
-    override val workManagerConfiguration: Configuration
-        get() = Configuration.Builder()
-            .setWorkerFactory(workerFactory)
-            .build()
 }

build-logic/src/main/java/com/yapp/convention/HiltAndroid.kt

@@ -13,9 +13,7 @@ internal fun Project.configureHiltAndroid() {
     dependencies {
         "implementation"(libs.findLibrary("hilt.android").get())
         "ksp"(libs.findLibrary("hilt.android.compiler").get())
-        "ksp"(libs.findLibrary("androidx-hilt-compiler").get())
         "implementation"(libs.findLibrary("hilt-navigation-compose").get())
-        "implementation"(libs.findLibrary("hilt-worker").get())
     }
 }
 

core/alarm/src/main/java/com/yapp/alarm/receivers/AlarmInteractionActivityReceiver.kt

@@ -6,9 +6,10 @@ import android.content.Intent
 import androidx.activity.ComponentActivity
 import androidx.core.net.toUri
 import com.yapp.alarm.AlarmConstants
-import com.yapp.domain.model.FortuneCreateStatus
+import com.yapp.domain.model.FortuneCreationState
 import com.yapp.domain.model.MissionType
 import com.yapp.domain.repository.FortuneRepository
+import com.yapp.domain.tracker.FortuneCreationTracker
 import dagger.hilt.android.AndroidEntryPoint
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
@@ -23,6 +24,9 @@ class AlarmInteractionActivityReceiver(private val activity: ComponentActivity)
     @Inject
     lateinit var fortuneRepository: FortuneRepository
 
+    @Inject
+    lateinit var fortuneCreationTracker: FortuneCreationTracker
+
     override fun onReceive(context: Context?, intent: Intent?) {
         val isSnoozed = intent?.getBooleanExtra(AlarmConstants.EXTRA_IS_SNOOZED, false) ?: false
 
@@ -46,16 +50,15 @@ class AlarmInteractionActivityReceiver(private val activity: ComponentActivity)
                 CoroutineScope(Dispatchers.Main).launch {
                     try {
                         if (!hasValidMissionData) {
-                            val (fortuneCreateStatus, hasUnseenFortune) = withContext(Dispatchers.IO) {
-                                val status = fortuneRepository.fortuneCreateStatusFlow.first()
+                            val (fortuneCreationState, hasUnseenFortune) = withContext(Dispatchers.IO) {
+                                val todayFortune = fortuneCreationTracker.state.first()
                                 val unseen = fortuneRepository.hasUnseenFortuneFlow.first()
-                                status to unseen
+
+                                todayFortune to unseen
                             }
 
-                            when (fortuneCreateStatus) {
-                                is FortuneCreateStatus.Creating,
-                                is FortuneCreateStatus.Failure,
-                                -> {
+                            when (fortuneCreationState) {
+                                is FortuneCreationState.Start -> {
                                     context?.let { ctx ->
                                         val uri = "orbitapp://fortune".toUri()
                                         val fortuneIntent = Intent(Intent.ACTION_VIEW, uri).apply {
@@ -65,8 +68,7 @@ class AlarmInteractionActivityReceiver(private val activity: ComponentActivity)
                                         ctx.startActivity(fortuneIntent)
                                     }
                                 }
-
-                                is FortuneCreateStatus.Success -> {
+                                is FortuneCreationState.Success -> {
                                     if (hasUnseenFortune) {
                                         context?.let { ctx ->
                                             val uri = "orbitapp://fortune".toUri()
@@ -79,8 +81,7 @@ class AlarmInteractionActivityReceiver(private val activity: ComponentActivity)
                                         }
                                     }
                                 }
-
-                                FortuneCreateStatus.Idle -> { }
+                                is FortuneCreationState.Failure -> { }
                             }
                         } else {
                             context?.let { ctx ->

core/alarm/src/main/java/com/yapp/alarm/scheduler/PostFortuneTaskScheduler.kt

@@ -23,17 +23,20 @@ import com.yapp.alarm.pendingIntent.interaction.createAlarmAlertPendingIntent
 import com.yapp.alarm.pendingIntent.interaction.createAlarmDismissPendingIntent
 import com.yapp.alarm.pendingIntent.interaction.createAlarmSnoozePendingIntent
 import com.yapp.alarm.pendingIntent.interaction.createNavigateToMissionPendingIntent
-import com.yapp.alarm.scheduler.PostFortuneTaskScheduler
 import com.yapp.domain.model.Alarm
 import com.yapp.domain.model.AlarmDay
 import com.yapp.domain.model.MissionType
 import com.yapp.domain.repository.AlarmRepository
+import com.yapp.domain.repository.FortuneRepository
+import com.yapp.domain.repository.UserInfoRepository
+import com.yapp.domain.tracker.FortuneCreationTracker
 import com.yapp.media.sound.SoundPlayer
 import dagger.hilt.android.AndroidEntryPoint
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.SupervisorJob
 import kotlinx.coroutines.cancel
+import kotlinx.coroutines.flow.first
 import kotlinx.coroutines.launch
 import javax.inject.Inject
 
@@ -52,7 +55,13 @@ class AlarmService : Service() {
     lateinit var androidAlarmScheduler: AndroidAlarmScheduler
 
     @Inject
-    lateinit var postFortuneTaskScheduler: PostFortuneTaskScheduler
+    lateinit var fortuneRepository: FortuneRepository
+
+    @Inject
+    lateinit var userInfoRepository: UserInfoRepository
+
+    @Inject
+    lateinit var fortuneCreationTracker: FortuneCreationTracker
 
     private val serviceScope = CoroutineScope(Dispatchers.IO + SupervisorJob())
 
@@ -79,7 +88,7 @@ class AlarmService : Service() {
         super.onDestroy()
     }
 
-    private fun handleIntent(intent: Intent) {
+    private suspend fun handleIntent(intent: Intent) {
         val alarm: Alarm? = intent.getStringExtra(AlarmConstants.EXTRA_ALARM)?.let(Alarm::fromJson)
 
         if (alarm == null) {
@@ -117,7 +126,19 @@ class AlarmService : Service() {
             turnOffAlarm(alarmId = notificationId)
         }
 
-        postFortuneTaskScheduler.enqueueOnceForToday()
+        val shouldPostFortune = !fortuneRepository.hasTodayFortune()
+        if (shouldPostFortune) {
+            val userId = userInfoRepository.userIdFlow.first()
+            userId?.let {
+                fortuneCreationTracker.start()
+                fortuneRepository.postFortune(userId).onSuccess { fortune ->
+                    fortuneCreationTracker.succeed(fortune.id)
+                    fortuneRepository.markFortuneAsCreated(fortune.id)
+                }.onFailure {
+                    fortuneCreationTracker.fail()
+                }
+            }
+        }
     }
 
     private fun shouldNavigateToMission(

core/alarm/src/main/java/com/yapp/alarm/services/AlarmService.kt

@@ -0,0 +1,19 @@
+package com.yapp.common.di
+
+import com.yapp.common.tracker.InMemoryFortuneCreationTracker
+import com.yapp.domain.tracker.FortuneCreationTracker
+import dagger.Binds
+import dagger.Module
+import dagger.hilt.InstallIn
+import dagger.hilt.components.SingletonComponent
+import javax.inject.Singleton
+
+@Module
+@InstallIn(SingletonComponent::class)
+abstract class FortuneTrackerModule {
+    @Binds
+    @Singleton
+    abstract fun bindFortuneCreationTracker(
+        impl: InMemoryFortuneCreationTracker,
+    ): FortuneCreationTracker
+}

core/common/src/main/java/com/yapp/common/di/FortuneTrackerModule.kt

@@ -0,0 +1,27 @@
+package com.yapp.common.tracker
+
+import com.yapp.domain.model.FortuneCreationState
+import com.yapp.domain.tracker.FortuneCreationTracker
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.flow.asStateFlow
+import javax.inject.Inject
+import javax.inject.Singleton
+
+@Singleton
+class InMemoryFortuneCreationTracker @Inject constructor() : FortuneCreationTracker {
+    private val _state = MutableStateFlow<FortuneCreationState>(FortuneCreationState.Start)
+    override val state: StateFlow<FortuneCreationState> = _state.asStateFlow()
+
+    override fun start() {
+        _state.value = FortuneCreationState.Start
+    }
+
+    override fun succeed(fortuneId: Long) {
+        _state.value = FortuneCreationState.Success(fortuneId)
+    }
+
+    override fun fail() {
+        _state.value = FortuneCreationState.Failure
+    }
+}