Foreground Service的onDestroy()失效，需解决应用清理后重启问题

当用户从最近应用列表划掉应用（强制终止进程）时，Android 8.0+系统会直接销毁整个应用进程，onDestroy()方法根本不会被调用，所以你在onDestroy()里设置的重启逻辑完全无法触发。另外，你的代码还存在两个基础适配问题：

1. 未创建通知渠道（Android 8.0+要求前台服务必须关联已创建的通知渠道）
2. 未适配Android 12+的POST_NOTIFICATIONS权限要求

一、修复基础适配问题 #

先确保前台服务能正常运行，再处理重启逻辑：

1. 添加通知渠道创建逻辑
   在ForegroundService中新增创建渠道的方法，并在启动前台服务前调用：

private fun createNotificationChannel() {
    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
        val channel = NotificationChannel(
            "persistent_service_channel",
            "后台服务通知",
            NotificationManager.IMPORTANCE_LOW
        )
        val notificationManager = getSystemService(NotificationManager::class.java)
        notificationManager.createNotificationChannel(channel)
    }
}

然后在onStartCommand()的开头调用createNotificationChannel()。

2. 适配Android 12+通知权限
   在AndroidManifest.xml中声明权限：

<uses-permission android:name="android.permission.POST_NOTIFICATIONS" />

在启动服务前动态申请该权限：

// 在Activity中调用
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU &&
    ContextCompat.checkSelfPermission(this, Manifest.permission.POST_NOTIFICATIONS) != PackageManager.PERMISSION_GRANTED) {
    ActivityCompat.requestPermissions(this, arrayOf(Manifest.permission.POST_NOTIFICATIONS), 1001)
}

二、实现强制终止后的服务重启 #

因为onDestroy()无法触发，必须使用独立于应用进程的系统级机制来监控并重启服务，推荐两种方案：

方案1：使用WorkManager（推荐，Jetpack官方组件，适配性最好）

WorkManager的任务由系统托管，即使应用进程被杀死，仍能在满足条件时执行。

• 首先添加依赖（build.gradle）：

implementation "androidx.work:work-runtime:2.8.1"

• 创建检查服务状态的Worker：

class ServiceCheckWorker(context: Context, params: WorkerParameters) : Worker(context, params) {
    override fun doWork(): Result {
        if (!isForegroundServiceRunning(ForegroundService::class.java)) {
            val intent = Intent(applicationContext, ForegroundService::class.java)
            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
                applicationContext.startForegroundService(intent)
            } else {
                applicationContext.startService(intent)
            }
        }
        return Result.success()
    }

    private fun isForegroundServiceRunning(serviceClass: Class<*>): Boolean {
        val activityManager = applicationContext.getSystemService(Context.ACTIVITY_SERVICE) as ActivityManager
        return activityManager.getRunningServices(Int.MAX_VALUE).any {
            it.service.className == serviceClass.name && it.foreground
        }
    }
}

• 在ForegroundService的onStartCommand()中调度周期性检查任务：

override fun onStartCommand(intent: Intent?, flags: Int, startId: Int): Int {
    createNotificationChannel()
    createForegroundNotification()
    Log.d("MyPersistentsService","Services started")
    
    // 每5分钟检查一次服务状态，若未运行则重启
    val workRequest = PeriodicWorkRequestBuilder<ServiceCheckWorker>(5, TimeUnit.MINUTES)
        .setConstraints(Constraints.Builder()
            .setRequiresBatteryNotLow(true) // 可选，根据需求设置运行约束
            .build())
        .build()
    WorkManager.getInstance(this).enqueueUniquePeriodicWork(
        "ServiceCheckTask",
        ExistingPeriodicWorkPolicy.REPLACE,
        workRequest
    )
    
    return START_STICKY
}

方案2：使用AlarmManager + BroadcastReceiver

通过广播接收器实现重启，适合需要更灵活定时逻辑的场景：

• 创建重启服务的广播接收器：

class RestartServiceReceiver : BroadcastReceiver() {
    override fun onReceive(context: Context?, intent: Intent?) {
        context?.let { ctx ->
            val serviceIntent = Intent(ctx, ForegroundService::class.java)
            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
                ctx.startForegroundService(serviceIntent)
            } else {
                ctx.startService(serviceIntent)
            }
        }
    }
}

• 在AndroidManifest.xml中注册接收器：

<receiver android:name=".RestartServiceReceiver" android:exported="false" />

• 在ForegroundService启动时设置周期性闹钟：

private fun schedulePeriodicRestart() {
    val alarmManager = getSystemService(ALARM_SERVICE) as AlarmManager
    val restartIntent = Intent(this, RestartServiceReceiver::class.java)
    val pendingIntent = PendingIntent.getBroadcast(
        this,
        0,
        restartIntent,
        PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_IMMUTABLE
    )
    
    val triggerAt = System.currentTimeMillis() + 60 * 1000
    // 适配Doze模式，确保闹钟能触发
    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
        alarmManager.setExactAndAllowWhileIdle(
            AlarmManager.RTC_WAKEUP,
            triggerAt,
            pendingIntent
        )
    } else {
        alarmManager.setRepeating(
            AlarmManager.RTC_WAKEUP,
            triggerAt,
            60 * 1000,
            pendingIntent
        )
    }
}

然后在onStartCommand()中调用schedulePeriodicRestart()。

三、应对厂商定制ROM限制 #

国内小米、华为、OPPO等厂商的ROM会对后台应用进行严格限制，即使上述逻辑正常，仍可能被强制杀死。必须引导用户进行以下设置：

1. 关闭应用的电池优化：跳转到系统设置页面让用户将应用设为“不优化”
2. 添加到后台保护/自启动白名单：不同厂商路径不同，可在应用内弹出引导说明
3. 必要时允许悬浮窗权限（部分厂商要求）

代码示例（跳转到电池优化设置）：

fun requestDisableBatteryOptimization(context: Context) {
    val powerManager = context.getSystemService(Context.POWER_SERVICE) as PowerManager
    if (!powerManager.isIgnoringBatteryOptimizations(context.packageName)) {
        val intent = Intent(Settings.ACTION_REQUEST_IGNORE_BATTERY_OPTIMIZATIONS)
        intent.data = Uri.parse("package:${context.packageName}")
        context.startActivity(intent)
    }
}

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