[FEAT] 알람 로직 리팩토링 및 테스트 코드 추가

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

@@ -22,7 +22,6 @@ internal fun Project.configureComposeUiTest() {
 @Suppress("UnstableApiUsage")
 internal fun Project.configureJUnitAndroid() {
     androidExtension.apply {
-        testOptions { unitTests.all { it.useJUnitPlatform() } }
         defaultConfig { testInstrumentationRunner = "androidx.test.runner.AndroidJUnitRunner" }
 
         val libs = extensions.libs

core/alarm/build.gradle.kts

@@ -11,6 +11,7 @@ android {
 
 dependencies {
     implementation(projects.core.analytics)
+    implementation(projects.core.common)
     implementation(projects.core.designsystem)
     implementation(projects.core.media)
     implementation(projects.domain)

core/alarm/src/main/java/com/yapp/alarm/AlarmConstants.kt

@@ -16,8 +16,6 @@ object AlarmConstants {
 
     const val SNOOZE_ID_OFFSET = 10000
 
-    const val WEEK_INTERVAL_MILLIS: Long = 7 * 24 * 60 * 60 * 1000
-
     val HOLIDAYS_2025 = setOf(
         "2025-01-01", "2025-01-27", "2025-01-28", "2025-01-29", "2025-01-30",
         "2025-03-01", "2025-03-03", "2025-05-05", "2025-05-06", "2025-06-06",

core/alarm/src/main/java/com/yapp/alarm/AlarmTimeCalculator.kt

@@ -0,0 +1,98 @@
+package com.yapp.alarm
+
+import com.yapp.domain.model.Alarm
+import com.yapp.domain.model.AlarmDay
+import com.yapp.domain.model.toDayOfWeek
+import java.time.Clock
+import java.time.LocalDateTime
+import java.time.ZoneId
+import java.time.format.DateTimeFormatter
+import javax.inject.Inject
+
+class AlarmTimeCalculator @Inject constructor(
+    private val clock: Clock,
+) {
+    private val holidayDateFormatter: DateTimeFormatter = DateTimeFormatter.ofPattern("yyyy-MM-dd")
+
+    private fun isHoliday(dateToCheck: LocalDateTime): Boolean {
+        if (dateToCheck.year == 2025) {
+            val dateString = dateToCheck.format(holidayDateFormatter)
+            return AlarmConstants.HOLIDAYS_2025.contains(dateString)
+        }
+        return false
+    }
+
+    private fun skipHolidaysIfEnabled(initialDateTime: LocalDateTime, alarm: Alarm): LocalDateTime {
+        if (!alarm.isHolidayAlarmOff) return initialDateTime
+
+        var adjustedDateTime = initialDateTime
+        while (isHoliday(adjustedDateTime)) {
+            adjustedDateTime = adjustedDateTime.plusWeeks(1)
+        }
+
+        return adjustedDateTime
+    }
+
+    private fun getAlarmDateTimeOnDate(alarm: Alarm, now: LocalDateTime): LocalDateTime {
+        return now
+            .withHour(alarm.hour)
+            .withMinute(alarm.minute)
+            .withSecond(alarm.second)
+            .withNano(0)
+    }
+
+    fun calculateNextRepeatingTimeMillis(
+        alarm: Alarm,
+        alarmDay: AlarmDay,
+        zoneId: ZoneId = clock.zone,
+    ): Long {
+        val now = LocalDateTime.now(clock)
+        val targetDayOfWeek = alarmDay.toDayOfWeek()
+
+        val alarmDateTimeToday = getAlarmDateTimeOnDate(alarm, now)
+
+        var nextAlarmDateTimeCandidate = alarmDateTimeToday
+
+        while (nextAlarmDateTimeCandidate.dayOfWeek != targetDayOfWeek || nextAlarmDateTimeCandidate.isBefore(now)) {
+            nextAlarmDateTimeCandidate = nextAlarmDateTimeCandidate.plusDays(1)
+        }
+
+        nextAlarmDateTimeCandidate = skipHolidaysIfEnabled(nextAlarmDateTimeCandidate, alarm)
+
+        return nextAlarmDateTimeCandidate.atZone(zoneId).toInstant().toEpochMilli()
+    }
+
+    fun calculateNonRepeatingTimeMillis(
+        alarm: Alarm,
+        zoneId: ZoneId = clock.zone,
+    ): Long {
+        val now = LocalDateTime.now(clock)
+        var alarmDateTime = getAlarmDateTimeOnDate(alarm, now)
+
+        if (alarmDateTime.isBefore(now)) {
+            alarmDateTime = alarmDateTime.plusDays(1)
+        }
+
+        return alarmDateTime.atZone(zoneId).toInstant().toEpochMilli()
+    }
+
+    fun calculateNextWeeklyRescheduledTimeMillis(
+        alarm: Alarm,
+        alarmTargetDay: AlarmDay,
+        zoneId: ZoneId = clock.zone,
+    ): Long {
+        val now = LocalDateTime.now(clock)
+        val targetDayOfWeek = alarmTargetDay.toDayOfWeek()
+
+        var initialAlarmDateTimeCandidate = getAlarmDateTimeOnDate(alarm, now)
+
+        while (initialAlarmDateTimeCandidate.dayOfWeek != targetDayOfWeek || initialAlarmDateTimeCandidate.isBefore(now)) {
+            initialAlarmDateTimeCandidate = initialAlarmDateTimeCandidate.plusDays(1)
+        }
+
+        val nextWeeklyAlarmDateTimeCandidate = initialAlarmDateTimeCandidate.plusWeeks(1)
+        val nextWeeklyAlarmDateTime = skipHolidaysIfEnabled(nextWeeklyAlarmDateTimeCandidate, alarm)
+
+        return nextWeeklyAlarmDateTime.atZone(zoneId).toInstant().toEpochMilli()
+    }
+}

core/alarm/src/main/java/com/yapp/alarm/AndroidAlarmScheduler.kt

@@ -2,24 +2,20 @@ package com.yapp.alarm
 
 import android.app.AlarmManager
 import android.app.Application
-import android.util.Log
 import com.yapp.alarm.pendingIntent.schedule.createAlarmReceiverPendingIntentForSchedule
 import com.yapp.alarm.pendingIntent.schedule.createAlarmReceiverPendingIntentForUnSchedule
 import com.yapp.domain.model.Alarm
 import com.yapp.domain.model.AlarmDay
 import com.yapp.domain.model.toAlarmDays
-import com.yapp.domain.model.toDayOfWeek
 import com.yapp.domain.scheduler.AlarmScheduler
-import java.time.Instant
-import java.time.LocalDateTime
-import java.time.ZoneId
-import java.time.format.DateTimeFormatter
 import javax.inject.Inject
 
 class AndroidAlarmScheduler @Inject constructor(
     private val app: Application,
     private val alarmManager: AlarmManager,
+    private val alarmTimeCalculator: AlarmTimeCalculator,
 ) : AlarmScheduler {
+
     override fun scheduleAlarm(alarm: Alarm) {
         val selectedDays = alarm.repeatDays.toAlarmDays()
 
@@ -32,19 +28,37 @@ class AndroidAlarmScheduler @Inject constructor(
         }
     }
 
-    fun scheduleWeeklyAlarm(alarm: Alarm, day: AlarmDay) {
-        val initialTriggerMillis = getNextAlarmTimeMillis(alarm, day) + AlarmConstants.WEEK_INTERVAL_MILLIS
-        val triggerMillis = findNextNonHolidayDate(initialTriggerMillis)
-
+    private fun setRepeatingAlarm(day: AlarmDay, alarm: Alarm) {
+        val triggerMillis = alarmTimeCalculator.calculateNextRepeatingTimeMillis(alarm, day)
         val pendingIntent = createAlarmReceiverPendingIntentForSchedule(app, alarm, day)
 
         alarmManager.setExactAndAllowWhileIdle(
             AlarmManager.RTC_WAKEUP,
             triggerMillis,
             pendingIntent,
         )
+    }
+
+    private fun setNonRepeatingAlarm(alarm: Alarm) {
+        val triggerMillis = alarmTimeCalculator.calculateNonRepeatingTimeMillis(alarm)
+        val pendingIntent = createAlarmReceiverPendingIntentForSchedule(app, alarm)
+
+        alarmManager.setExactAndAllowWhileIdle(
+            AlarmManager.RTC_WAKEUP,
+            triggerMillis,
+            pendingIntent,
+        )
+    }
+
+    fun rescheduleUpcomingWeeklyAlarm(alarm: Alarm, day: AlarmDay) {
+        val triggerMillis = alarmTimeCalculator.calculateNextWeeklyRescheduledTimeMillis(alarm, day)
+        val pendingIntent = createAlarmReceiverPendingIntentForSchedule(app, alarm, day)
 
-        Log.d("AlarmHelper", "Scheduled weekly alarm for $day at: $triggerMillis")
+        alarmManager.setExactAndAllowWhileIdle(
+            AlarmManager.RTC_WAKEUP,
+            triggerMillis,
+            pendingIntent,
+        )
     }
 
     override fun unScheduleAlarm(alarm: Alarm) {
@@ -73,85 +87,5 @@ class AndroidAlarmScheduler @Inject constructor(
         val snoozedAlarmId = alarmId + AlarmConstants.SNOOZE_ID_OFFSET
         val pendingIntent = createAlarmReceiverPendingIntentForUnSchedule(app, Alarm(id = snoozedAlarmId))
         alarmManager.cancel(pendingIntent)
-        Log.d("AlarmHelper", "Canceled snoozed alarm with id: $snoozedAlarmId")
-    }
-
-    private fun setRepeatingAlarm(day: AlarmDay, alarm: Alarm) {
-        val alarmReceiverPendingIntent =
-            createAlarmReceiverPendingIntentForSchedule(app, alarm, day)
-        val firstAlarmTriggerMillis = getNextAlarmTimeMillis(alarm, day)
-
-        Log.d("AlarmHelper", "Setting repeating alarm id: ${alarm.id} at: $firstAlarmTriggerMillis")
-
-        alarmManager.setExactAndAllowWhileIdle(
-            AlarmManager.RTC_WAKEUP,
-            firstAlarmTriggerMillis,
-            alarmReceiverPendingIntent,
-        )
-    }
-
-    private fun setNonRepeatingAlarm(alarm: Alarm) {
-        val alarmReceiverPendingIntent =
-            createAlarmReceiverPendingIntentForSchedule(app, alarm)
-
-        val triggerMillis = getNextAlarmTimeMillis(alarm, null)
-
-        Log.d("AlarmHelper", "Setting one-time alarm at: $triggerMillis")
-
-        alarmManager.setExactAndAllowWhileIdle(
-            AlarmManager.RTC_WAKEUP,
-            triggerMillis,
-            alarmReceiverPendingIntent,
-        )
-    }
-
-    private fun getNextAlarmTimeMillis(alarm: Alarm, day: AlarmDay?): Long {
-        val now = LocalDateTime.now().withNano(0) // 밀리초 제거하여 정확한 초 기준 설정
-
-        val alarmHour = when {
-            alarm.isAm && alarm.hour == 12 -> 0
-            !alarm.isAm && alarm.hour != 12 -> alarm.hour + 12
-            else -> alarm.hour
-        }
-
-        var alarmDateTime = now.withHour(alarmHour).withMinute(alarm.minute).withSecond(alarm.second)
-
-        if (day != null) {
-            val targetDayOfWeek = day.toDayOfWeek()
-            while (alarmDateTime.dayOfWeek != targetDayOfWeek || alarmDateTime.isBefore(now)) {
-                alarmDateTime = alarmDateTime.plusDays(1)
-            }
-        } else {
-            if (alarmDateTime.isBefore(now)) {
-                alarmDateTime = alarmDateTime.plusDays(1)
-            }
-        }
-
-        val epochMillis = alarmDateTime.atZone(ZoneId.systemDefault()).toInstant().toEpochMilli()
-
-        Log.d("AlarmHelper", "Alarm scheduled at: $alarmDateTime (epochMillis=$epochMillis)")
-
-        return epochMillis
-    }
-
-    private fun findNextNonHolidayDate(initialMillis: Long): Long {
-        val dateFormatter = DateTimeFormatter.ofPattern("yyyy-MM-dd")
-
-        var adjustedMillis = initialMillis
-
-        while (true) {
-            val localDate = Instant.ofEpochMilli(adjustedMillis)
-                .atZone(ZoneId.systemDefault())
-                .toLocalDate()
-
-            val dateString = localDate.format(dateFormatter)
-
-            if (!AlarmConstants.HOLIDAYS_2025.contains(dateString)) {
-                return adjustedMillis // 공휴일이 아니라면 해당 날짜 반환
-            }
-
-            // 공휴일이라면 다음 1주 뒤로 이동
-            adjustedMillis += AlarmConstants.WEEK_INTERVAL_MILLIS
-        }
     }
 }

core/alarm/src/main/java/com/yapp/alarm/di/AlarmModule.kt

@@ -2,6 +2,7 @@ package com.yapp.alarm.di
 
 import android.app.AlarmManager
 import android.content.Context
+import com.yapp.alarm.AlarmTimeCalculator
 import com.yapp.alarm.AndroidAlarmScheduler
 import com.yapp.domain.scheduler.AlarmScheduler
 import dagger.Binds
@@ -10,6 +11,7 @@ import dagger.Provides
 import dagger.hilt.InstallIn
 import dagger.hilt.android.qualifiers.ApplicationContext
 import dagger.hilt.components.SingletonComponent
+import java.time.Clock
 import javax.inject.Singleton
 
 @Module
@@ -22,6 +24,12 @@ abstract class AlarmModule {
     ): AlarmScheduler
 
     companion object {
+        @Provides
+        @Singleton
+        fun provideAlarmTimeCalculator(clock: Clock): AlarmTimeCalculator {
+            return AlarmTimeCalculator(clock)
+        }
+
         @Provides
         @Singleton
         fun provideAlarmManager(@ApplicationContext context: Context): AlarmManager {

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

@@ -152,8 +152,7 @@ class AlarmReceiver : BroadcastReceiver() {
             .plusMinutes(alarm.snoozeInterval.toLong())
 
         val updatedAlarm = alarm.copy(
-            isAm = snoozeDateTime.hour < 12,
-            hour = if (snoozeDateTime.hour == 0) 12 else if (snoozeDateTime.hour > 12) snoozeDateTime.hour - 12 else snoozeDateTime.hour,
+            hour = snoozeDateTime.hour,
             minute = snoozeDateTime.minute,
             second = snoozeDateTime.second,
             repeatDays = 0,

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

@@ -103,7 +103,7 @@ class AlarmService : Service() {
         // 반복 요일 알람 시, 다음 주 동일 요일 알람 예약
         if (!isOneTimeAlarm) {
             intent.getStringExtra(AlarmConstants.EXTRA_ALARM_DAY)?.let {
-                androidAlarmScheduler.scheduleWeeklyAlarm(alarm, AlarmDay.valueOf(it))
+                androidAlarmScheduler.rescheduleUpcomingWeeklyAlarm(alarm, AlarmDay.valueOf(it))
             }
         }