Android唤醒状态下凌晨12点每日定时任务实现方法咨询

嘿，这个需求我之前帮朋友处理过类似的，结合你的应用始终保持屏幕唤醒的特点，给你几个靠谱的实现方案，按需选择就行：

如果你需要任务准点在凌晨12点触发，AlarmManager是最稳妥的选择，哪怕系统资源紧张，它也能保证触发（当然前提是你的应用没被彻底清掉）。

实现步骤： #

1. 写一个后台服务来处理长时间任务：
   这个服务里要把耗时操作放到后台线程，绝对不能阻塞主线程，不然会触发ANR。任务完成后再切回主线程更新UI。

   class DailyTaskService : Service() {
       override fun onStartCommand(intent: Intent?, flags: Int, startId: Int): Int {
           // 开个后台线程跑耗时任务
           Thread {
               // 这里放你的业务逻辑，比如数据计算、接口请求啥的
               doLongRunningJob()
               
               // 切回主线程更新布局
               runOnUiThread {
                   updateLayoutValues()
               }
           }.start()
           
           return START_STICKY // 如果服务被意外杀死，系统会尝试重启它
       }
   
       private fun doLongRunningJob() {
           // 模拟5秒耗时操作，替换成你的实际逻辑
           Thread.sleep(5000)
       }
   
       private fun updateLayoutValues() {
           // 假设你的Activity有全局引用（或者用ViewModel/LiveData更优雅）
           (application as MyApp).mainActivity?.run {
               findViewById<TextView>(R.id.tv_display).text = "今日任务完成：${System.currentTimeMillis()}"
           }
       }
   
       override fun onBind(intent: Intent?): IBinder? = null
   }
   

2. 在AndroidManifest.xml里注册这个服务：

   <service android:name=".DailyTaskService" />
   

3. 设置每日重复的闹钟：
   在你的主Activity里初始化AlarmManager，计算好凌晨12点的触发时间，如果当前已经过了12点，就自动顺延到第二天。

   private fun setupDailyAlarm() {
       val alarmManager = getSystemService(Context.ALARM_SERVICE) as AlarmManager
       val intent = Intent(this, DailyTaskService::class.java)
       val pendingIntent = PendingIntent.getService(this, 0, intent, PendingIntent.FLAG_IMMUTABLE)
   
       val triggerTime = Calendar.getInstance().apply {
           timeInMillis = System.currentTimeMillis()
           set(Calendar.HOUR_OF_DAY, 0)
           set(Calendar.MINUTE, 0)
           set(Calendar.SECOND, 0)
           // 现在已经过了12点？那就设到明天的12点
           if (timeInMillis <= System.currentTimeMillis()) {
               add(Calendar.DAY_OF_MONTH, 1)
           }
       }.timeInMillis
   
       // 设置每天重复触发
       alarmManager.setRepeating(
           AlarmManager.RTC_WAKEUP, // 因为你应用一直唤醒，用RTC也行，但WAKEUP更保险
           triggerTime,
           AlarmManager.INTERVAL_DAY,
           pendingIntent
       )
   }
   

如果你的应用需要适配Android 12+的后台限制，WorkManager是官方推荐的方案，它会自动根据系统状态调整任务执行时机，而且支持周期性任务。

实现步骤： #

1. 写一个Worker类处理任务：
   CoroutineWorker自带协程支持，不用手动开线程，很方便。

   class DailyWorker(context: Context, params: WorkerParameters) : CoroutineWorker(context, params) {
       override suspend fun doWork(): Result {
           // 执行耗时任务，协程里直接写就行
           doLongRunningJob()
           
           // 发个广播通知UI更新（或者用LiveData更优雅）
           val updateIntent = Intent("com.your.app.TASK_DONE")
           updateIntent.putExtra("task_result", "今日任务已完成")
           LocalBroadcastManager.getInstance(applicationContext).sendBroadcast(updateIntent)
           
           return Result.success()
       }
   
       private suspend fun doLongRunningJob() {
           // 模拟耗时操作
           delay(5000)
       }
   }
   

2. 配置周期性任务：
   在Activity里初始化WorkManager，设置每天凌晨12点触发。

   private fun setupDailyWork() {
       val calendar = Calendar.getInstance().apply {
           set(Calendar.HOUR_OF_DAY, 0)
           set(Calendar.MINUTE, 0)
           set(Calendar.SECOND, 0)
       }
   
       // 计算第一次触发的延迟时间
       val initialDelay = if (calendar.timeInMillis <= System.currentTimeMillis()) {
           calendar.add(Calendar.DAY_OF_MONTH, 1)
           calendar.timeInMillis - System.currentTimeMillis()
       } else {
           calendar.timeInMillis - System.currentTimeMillis()
       }
   
       val dailyWork = PeriodicWorkRequestBuilder<DailyWorker>(1, TimeUnit.DAYS)
           .setInitialDelay(initialDelay, TimeUnit.MILLISECONDS)
           .build()
   
       WorkManager.getInstance(this).enqueue(dailyWork)
   }
   

3. 接收任务完成通知更新UI：
   在Activity里注册广播接收器，收到通知后更新布局。

   private val taskReceiver = object : BroadcastReceiver() {
       override fun onReceive(context: Context?, intent: Intent?) {
           val result = intent?.getStringExtra("task_result") ?: ""
           findViewById<TextView>(R.id.tv_display).text = result
       }
   }
   
   override fun onResume() {
       super.onResume()
       LocalBroadcastManager.getInstance(this).registerReceiver(
           taskReceiver,
           IntentFilter("com.your.app.TASK_DONE")
       )
   }
   
   override fun onPause() {
       super.onPause()
       LocalBroadcastManager.getInstance(this).unregisterReceiver(taskReceiver)
   }
   

既然你的应用始终保持屏幕唤醒、不退出，那用Handler循环延迟是最简单的方式，不用依赖系统组件，自己控制任务节奏。

实现代码： #

private val mainHandler = Handler(Looper.getMainLooper())
private val dailyTask = object : Runnable {
    override fun run() {
        // 开后台线程执行耗时任务
        Thread {
            doLongRunningJob()
            
            // 切回主线程更新UI
            runOnUiThread {
                updateLayoutValues()
            }
            
            // 计算下一次到12点的延迟，继续循环
            val nextDelay = getNextMidnightDelay()
            mainHandler.postDelayed(this, nextDelay)
        }.start()
    }
}

private fun getNextMidnightDelay(): Long {
    val nextMidnight = Calendar.getInstance().apply {
        set(Calendar.HOUR_OF_DAY, 0)
        set(Calendar.MINUTE, 0)
        set(Calendar.SECOND, 0)
        add(Calendar.DAY_OF_MONTH, 1)
    }.timeInMillis
    return nextMidnight - System.currentTimeMillis()
}

// 在Activity启动时触发第一次任务
override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    setContentView(R.layout.activity_main)
    
    val initialDelay = getNextMidnightDelay()
    mainHandler.postDelayed(dailyTask, initialDelay)
}

// 销毁时移除回调，避免内存泄漏
override fun onDestroy() {
    super.onDestroy()
    mainHandler.removeCallbacks(dailyTask)
}

• 耗时任务必须放后台线程：不管用哪个方案，绝对不能在主线程执行长时间操作，不然会导致应用卡死甚至崩溃。
• 更新UI必须回主线程：安卓的UI控件只能在主线程修改，用runOnUiThread、协程的withContext(Dispatchers.Main)或者LiveData都是可行的方式。
• 内存泄漏要注意：Handler、广播接收器这些要在合适的时机移除/注销，避免内存泄漏。
• Android 12+后台限制：如果你的应用需要适配高版本系统，WorkManager是更稳妥的选择，AlarmManager在后台启动服务会有严格限制，可能需要配合前台服务。

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