// 用于在 Activity 或 Service 中
private val handler = Handler(Looper.getMainLooper())
private val task = object : Runnable {
  override fun run() {
    // 執(zhí)行定時(shí)任務(wù)
    refreshUI()
    // 再次調(diào)度
    handler.postDelayed(this, 5000)
  }
}
 
override fun onStart() {
  super.onStart()
  handler.postDelayed(task, 5000) // 5 秒后首次執(zhí)行
}
 
override fun onStop() {
  super.onStop()
  handler.removeCallbacks(task)  // 停止調(diào)度
}

private var timer: Timer? = null
 
fun startTimer() {
  timer = Timer().apply {
    scheduleAtFixedRate(object : TimerTask() {
      override fun run() {
        // 后臺(tái)線程執(zhí)行
        performBackgroundWork()
      }
    }, 0, 10_000) // 10 秒一次
  }
}
 
fun stopTimer() {
  timer?.cancel()
  timer = null
}

private val scheduler = Executors.newScheduledThreadPool(1)
 
fun startScheduledTask() {
  scheduler.scheduleAtFixedRate({
    performBackgroundWork()
  }, 0, 15, TimeUnit.MINUTES) // 每 15 分鐘執(zhí)行
}
 
fun stopScheduledTask() {
  scheduler.shutdownNow()
}

// 注冊(cè)廣播接收者：AlarmReceiver
class AlarmReceiver: BroadcastReceiver() {
  override fun onReceive(ctx: Context, intent: Intent) {
    // 執(zhí)行任務(wù)
    performWork(ctx)
  }
}
 
// 在 AndroidManifest.xml
<receiver android:name=".AlarmReceiver" />
 
// 在代碼中設(shè)置 Alarm
val am = getSystemService(Context.ALARM_SERVICE) as AlarmManager
val pi = PendingIntent.getBroadcast(this, 0,
    Intent(this, AlarmReceiver::class.java), 0)
// 精準(zhǔn)鬧鐘（API 19+可能被合并）
am.setExactAndAllowWhileIdle(
  AlarmManager.RTC_WAKEUP,
  System.currentTimeMillis() + 60_000,  // 1 分鐘后
  pi
)

class MyJobService: JobService() {
  override fun onStartJob(params: JobParameters): Boolean {
    // 在后臺(tái)線程執(zhí)行
    doWork {
      jobFinished(params, false)
    }
    return true // 還有后臺(tái)線程工作
  }
  override fun onStopJob(params: JobParameters) = false
}
 
// 在 Activity 或 Application 中調(diào)度
val tm = getSystemService(Context.JOB_SCHEDULER_SERVICE) as JobScheduler
val job = JobInfo.Builder(1, ComponentName(this, MyJobService::class.java))
  .setRequiresCharging(false)
  .setRequiredNetworkType(JobInfo.NETWORK_TYPE_ANY)
  .setPeriodic(15 * 60 * 1000) // 最小 15 分鐘
  .build()
tm.schedule(job)

class MyWorker(ctx: Context, params: WorkerParameters): Worker(ctx, params) {
  override fun doWork(): Result {
    performWork(applicationContext)
    return Result.success()
  }
}
 
// 在代碼中調(diào)度
val request = PeriodicWorkRequestBuilder<MyWorker>(1, TimeUnit.HOURS)
  .setConstraints(Constraints.Builder()
    .setRequiredNetworkType(NetworkType.CONNECTED)
    .build())
  .build()
WorkManager.getInstance(this).enqueueUniquePeriodicWork(
  "my_hourly_work",
  ExistingPeriodicWorkPolicy.KEEP,
  request
)

class ForegroundTimerService: Service() {
  private val handler = Handler(Looper.getMainLooper())
  private val task = object: Runnable {
    override fun run() {
      performWork(this@ForegroundTimerService)
      handler.postDelayed(this, 5*60*1000)
    }
  }
  override fun onCreate() {
    super.onCreate()
    startForeground(1, buildNotification())
    handler.post(task)
  }
  override fun onDestroy() {
    handler.removeCallbacks(task)
    super.onDestroy()
  }
  override fun onBind(intent: Intent?) = null
}

// app/build.gradle
plugins {
  id 'com.android.application'
  id 'kotlin-android'
}
 
android {
  compileSdk 34
  defaultConfig {
    applicationId "com.example.scheduletask"
    minSdk 21
    targetSdk 34
  }
}
 
dependencies {
  implementation 'androidx.work:work-runtime-ktx:2.8.1'
}

// =======================================================
// 文件：AndroidManifest.xml
// 描述：聲明 Service 與 BroadcastReceiver
// =======================================================
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    package="com.example.scheduletask">
  <application android:name=".App">
    <!-- AlarmManager Receiver -->
    <receiver android:name=".AlarmReceiver"/>
    <!-- Foreground Service -->
    <service android:name=".ForegroundTimerService"
        android:exported="false"/>
    <!-- JobScheduler Service -->
    <service android:name=".MyJobService"
        android:permission="android.permission.BIND_JOB_SERVICE"/>
  </application>
</manifest>
 
// =======================================================
// 文件：App.kt
// 描述：Application，初始化 WorkManager
// =======================================================
package com.example.scheduletask
import android.app.Application
class App : Application()
 
// =======================================================
// 文件：AlarmReceiver.kt
// 描述：AlarmManager 定時(shí)任務(wù)接收
// =======================================================
package com.example.scheduletask
import android.content.BroadcastReceiver
import android.content.Context
import android.content.Intent
 
class AlarmReceiver : BroadcastReceiver() {
  override fun onReceive(ctx: Context, intent: Intent) {
    TaskUtils.log("AlarmManager triggered")
  }
}
 
// =======================================================
// 文件：MyJobService.kt
// 描述：JobScheduler Service
// =======================================================
package com.example.scheduletask
import android.app.job.JobParameters
import android.app.job.JobService
import kotlinx.coroutines.*
 
class MyJobService: JobService() {
  private val scope = CoroutineScope(Dispatchers.Default)
  override fun onStartJob(params: JobParameters): Boolean {
    scope.launch {
      TaskUtils.log("JobScheduler triggered")
      jobFinished(params, false)
    }
    return true
  }
  override fun onStopJob(params: JobParameters) = false
}
 
// =======================================================
// 文件：ForegroundTimerService.kt
// 描述：前臺(tái) Service + Handler
// =======================================================
package com.example.scheduletask
import android.app.Notification
import android.app.PendingIntent
import android.app.Service
import android.content.Intent
import android.os.*
 
class ForegroundTimerService: Service() {
  private val handler = Handler(Looper.getMainLooper())
  private val task = object : Runnable {
    override fun run() {
      TaskUtils.log("ForegroundService task executed")
      handler.postDelayed(this, 5*60*1000)
    }
  }
  override fun onCreate() {
    super.onCreate()
    startForeground(1, buildNotification())
    handler.post(task)
  }
  override fun onDestroy() {
    handler.removeCallbacks(task)
    super.onDestroy()
  }
  override fun onBind(intent: Intent?) = null
 
  private fun buildNotification(): Notification {
    val pi = PendingIntent.getActivity(
      this,0, Intent(this, MainActivity::class.java),0)
    return Notification.Builder(this, TaskUtils.CHANNEL_ID)
      .setContentTitle("定時(shí)任務(wù)服務(wù)")
      .setSmallIcon(R.drawable.ic_launcher_foreground)
      .setContentIntent(pi)
      .build()
  }
}
 
// =======================================================
// 文件：TaskUtils.kt
// 描述：工具類：日志與調(diào)度注冊(cè)方法
// =======================================================
package com.example.scheduletask
import android.app.AlarmManager
import android.app.PendingIntent
import android.content.Context
import android.content.Intent
import android.app.job.JobInfo
import android.app.job.JobScheduler
import android.content.ComponentName
import androidx.work.*
import java.util.concurrent.TimeUnit
 
object TaskUtils {
  const val CHANNEL_ID = "task_service_channel"
 
  fun scheduleAlarm(ctx: Context){
    val am = ctx.getSystemService(Context.ALARM_SERVICE)
        as AlarmManager
    val pi = PendingIntent.getBroadcast(
      ctx,0, Intent(ctx,AlarmReceiver::class.java),0)
    am.setExactAndAllowWhileIdle(
      AlarmManager.RTC_WAKEUP,
      System.currentTimeMillis()+60_000, pi)
  }
 
  fun scheduleJob(ctx: Context){
    val js = ctx.getSystemService(Context.JOB_SCHEDULER_SERVICE)
      as JobScheduler
    val job = JobInfo.Builder(1,
      ComponentName(ctx, MyJobService::class.java))
      .setPeriodic(15*60*1000)
      .build()
    js.schedule(job)
  }
 
  fun scheduleWork(){
    val req = PeriodicWorkRequestBuilder<MyWorker>(
      1, TimeUnit.HOURS).build()
    WorkManager.getInstance(App.instance)
      .enqueueUniquePeriodicWork(
        "my_hourly_work",
        ExistingPeriodicWorkPolicy.KEEP,
        req)
  }
}
 
// =======================================================
// 文件：MyWorker.kt
// 描述：WorkManager Worker
// =======================================================
package com.example.scheduletask
import android.content.Context
import androidx.work.Worker
import androidx.work.WorkerParameters
 
class MyWorker(ctx: Context, params: WorkerParameters)
  : Worker(ctx, params) {
  override fun doWork(): Result {
    TaskUtils.log("WorkManager triggered")
    return Result.success()
  }
}
 
// =======================================================
// 文件：MainActivity.kt
// 描述：演示各方案觸發(fā)與開始
// =======================================================
package com.example.scheduletask
import android.Manifest
import android.content.Intent
import android.os.*
import androidx.appcompat.app.AppCompatActivity
import com.example.scheduletask.databinding.ActivityMainBinding
 
class MainActivity : AppCompatActivity() {
  private lateinit var b: ActivityMainBinding
  override fun onCreate(s: Bundle?) {
    super.onCreate(s)
    b = ActivityMainBinding.inflate(layoutInflater); setContentView(b.root)
 
    b.btnHandler.setOnClickListener {
      handler.postDelayed(runnable, 5000)
    }
    b.btnTimer.setOnClickListener { startTimer() }
    b.btnScheduled.setOnClickListener { startScheduled() }
    b.btnAlarm.setOnClickListener { TaskUtils.scheduleAlarm(this) }
    b.btnJob.setOnClickListener { TaskUtils.scheduleJob(this) }
    b.btnWork.setOnClickListener { TaskUtils.scheduleWork() }
    b.btnService.setOnClickListener {
      startService(Intent(this, ForegroundTimerService::class.java))
    }
  }
 
  // Handler 示例
  private val handler = Handler(Looper.getMainLooper())
  private val runnable = object: Runnable {
    override fun run() {
      TaskUtils.log("Handler.postDelayed triggered")
    }
  }
 
  // Timer 示例
  private var timer: Timer? = null
  private fun startTimer(){
    timer?.cancel()
    timer = Timer().apply {
      schedule(object: TimerTask(){
        override fun run() {
          TaskUtils.log("TimerTask triggered")
        }
      }, 0, 10000)
    }
  }
 
  // ScheduledThreadPoolExecutor 示例
  private val scheduler = Executors.newScheduledThreadPool(1)
  private fun startScheduled(){
    scheduler.scheduleAtFixedRate({
      TaskUtils.log("ScheduledThreadPoolExecutor triggered")
    },0,30,TimeUnit.SECONDS)
  }
}