[FEAT] 운세 생성 API 호출 시점 변경

app/build.gradle.kts

@@ -8,6 +8,7 @@ plugins {
 
 android {
     namespace = "com.yapp.orbit"
+    compileSdk = 35
 
     defaultConfig {
         versionCode = 6
@@ -53,4 +54,6 @@ dependencies {
     implementation(libs.firebase.crashlytics)
     implementation(libs.play.services.ads)
     implementation(libs.kotlin.reflect)
+    implementation(libs.hilt.worker)
+    implementation(libs.androidx.work.runtime)
 }

app/src/main/AndroidManifest.xml

@@ -46,9 +46,7 @@
                 <action android:name="android.intent.action.VIEW" />
                 <category android:name="android.intent.category.DEFAULT" />
                 <category android:name="android.intent.category.BROWSABLE" />
-                <data
-                    android:scheme="orbitapp"
-                    android:host="mission"/>
+                <data android:scheme="orbitapp" />
             </intent-filter>
         </activity>
 
@@ -80,5 +78,15 @@
         <service
             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,13 +1,24 @@
 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() {
+class OrbitApplication() : Application(), Configuration.Provider {
+
+    @Inject lateinit var workerFactory: HiltWorkerFactory
+
     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

@@ -14,7 +14,9 @@ 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())
     }
 }
 

build-logic/src/main/java/orbit.android.feature.gradle.kts

@@ -1,13 +1,10 @@
-import com.yapp.convention.configureHiltAndroid
 import com.yapp.convention.libs
 
 plugins {
     id("orbit.android.library")
     id("orbit.android.compose")
 }
 
-configureHiltAndroid()
-
 dependencies {
     implementation(project(":core:designsystem"))
     implementation(project(":core:ui"))

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

@@ -11,10 +11,9 @@ import com.yapp.domain.repository.FortuneRepository
 import dagger.hilt.android.AndroidEntryPoint
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.flow.firstOrNull
+import kotlinx.coroutines.flow.first
 import kotlinx.coroutines.launch
-import java.time.LocalDate
-import java.time.format.DateTimeFormatter
+import kotlinx.coroutines.withContext
 import javax.inject.Inject
 
 @AndroidEntryPoint
@@ -42,24 +41,38 @@ class AlarmInteractionActivityReceiver(private val activity: ComponentActivity)
                         missionCount != -1
                     )
 
-                if (!hasValidMissionData) return
-
-                CoroutineScope(Dispatchers.IO).launch {
-                    val fortuneDate = fortuneRepository.fortuneDateFlow.firstOrNull()
-                    val todayDate = LocalDate.now().format(DateTimeFormatter.ISO_DATE)
-
-                    val shouldLaunchMission = fortuneDate != todayDate
+                val pending = goAsync()
+                CoroutineScope(Dispatchers.Main).launch {
+                    try {
+                        if (!hasValidMissionData) {
+                            val hasUnseenFortune = withContext(Dispatchers.IO) {
+                                fortuneRepository.hasUnseenFortuneFlow.first()
+                            }
+                            if (hasUnseenFortune) {
+                                context?.let { ctx ->
+                                    val uri = "orbitapp://fortune".toUri()
+                                    val fortuneIntent = Intent(Intent.ACTION_VIEW, uri).apply {
+                                        addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
+                                        setPackage(ctx.packageName)
+                                    }
+                                    ctx.startActivity(fortuneIntent)
+                                }
+                            }
+                            return@launch
+                        }
 
-                    if (shouldLaunchMission) {
-                        context?.let {
+                        context?.let { ctx ->
                             val uriString =
                                 "orbitapp://mission?notificationId=$notificationId&missionType=${missionType.value}&missionCount=$missionCount"
-                            val missionIntent = Intent(Intent.ACTION_VIEW, uriString.toUri()).apply {
-                                addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
-                                setPackage(it.packageName)
-                            }
-                            it.startActivity(missionIntent)
+                            val missionIntent =
+                                Intent(Intent.ACTION_VIEW, uriString.toUri()).apply {
+                                    addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
+                                    setPackage(ctx.packageName)
+                                }
+                            ctx.startActivity(missionIntent)
                         }
+                    } finally {
+                        pending.finish()
                     }
                 }
             }

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

@@ -12,15 +12,16 @@ import com.yapp.alarm.services.AlarmService
 import com.yapp.analytics.AnalyticsEvent
 import com.yapp.analytics.AnalyticsHelper
 import com.yapp.domain.model.Alarm
+import com.yapp.domain.model.toAlarmDay
 import com.yapp.domain.model.toTimeString
 import com.yapp.domain.repository.FortuneRepository
 import com.yapp.domain.usecase.AlarmUseCase
 import dagger.hilt.android.AndroidEntryPoint
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.flow.first
-import kotlinx.coroutines.flow.firstOrNull
 import kotlinx.coroutines.launch
+import java.time.LocalDate
 import java.time.LocalDateTime
 import javax.inject.Inject
 
@@ -105,17 +106,31 @@ class AlarmReceiver : BroadcastReceiver() {
                 androidAlarmScheduler.cancelSnoozedAlarm(notificationId)
                 context.stopService(alarmServiceIntent)
 
-                sendBroadCastToCloseAlarmInteractionActivity(
-                    context = context,
-                    notificationId = notificationId,
-                    missionType = missionType,
-                    missionCount = missionCount,
-                )
-
                 CoroutineScope(Dispatchers.IO).launch {
-                    val alarms = alarmUseCase.getAllAlarms().first().sortedBy { it.isAlarmActive }
-                    val isFirstAlarm = alarms.firstOrNull()?.id == notificationId
+                    val alarms = alarmUseCase.getAllAlarms().first()
+
+                    val isSnoozeId = notificationId >= AlarmConstants.SNOOZE_ID_OFFSET
+
+                    fun Alarm.ringsToday(): Boolean {
+                        if (repeatDays == 0) return true
+
+                        val todayAlarmDay = LocalDate.now().dayOfWeek.toAlarmDay()
+                        return (repeatDays and todayAlarmDay.bitValue) != 0
+                    }
 
+                    val earliestIdToday: Long? = alarms
+                        .asSequence()
+                        .filter { (it.isAlarmActive || it.id == notificationId) && it.ringsToday() }
+                        .sortedWith(compareBy({ it.hour }, { it.minute }, { it.second }))
+                        .firstOrNull()
+                        ?.id
+
+                    val isEarliestAlarmDismissedToday =
+                        !isSnoozeId && (earliestIdToday == notificationId)
+
+                    if (isEarliestAlarmDismissedToday) fortuneRepository.markFirstAlarmDismissedToday()
+
+                    val isFirstAlarm = earliestIdToday == notificationId
                     analyticsHelper.logEvent(
                         AnalyticsEvent(
                             type = "alarm_dismiss",
@@ -126,12 +141,12 @@ class AlarmReceiver : BroadcastReceiver() {
                         ),
                     )
 
-                    val existingId = fortuneRepository.firstDismissedAlarmIdFlow.firstOrNull()
-                    if (existingId == null) {
-                        fortuneRepository.saveFirstDismissedAlarmId(notificationId)
-                    } else if (existingId != notificationId) {
-                        fortuneRepository.clearDismissedAlarmId()
-                    }
+                    sendBroadCastToCloseAlarmInteractionActivity(
+                        context = context,
+                        notificationId = notificationId,
+                        missionType = missionType,
+                        missionCount = missionCount,
+                    )
                 }
 
                 Toast.makeText(context, "알람이 해제되었어요", Toast.LENGTH_SHORT).show()

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

@@ -0,0 +1,5 @@
+package com.yapp.alarm.scheduler
+
+interface PostFortuneTaskScheduler {
+    fun enqueueOnceForToday()
+}

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

@@ -23,21 +23,18 @@ 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.FortuneRepository
 import com.yapp.domain.usecase.AlarmUseCase
 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.firstOrNull
 import kotlinx.coroutines.launch
-import java.time.LocalDate
-import java.time.format.DateTimeFormatter
 import javax.inject.Inject
 
 @AndroidEntryPoint
@@ -55,7 +52,7 @@ class AlarmService : Service() {
     lateinit var androidAlarmScheduler: AndroidAlarmScheduler
 
     @Inject
-    lateinit var fortuneRepository: FortuneRepository
+    lateinit var postFortuneTaskScheduler: PostFortuneTaskScheduler
 
     private val serviceScope = CoroutineScope(Dispatchers.IO + SupervisorJob())
 
@@ -82,7 +79,7 @@ class AlarmService : Service() {
         super.onDestroy()
     }
 
-    private suspend fun handleIntent(intent: Intent) {
+    private fun handleIntent(intent: Intent) {
         val alarm: Alarm? = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
             intent.getParcelableExtra(AlarmConstants.EXTRA_ALARM, Alarm::class.java)
         } else {
@@ -124,16 +121,14 @@ class AlarmService : Service() {
         if (isOneTimeAlarm) {
             turnOffAlarm(alarmId = notificationId)
         }
+
+        postFortuneTaskScheduler.enqueueOnceForToday()
     }
 
-    private suspend fun shouldNavigateToMission(
+    private fun shouldNavigateToMission(
         missionType: MissionType,
     ): Boolean {
-        if (missionType == MissionType.NONE) return false
-
-        val fortuneDate = fortuneRepository.fortuneDateFlow.firstOrNull()
-        val todayDate = LocalDate.now().format(DateTimeFormatter.ISO_DATE)
-        return fortuneDate != todayDate
+        return missionType != MissionType.NONE
     }
 
     private fun createNotification(alarm: Alarm, shouldNavigateToMission: Boolean): Notification {