无后台模式下无限运行后台任务的实现方案咨询

Got it, let's walk through how to keep your three critical tasks running reliably—even when your app is in the background or your device goes to sleep. This is tailored for Android (since you're dealing with mobile device background/sleep behavior):

First off, regular timers or handler-based tasks won't cut it here. Android's system aggressively restricts background processes to save battery, and when the device sleeps, the CPU enters a low-power state that pauses most non-critical operations. We need to use platform-specific components to bypass these restrictions.

1. 1-Second Sensor Data Collection #

For a high-frequency, persistent sensor task, you'll need:

• Foreground Service: Android 8+ kills background services after a short window, so moving your sensor collection to a foreground service ensures it stays active. You'll have to show a persistent notification (required by the OS) to let the user know the app is running in the foreground.
• Partial Wake Lock: This keeps the CPU running even when the screen is off. Make sure to acquire it when starting the sensor collection and release it only when the task stops to avoid unnecessary battery drain.
• SensorManager Registration: Register your sensor listener directly in the foreground service. Unlike background processes, foreground services can maintain active sensor connections.

Quick code snippet outline for the service:

class SensorCollectionService : Service() {
    private lateinit var sensorManager: SensorManager
    private lateinit var wakeLock: PowerManager.WakeLock
    private val sensorListener = object : SensorEventListener {
        override fun onSensorChanged(event: SensorEvent) {
            // Save data to SQLite here
        }
        override fun onAccuracyChanged(sensor: Sensor, accuracy: Int) {}
    }

    override fun onCreate() {
        super.onCreate()
        sensorManager = getSystemService(SENSOR_SERVICE) as SensorManager
        // Acquire wake lock
        val powerManager = getSystemService(POWER_SERVICE) as PowerManager
        wakeLock = powerManager.newWakeLock(PowerManager.PARTIAL_WAKE_LOCK, "MyApp::SensorWakeLock")
        wakeLock.acquire()
        // Register sensor
        sensorManager.getDefaultSensor(Sensor.TYPE_ACCELEROMETER)?.let {
            sensorManager.registerListener(sensorListener, it, SensorManager.SENSOR_DELAY_NORMAL)
        }
        // Start foreground notification
        val notification = NotificationCompat.Builder(this, "sensor_channel")
            .setContentTitle("Collecting Sensor Data")
            .setSmallIcon(R.drawable.ic_sensor)
            .build()
        startForeground(1, notification)
    }

    override fun onDestroy() {
        super.onDestroy()
        sensorManager.unregisterListener(sensorListener)
        if (wakeLock.isHeld) wakeLock.release()
    }

    override fun onBind(intent: Intent): IBinder? = null
}

2. 30-Minute AWS IoT Data Sync #

For this less frequent task, WorkManager is the right tool—it's designed for deferrable, reliable background tasks that need to run even if the app is closed or the device restarts. To ensure it runs during sleep:

• Use PeriodicWorkRequest with a 30-minute interval.
• Disable battery restrictions with setRequiresBatteryNotLow(false) and setRequiresCharging(false).
• If you need near-exact timing (not just "within a window"), use setInitialDelay with an exact request, but note that Android 12+ limits exact periodic tasks to reduce battery usage.

Example setup:

val awsSyncWork = PeriodicWorkRequestBuilder<AwsSyncWorker>(30, TimeUnit.MINUTES)
    .setRequiresBatteryNotLow(false)
    .setRequiresCharging(false)
    .build()

WorkManager.getInstance(context).enqueueUniquePeriodicWork(
    "AwsSync",
    ExistingPeriodicWorkPolicy.KEEP,
    awsSyncWork
)

// Worker class
class AwsSyncWorker(context: Context, params: WorkerParameters) : Worker(context, params) {
    override fun doWork(): Result {
        // Fetch data from SQLite and send to AWS IoT
        return Result.success()
    }
}

3. 60-Minute Task Parameter Refresh #

Similar to the AWS sync, but if you need the refresh to happen at exact 60-minute intervals (e.g., to pull new configs at specific times), you might combine WorkManager with AlarmManager using setExactAndAllowWhileIdle(). This ensures the task runs even in Doze mode.

Note: You'll need the REQUEST_SCHEDULE_EXACT_ALARM permission in your manifest, and on Android 12+, you'll have to request it from the user at runtime.

Example AlarmManager setup:

fun scheduleParameterRefresh(context: Context) {
    val alarmManager = context.getSystemService(ALARM_SERVICE) as AlarmManager
    val intent = Intent(context, ParameterRefreshReceiver::class.java)
    val pendingIntent = PendingIntent.getBroadcast(
        context,
        0,
        intent,
        PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_IMMUTABLE
    )

    // Schedule exact alarm every 60 minutes
    val interval = 60 * 60 * 1000L
    val triggerTime = System.currentTimeMillis() + interval
    alarmManager.setExactAndAllowWhileIdle(
        AlarmManager.RTC_WAKEUP,
        triggerTime,
        pendingIntent
    )
}

// Broadcast Receiver
class ParameterRefreshReceiver : BroadcastReceiver() {
    override fun onReceive(context: Context, intent: Intent) {
        // Call API to refresh task parameters
        // Re-schedule the next alarm after refresh
        scheduleParameterRefresh(context)
    }
}

• Battery Optimization Exclusion: Guide users to add your app to the device's battery optimization whitelist. Go to Settings > Battery > Battery Optimization > Find your app > Select "Don't optimize". This prevents the system from throttling your app in Doze mode.
• Permissions: Make sure to declare these in your AndroidManifest.xml:

  <uses-permission android:name="android.permission.WAKE_LOCK" />
  <uses-permission android:name="android.permission.REQUEST_SCHEDULE_EXACT_ALARM" />
  <uses-permission android:name="android.permission.POST_NOTIFICATIONS" />
  <service android:name=".SensorCollectionService" android:foregroundServiceType="dataSync" />
  

• Test Edge Cases: Test your app in background mode, screen-off mode, and after device restarts to ensure all tasks keep running as expected.

While your requirements demand persistent running, keep an eye on battery usage. High-frequency sensor collection (1 second) will drain battery quickly—consider adding a user-configurable option to reduce frequency if possible, or use batch processing for sensor data to minimize CPU wake-ups.

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