应用闲置时如何捕获SCREEN_OFF/ON事件？（POC验证场景）

Hey there, let's work through this POC challenge you're having with detecting when a device enters or exits an interactive state! I've dealt with similar Android background restriction hurdles before, so here are practical solutions tailored to your situation:

1. Foreground Service + Dynamic BroadcastReceiver (Real-Time Detection) #

You already noticed dynamic BroadcastReceivers only work while your app is running—so let's fix that by tying the receiver to a foreground service. Foreground services are prioritized by the system (harder to kill) and let you keep listening for SCREEN_ON/SCREEN_OFF events even when your app is in the background.

Here's how to set it up:

• Create a foreground service that registers the receiver in its onCreate() method
• You'll need to show a persistent (but low-priority) notification (required for foreground services) to comply with Android rules
• This setup gives you real-time updates for screen state changes

Code Snippet (Kotlin): #

class ScreenStateMonitorService : Service() {
    private lateinit var screenReceiver: BroadcastReceiver

    override fun onCreate() {
        super.onCreate()
        // Initialize and register the receiver
        screenReceiver = object : BroadcastReceiver() {
            override fun onReceive(context: Context?, intent: Intent?) {
                when (intent?.action) {
                    Intent.ACTION_SCREEN_ON -> {
                        // Handle device entering interactive state
                        Log.d("ScreenMonitor", "Device is now interactive (screen on)")
                    }
                    Intent.ACTION_SCREEN_OFF -> {
                        // Handle device exiting interactive state
                        Log.d("ScreenMonitor", "Device is no longer interactive (screen off)")
                    }
                }
            }
        }
        val intentFilter = IntentFilter().apply {
            addAction(Intent.ACTION_SCREEN_ON)
            addAction(Intent.ACTION_SCREEN_OFF)
        }
        registerReceiver(screenReceiver, intentFilter)

        // Start foreground service with a low-priority notification
        val notification = NotificationCompat.Builder(this, "SCREEN_MONITOR_CHANNEL")
            .setContentTitle("Screen State Monitor")
            .setContentText("Tracking device interaction status")
            .setSmallIcon(R.drawable.ic_monitor)
            .setPriority(NotificationCompat.PRIORITY_LOW)
            .build()
        startForeground(1001, notification)
    }

    override fun onDestroy() {
        super.onDestroy()
        unregisterReceiver(screenReceiver)
    }

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

Manifest Setup: #

Don't forget to declare the service and request necessary permissions (Android 12+ needs POST_NOTIFICATIONS):

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

<service
    android:name=".ScreenStateMonitorService"
    android:foregroundServiceType="dataSync" /> <!-- Match your use case -->

2. WorkManager for Periodic Checks (Non-Real-Time) #

If real-time updates aren't a hard requirement, WorkManager is a better alternative to JobScheduler—it's more flexible, works across Android versions, and survives system reboots. You can set up periodic tasks to check the device's current interactive state on a schedule (minimum 15-minute intervals, enforced by Android).

Code Snippet: #

class ScreenStateCheckWorker(context: Context, params: WorkerParameters) : Worker(context, params) {
    override fun doWork(): Result {
        val powerManager = applicationContext.getSystemService(Context.POWER_SERVICE) as PowerManager
        val isInteractive = powerManager.isInteractive

        if (isInteractive) {
            Log.d("ScreenWorker", "Device is in interactive state")
            // Your logic for interaction state here
        } else {
            Log.d("ScreenWorker", "Device is in non-interactive state")
            // Your logic for non-interaction state here
        }
        return Result.success()
    }
}

// Enqueue the periodic task
val periodicWorkRequest = PeriodicWorkRequestBuilder<ScreenStateCheckWorker>(15, TimeUnit.MINUTES)
    .build()
WorkManager.getInstance(applicationContext).enqueue(periodicWorkRequest)

3. Android 14+ Exclusive: DeviceStateManager #

If your POC targets Android 14 or newer, you can use the new DeviceStateManager API for cleaner, more efficient state listening. No broadcast receivers needed—just attach a listener to get updates when the device's interaction state changes.

Code Snippet: #

val deviceStateManager = getSystemService(Context.DEVICE_STATE_SERVICE) as DeviceStateManager
val stateListener = DeviceStateManager.OnDeviceStateChangedListener { deviceState ->
    when (deviceState.interactionState) {
        DeviceState.INTERACTION_STATE_INTERACTIVE -> {
            // Device is interactive
        }
        DeviceState.INTERACTION_STATE_NON_INTERACTIVE -> {
            // Device is non-interactive
        }
        DeviceState.INTERACTION_STATE_UNKNOWN -> {
            // Handle unknown state
        }
    }
}
// Attach the listener (use a proper executor for background processing)
deviceStateManager.addOnDeviceStateChangedListener(Executors.newSingleThreadExecutor(), stateListener)

Note: This still requires your app process to be alive, so pairing it with a foreground service is recommended for consistent results.

Quick Recap: #

• Need real-time updates? Go with the Foreground Service + Dynamic Receiver combo (or DeviceStateManager for Android 14+).
• Okay with periodic checks? Use WorkManager instead of JobScheduler for better compatibility.
• Avoid Manifest-registered receivers for SCREEN_ON/SCREEN_OFF—Android's background restrictions block these when your app isn't running, so they're useless for your use case.

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