Android中如何在指定时间区间内按设定频率推送通知？

你的思路其实是完全可行的，但我还有更简洁高效的方案可以分享给你，咱们一步步来梳理：

你的初始方案合理性分析 #

用WorkManager处理每日的启停时间，再由AlarmManager负责时间段内的重复通知，这个组合逻辑上是能满足需求的，但需要注意几个细节：

• Android 6.0+之后，AlarmManager.setRepeating()的精准性被调整，若要保证通知按时触发，建议用setExactAndAllowWhileIdle()，每次触发后再手动设置下一次的闹钟；
• 要处理设备重启的场景，得在BootCompleted广播里重新初始化WorkManager的任务，避免重启后任务丢失；
• 要确保两个WorkManager任务（启动/取消AlarmManager）的状态一致，比如防止出现AlarmManager没被正确取消导致超时通知的情况。

更简洁的优化方案：直接用WorkManager实现 #

其实你完全可以不用AlarmManager，直接用WorkManager完成整个逻辑，减少组件间的依赖，代码也更易维护：

核心思路 #

创建一个Worker类，每次执行时先判断当前时间是否在用户设定的区间内：

• 如果在区间内，就发送通知，然后计算下一次执行的时间：若加间隔后仍在区间内，就延迟对应间隔时间重试；若超出区间，就延迟到第二天的开始时间重试；
• 如果不在区间内，直接计算到下一个开始时间的延迟，重试任务。

示例代码片段 #

class NotificationWorker(context: Context, params: WorkerParameters) : Worker(context, params) {
    override fun doWork(): Result {
        val currentTime = Calendar.getInstance()
        // 读取用户设置的开始/结束时间，这里用示例值13:00-20:00
        val userStartTime = Calendar.getInstance().apply {
            set(Calendar.HOUR_OF_DAY, 13)
            set(Calendar.MINUTE, 0)
            set(Calendar.SECOND, 0)
        }
        val userEndTime = Calendar.getInstance().apply {
            set(Calendar.HOUR_OF_DAY, 20)
            set(Calendar.MINUTE, 0)
            set(Calendar.SECOND, 0)
        }

        return when {
            // 当前在用户设定的时间段内
            currentTime.after(userStartTime) && currentTime.before(userEndTime) -> {
                sendNotification()
                calculateNextRetryTime(currentTime, userStartTime, userEndTime, 2)
            }
            // 当前在时间段之前，延迟到当天开始时间
            currentTime.before(userStartTime) -> {
                val delay = userStartTime.timeInMillis - System.currentTimeMillis()
                Result.retry().setBackoffCriteria(BackoffPolicy.LINEAR, delay, TimeUnit.MILLISECONDS)
            }
            // 当前在时间段之后，延迟到第二天开始时间
            else -> {
                val nextDayStartTime = userStartTime.clone() as Calendar
                nextDayStartTime.add(Calendar.DAY_OF_MONTH, 1)
                val delay = nextDayStartTime.timeInMillis - System.currentTimeMillis()
                Result.retry().setBackoffCriteria(BackoffPolicy.LINEAR, delay, TimeUnit.MILLISECONDS)
            }
        }
    }

    private fun calculateNextRetryTime(current: Calendar, start: Calendar, end: Calendar, intervalHours: Int): Result {
        val nextTrigger = current.clone() as Calendar
        nextTrigger.add(Calendar.HOUR_OF_DAY, intervalHours)
        return if (nextTrigger.before(end)) {
            // 下一次触发仍在区间内，延迟intervalHours小时
            val delay = nextTrigger.timeInMillis - System.currentTimeMillis()
            Result.retry().setBackoffCriteria(BackoffPolicy.LINEAR, delay, TimeUnit.MILLISECONDS)
        } else {
            // 下一次触发超出区间，延迟到第二天开始时间
            val nextDayStart = start.clone() as Calendar
            nextDayStart.add(Calendar.DAY_OF_MONTH, 1)
            val delay = nextDayStart.timeInMillis - System.currentTimeMillis()
            Result.retry().setBackoffCriteria(BackoffPolicy.LINEAR, delay, TimeUnit.MILLISECONDS)
        }
    }

    private fun sendNotification() {
        // 这里实现你的通知发送逻辑
    }
}

启动任务 #

// 计算从当前时间到用户设定的首次开始时间的延迟
fun calculateInitialDelay(startHour: Int, startMinute: Int): Long {
    val current = Calendar.getInstance()
    val startTime = Calendar.getInstance().apply {
        set(Calendar.HOUR_OF_DAY, startHour)
        set(Calendar.MINUTE, startMinute)
        set(Calendar.SECOND, 0)
        if (before(current)) add(Calendar.DAY_OF_MONTH, 1)
    }
    return startTime.timeInMillis - System.currentTimeMillis()
}

// 初始化并启动任务
val initialDelay = calculateInitialDelay(13, 0)
val workRequest = OneTimeWorkRequestBuilder<NotificationWorker>()
    .setInitialDelay(initialDelay, TimeUnit.MILLISECONDS)
    .build()
WorkManager.getInstance(context).enqueue(workRequest)

两种方案对比 #

总结 #

如果你的通知对时间精度要求不是极致严格（比如误差几分钟可以接受），纯WorkManager方案更值得推荐，代码更易维护；如果必须保证每2小时精准触发，你的初始方案是可行的，但一定要注意AlarmManager在不同Android版本的行为差异，以及WorkManager任务的持久化处理。

内容的提问来源于stack exchange，提问作者Elvis