寻求前台服务生命周期内的本地定时任务方案（替代AlarmManager等）

核心思路 #

基于LocalBroadcastManager + ScheduledExecutorService封装一个和前台服务生命周期绑定的定时调度器，直接支持按指定日期/时间配置单次或每日重复任务，无需依赖系统闹钟或手动计算延迟。

具体实现步骤 #

1. 定义定时任务实体类

用来存储任务核心配置，包括触发时间、重复模式、对应广播标识：

data class ScheduledTask(
    val taskId: String,
    val triggerTime: Long, // 首次触发的时间戳（毫秒）
    val isDailyRepeat: Boolean,
    val broadcastAction: String
)

2. 封装定时调度器

在前台服务内部实现调度器，负责计算触发延迟、调度任务并发送本地广播：

class ForegroundTaskScheduler(private val context: Context) {
    private val scheduledExecutor = Executors.newSingleThreadScheduledExecutor()
    private val taskMap = mutableMapOf<String, ScheduledFuture<*>>()

    // 添加定时任务
    fun addTask(task: ScheduledTask) {
        // 先移除同名任务避免重复调度
        removeTask(task.taskId)
        
        val initialDelay = calculateInitialDelay(task)
        val period = if (task.isDailyRepeat) 24 * 60 * 60 * 1000L else 0L

        val future = if (task.isDailyRepeat) {
            scheduledExecutor.scheduleAtFixedRate(
                { sendBroadcast(task.broadcastAction) },
                initialDelay,
                period,
                TimeUnit.MILLISECONDS
            )
        } else {
            scheduledExecutor.schedule(
                { 
                    sendBroadcast(task.broadcastAction)
                    // 单次任务执行后自动清理
                    taskMap.remove(task.taskId)
                },
                initialDelay,
                TimeUnit.MILLISECONDS
            )
        }
        taskMap[task.taskId] = future
    }

    // 移除指定任务
    fun removeTask(taskId: String) {
        taskMap[taskId]?.cancel(false)
        taskMap.remove(taskId)
    }

    // 清空所有任务
    fun clearAllTasks() {
        taskMap.values.forEach { it.cancel(false) }
        taskMap.clear()
    }

    // 计算首次触发的延迟时间
    private fun calculateInitialDelay(task: ScheduledTask): Long {
        val now = System.currentTimeMillis()
        return if (task.triggerTime > now) {
            task.triggerTime - now
        } else {
            // 设置时间已过时，重复任务顺延到次日，单次任务立即执行
            if (task.isDailyRepeat) {
                task.triggerTime + 24 * 60 * 60 * 1000L - now
            } else {
                0L
            }
        }
    }

    // 发送本地广播触发业务逻辑
    private fun sendBroadcast(action: String) {
        val intent = Intent(action)
        LocalBroadcastManager.getInstance(context).sendBroadcast(intent)
    }
}

3. 前台服务集成调度器

在服务生命周期内初始化调度器、注册广播接收器，确保任务和服务同生共死：

class MyForegroundService : Service() {
    private lateinit var taskScheduler: ForegroundTaskScheduler
    private lateinit var broadcastReceiver: BroadcastReceiver

    override fun onCreate() {
        super.onCreate()
        taskScheduler = ForegroundTaskScheduler(this)
        
        // 注册本地广播接收器处理任务触发事件
        broadcastReceiver = object : BroadcastReceiver() {
            override fun onReceive(context: Context?, intent: Intent?) {
                when (intent?.action) {
                    "ACTION_DAILY_REMINDER" -> {
                        // 执行每日提醒逻辑
                    }
                    "ACTION_ONCE_TASK" -> {
                        // 执行单次任务逻辑
                    }
                }
            }
        }

        val filter = IntentFilter().apply {
            addAction("ACTION_DAILY_REMINDER")
            addAction("ACTION_ONCE_TASK")
        }
        LocalBroadcastManager.getInstance(this).registerReceiver(broadcastReceiver, filter)
    }

    // 对外暴露添加任务的入口，可从外部组件调用
    fun addScheduledTask(task: ScheduledTask) {
        taskScheduler.addTask(task)
    }

    override fun onDestroy() {
        super.onDestroy()
        // 服务销毁时清理所有任务、注销接收器
        taskScheduler.clearAllTasks()
        LocalBroadcastManager.getInstance(this).unregisterReceiver(broadcastReceiver)
    }

    override fun onBind(intent: Intent): IBinder? {
        // 如需绑定服务，返回Binder实例
        return null
    }
}

4. 配置并添加任务

直接按日期时间创建任务，无需计算毫秒延迟：

// 示例：创建明天早上8点的单次任务
val singleTaskCalendar = Calendar.getInstance().apply {
    add(Calendar.DAY_OF_MONTH, 1)
    set(Calendar.HOUR_OF_DAY, 8)
    set(Calendar.MINUTE, 0)
    set(Calendar.SECOND, 0)
}
val singleTask = ScheduledTask(
    taskId = "once_task_001",
    triggerTime = singleTaskCalendar.timeInMillis,
    isDailyRepeat = false,
    broadcastAction = "ACTION_ONCE_TASK"
)
// 通过服务绑定或其他方式调用addScheduledTask添加任务

// 示例：创建每天晚上9点的重复任务
val dailyTaskCalendar = Calendar.getInstance().apply {
    set(Calendar.HOUR_OF_DAY, 21)
    set(Calendar.MINUTE, 0)
    set(Calendar.SECOND, 0)
}
val dailyTask = ScheduledTask(
    taskId = "daily_task_001",
    triggerTime = dailyTaskCalendar.timeInMillis,
    isDailyRepeat = true,
    broadcastAction = "ACTION_DAILY_REMINDER"
)

方案优势 #

• 完全绑定前台服务生命周期，服务销毁自动清理任务，无内存泄漏风险
• 直接支持按日期/时间配置任务，无需手动计算延迟毫秒数
• 本地广播实现调度与业务逻辑解耦，代码结构清晰
• 无需额外系统权限，避免AlarmManager的系统级触发逻辑

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