Add integration tests for background ANR monitoring stop (#2269)

Author: priettt

embrace-android-features/src/main/kotlin/io/embrace/android/embracesdk/internal/anr/EmbraceAnrService.kt

@@ -14,6 +14,7 @@ import io.embrace.android.embracesdk.internal.session.lifecycle.ProcessStateServ
 import io.embrace.android.embracesdk.internal.worker.BackgroundWorker
 import java.util.concurrent.Callable
 import java.util.concurrent.CopyOnWriteArrayList
+import java.util.concurrent.ScheduledFuture
 import java.util.concurrent.TimeUnit
 
 /**
@@ -36,6 +37,7 @@ internal class EmbraceAnrService(
 ) : AnrService, MemoryCleanerListener, ProcessStateListener, BlockedThreadListener {
 
     private val listeners: CopyOnWriteArrayList<BlockedThreadListener> = CopyOnWriteArrayList<BlockedThreadListener>()
+    private var delayedBackgroundCheckTask: ScheduledFuture<*>? = null
 
     init {
         if (processStateService.isInBackground) {
@@ -111,6 +113,8 @@ internal class EmbraceAnrService(
      */
     override fun onForeground(coldStart: Boolean, timestamp: Long) {
         this.anrMonitorWorker.submit {
+            // Cancel any pending delayed background check since we're now in foreground
+            cancelDelayedBackgroundCheck()
             state.resetState()
             livenessCheckScheduler.startMonitoringThread()
         }
@@ -144,7 +148,15 @@ internal class EmbraceAnrService(
      * This handles slow app startup scenarios where the app takes time to transition to foreground.
      */
     private fun scheduleDelayedBackgroundCheck() {
-        anrMonitorWorker.schedule<Unit>(::stopMonitoringIfStillInBackground, 10, TimeUnit.SECONDS)
+        delayedBackgroundCheckTask = anrMonitorWorker.schedule<Unit>(::stopMonitoringIfStillInBackground, 10, TimeUnit.SECONDS)
+    }
+
+    /**
+     * Cancels the delayed background check task if it exists.
+     */
+    private fun cancelDelayedBackgroundCheck() {
+        delayedBackgroundCheckTask?.cancel(false)
+        delayedBackgroundCheckTask = null
     }
 
     /**
@@ -155,6 +167,7 @@ internal class EmbraceAnrService(
         if (processStateService.isInBackground) {
             livenessCheckScheduler.stopMonitoringThread()
         }
+        delayedBackgroundCheckTask = null
     }
 
     private companion object {

embrace-android-features/src/test/java/io/embrace/android/embracesdk/internal/anr/EmbraceAnrServiceRule.kt

@@ -40,18 +40,19 @@ internal class EmbraceAnrServiceRule<T : ScheduledExecutorService>(
     lateinit var targetThreadHandler: TargetThreadHandler
     lateinit var anrMonitorThread: AtomicReference<Thread>
     lateinit var stacktraceSampler: AnrStacktraceSampler
+    lateinit var looper: Looper
+    lateinit var worker: BackgroundWorker
 
     override fun before() {
         clock.setCurrentTime(0)
-        val looper: Looper = mockk(relaxed = true)
+        looper = mockk(relaxed = true)
         anrBehavior = FakeAnrBehavior()
         anrMonitorThread = AtomicReference(Thread.currentThread())
         fakeConfigService = FakeConfigService(anrBehavior = anrBehavior)
         fakeProcessStateService = FakeProcessStateService(false)
         anrExecutorService = scheduledExecutorSupplier.invoke()
         state = ThreadMonitoringState(clock)
-        val worker =
-            BackgroundWorker(anrExecutorService)
+        worker = BackgroundWorker(anrExecutorService)
         targetThreadHandler = TargetThreadHandler(
             looper = looper,
             anrMonitorWorker = worker,
@@ -90,4 +91,21 @@ internal class EmbraceAnrServiceRule<T : ScheduledExecutorService>(
             processStateService = fakeProcessStateService
         )
     }
+
+    /**
+     * Recreates the ANR service. Useful for tests where we need to update the fakes that we pass to the EmbraceAnrService.
+     */
+    fun recreateService() {
+        anrService = EmbraceAnrService(
+            configService = fakeConfigService,
+            looper = looper,
+            logger = logger,
+            livenessCheckScheduler = livenessCheckScheduler,
+            anrMonitorWorker = worker,
+            state = state,
+            clock = clock,
+            stacktraceSampler = stacktraceSampler,
+            processStateService = fakeProcessStateService
+        )
+    }
 }

embrace-android-features/src/test/java/io/embrace/android/embracesdk/internal/anr/EmbraceAnrServiceTimingTest.kt

@@ -9,6 +9,7 @@ import org.junit.Before
 import org.junit.Rule
 import org.junit.Test
 import java.lang.Thread.currentThread
+import java.util.concurrent.TimeUnit
 import java.util.concurrent.atomic.AtomicReference
 
 /**
@@ -67,4 +68,81 @@ internal class EmbraceAnrServiceTimingTest {
             assertEquals(1, anrExecutorService.scheduledTasksCount())
         }
     }
+
+    @Test
+    fun `test delayed background check stops monitoring when app remains in background`() {
+        with(rule) {
+            // Set background state and recreate service
+            fakeProcessStateService.isInBackground = true
+            recreateService()
+
+            // Start ANR capture - this should trigger scheduleDelayedBackgroundCheck
+            anrService.startAnrCapture()
+            anrExecutorService.runCurrentlyBlocked()
+
+            // Monitoring is initially started (even in background)
+            assertTrue(state.started.get())
+
+            // Advance time by 9 seconds - monitoring should still be active
+            anrExecutorService.moveForwardAndRunBlocked(TimeUnit.SECONDS.toMillis(9))
+            assertTrue(state.started.get())
+
+            // Advance time by 2 more second to trigger the 10-second delayed check
+            anrExecutorService.moveForwardAndRunBlocked(TimeUnit.SECONDS.toMillis(1))
+
+            // Run any pending tasks to ensure the delayed check executes
+            anrExecutorService.runCurrentlyBlocked()
+
+            // Verify that monitoring is now stopped because app is still in background
+            assertFalse(state.started.get())
+        }
+    }
+
+    @Test
+    fun `test delayed background check does not stop monitoring when app transitions to foreground`() {
+        with(rule) {
+            // Set background state and recreate service
+            fakeProcessStateService.isInBackground = true
+            recreateService()
+
+            // Start ANR capture - this should trigger scheduleDelayedBackgroundCheck
+            anrService.startAnrCapture()
+            anrExecutorService.runCurrentlyBlocked()
+
+            // Monitoring is initially started (even in background)
+            assertTrue(state.started.get())
+
+            // Advance time by 5 seconds
+            anrExecutorService.moveForwardAndRunBlocked(TimeUnit.SECONDS.toMillis(5))
+
+            // Transition to foreground before the 10-second delay
+            fakeProcessStateService.isInBackground = false
+            anrService.onForeground(false, clock.now())
+            anrExecutorService.runCurrentlyBlocked()
+
+            // Advance time by 5 more seconds to reach the 10-second mark
+            anrExecutorService.moveForwardAndRunBlocked(TimeUnit.SECONDS.toMillis(5))
+
+            // Verify that monitoring is still active because app is now in foreground
+            assertTrue(state.started.get())
+        }
+    }
+
+    @Test
+    fun `test delayed background check is not scheduled when app starts in foreground`() {
+        with(rule) {
+            // Start ANR capture - this won't trigger scheduleDelayedBackgroundCheck as the default state is foreground
+            anrService.startAnrCapture()
+            anrExecutorService.runCurrentlyBlocked()
+
+            // Verify that monitoring is started
+            assertTrue(state.started.get())
+
+            // Advance time by 15 seconds to ensure any delayed check would have triggered
+            anrExecutorService.moveForwardAndRunBlocked(TimeUnit.SECONDS.toMillis(15))
+
+            // Verify that monitoring is still active (no delayed check was scheduled)
+            assertTrue(state.started.get())
+        }
+    }
 }