如何实现应用销毁后仍后台运行并随机唤起指定Activity？

Hey there! I totally get your frustration—regular Services get taken down when your app's process is killed, especially with Android's strict background restrictions these days. Let's walk through a reliable way to make your app run persistently in the background and trigger that Activity randomly, even after the app is destroyed.

1. Why regular Services don't work here #

As you've noticed, once your app's process is terminated, the system will stop any running Services that aren't in the foreground. Regular Services just aren't built for long-term persistence when the app isn't actively used.

2. Use WorkManager for persistent random tasks #

WorkManager is Google's recommended tool for deferrable, guaranteed background tasks—it keeps running even if the app is killed or the device restarts. Here's how to set it up:

Step 1: Add WorkManager dependency

First, add the dependency to your app-level build.gradle (Module level):

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

Step 2: Create a custom Worker class

This Worker will handle triggering your target Activity when the task runs. Note the flags we need to start an Activity from the background:

class RandomActivityWorker(context: Context, params: WorkerParameters) : Worker(context, params) {
    override fun doWork(): Result {
        // Check if we have permission to start Activity from background
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M && !Settings.canDrawOverlays(applicationContext)) {
            // If not, trigger a notification to ask user for permission
            return Result.retry()
        }

        val intent = Intent(applicationContext, YourTargetActivity::class.java).apply {
            addFlags(Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_ACTIVITY_CLEAR_TOP)
        }
        applicationContext.startActivity(intent)

        // Schedule the next random task after this one completes
        scheduleNextRandomTask()

        return Result.success()
    }

    private fun scheduleNextRandomTask() {
        // Generate a random delay (e.g., between 10 minutes and 2 hours)
        val random = Random()
        val minDelayMinutes = 10L
        val maxDelayMinutes = 120L
        val delayMinutes = minDelayMinutes + random.nextLong(maxDelayMinutes - minDelayMinutes)
        val delayMillis = delayMinutes * 60 * 1000

        val workRequest = OneTimeWorkRequestBuilder<RandomActivityWorker>()
            .setInitialDelay(delayMillis, TimeUnit.MILLISECONDS)
            .build()

        WorkManager.getInstance(applicationContext).enqueue(workRequest)
    }
}

Step 3: Kick off the first task when your app launches

In your MainActivity or Application class, start the initial random task:

// Call this when your app starts (e.g., in MainActivity's onCreate)
private fun scheduleInitialRandomTask() {
    val random = Random()
    val minDelayMinutes = 10L
    val maxDelayMinutes = 120L
    val delayMinutes = minDelayMinutes + random.nextLong(maxDelayMinutes - minDelayMinutes)
    val delayMillis = delayMinutes * 60 * 1000

    val workRequest = OneTimeWorkRequestBuilder<RandomActivityWorker>()
        .setInitialDelay(delayMillis, TimeUnit.MILLISECONDS)
        .build()

    WorkManager.getInstance(this).enqueue(workRequest)
}

3. Critical: Handle background Activity launch permissions #

Android 10 (API 29) and above block apps from starting Activities from the background by default. To get around this legally, you need:

• Declare the SYSTEM_ALERT_WINDOW permission in your AndroidManifest.xml:

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

• Ask the user to manually enable this permission in system settings. You can trigger the settings intent like this:

  if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M && !Settings.canDrawOverlays(this)) {
      val intent = Intent(Settings.ACTION_MANAGE_OVERLAY_PERMISSION, Uri.parse("package:" + packageName))
      startActivity(intent)
  }
  

4. Alternative: AlarmManager (for more immediate triggers) #

If WorkManager's scheduling isn't flexible enough, you can use AlarmManager with a BroadcastReceiver. But note that AlarmManager gets throttled in Doze mode, so WorkManager is still the better choice for most persistence cases.

Key Notes #

• Don't overdo the random triggers—too many background Activity launches will annoy users and might get your app flagged as malicious.
• Test thoroughly by killing your app process (long press in recent apps) to ensure the tasks still fire.
• For Android 12+, even with SYSTEM_ALERT_WINDOW, there are edge cases where background launches might be blocked—consider using a notification that opens the Activity when tapped as a fallback.

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