[2661] Fix BroadcastReceiver ANR at ScreenOffTrigger

leakcanary/leakcanary-android-release/src/main/java/leakcanary/ScreenOffTrigger.kt

@@ -9,6 +9,11 @@ import android.content.Intent.ACTION_SCREEN_ON
 import android.content.IntentFilter
 import android.os.Build
 import java.util.concurrent.Executor
+import java.util.concurrent.Executors
+import java.util.concurrent.ScheduledExecutorService
+import java.util.concurrent.ScheduledFuture
+import java.util.concurrent.TimeUnit
+import java.util.concurrent.atomic.AtomicReference
 import leakcanary.internal.friendly.checkMainThread
 import shark.SharkLog
 
@@ -19,7 +24,7 @@ class ScreenOffTrigger(
    * The executor on which the analysis is performed and on which [analysisCallback] is called.
    * This should likely be a single thread executor with a background thread priority.
    */
-  private val analysisExecutor: Executor,
+  analysisExecutor: Executor,
 
   /**
    * Called back with a [HeapAnalysisJob.Result] after the screen went off and a
@@ -32,30 +37,38 @@ class ScreenOffTrigger(
   private val analysisCallback: (HeapAnalysisJob.Result) -> Unit = { result ->
     SharkLog.d { "$result" }
   },
+
+  /**
+   * Initial delay to wait for analysisExecutor to start analysis
+   *
+   * If not provided, initial delay is 500ms
+   */
+  private val analysisExecutorDelayMillis: Long = INITIAL_EXECUTOR_DELAY_IN_MILLI
 ) {
 
-  @Volatile
-  private var currentJob: HeapAnalysisJob? = null
+  private val currentJob = AtomicReference<HeapAnalysisJob?>()
 
+  private val delayedScheduledExecutorService = DelayedScheduledExecutorService()
   private val screenReceiver = object : BroadcastReceiver() {
     override fun onReceive(
       context: Context,
       intent: Intent
     ) {
-      if (intent.action == ACTION_SCREEN_OFF) {
-        if (currentJob == null) {
+      if (intent.shouldStartAnalysis()) {
           val job =
             analysisClient.newJob(JobContext(ScreenOffTrigger::class))
-          currentJob = job
-          analysisExecutor.execute {
-            val result = job.execute()
-            currentJob = null
-            analysisCallback(result)
+          if(currentJob.compareAndSet(null, job)){
+            delayedScheduledExecutorService.schedule {
+              val result = job.execute()
+              analysisCallback(result)
+            }
           }
-        }
       } else {
-        currentJob?.cancel("screen on again")
-        currentJob = null
+        delayedScheduledExecutorService.cancel()
+        currentJob.getAndUpdate { job ->
+          job?.cancel("screen on again")
+          null
+        }
       }
     }
   }
@@ -78,4 +91,38 @@ class ScreenOffTrigger(
     checkMainThread()
     application.unregisterReceiver(screenReceiver)
   }
+
+  private fun Intent.shouldStartAnalysis():Boolean{
+    return this.action == ACTION_SCREEN_OFF && currentJob.get() == null
+  }
+
+  private class DelayedScheduledExecutorService(
+    private val analysisExecutorDelayMillis:Long,
+    private val analysisExecutor: Executor){
+
+    private var scheduledFuture:ScheduledFuture<*>?=null
+
+    private val scheduledExecutorService:ScheduledExecutorService by lazy {
+      Executors.newScheduledThreadPool(1)
+    }
+
+    /** Runs the specified [action] after an initial [analysisExecutorDelayMillis] */
+    fun schedule(action:Runnable){
+      scheduledFuture =
+        scheduledExecutorService.schedule(
+          { analysisExecutor.execute(action)},
+          analysisExecutorDelayMillis,
+          TimeUnit.MILLISECONDS
+        )
+    }
+
+    /** Cancels prior ScheduledExecutorService */
+    fun cancel(){
+      scheduledFuture?.cancel(true)
+    }
+  }
+
+  companion object{
+    const val INITIAL_EXECUTOR_DELAY_IN_MILLI = 500L
+  }
 }