Use shutdownNow() for replay executors in close() to avoid ANR

shutdown() calls awaitTermination() which blocks up to
shutdownTimeoutMillis. Since close() can run on the main thread
(via Sentry.close() from hybrid SDKs), this risks an ANR.
shutdownNow() is non-blocking and sufficient at teardown.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: romtsn

sentry-android-replay/src/main/java/io/sentry/android/replay/ReplayIntegration.kt

@@ -107,15 +107,17 @@ public class ReplayIntegration(
   private var gestureRecorder: GestureRecorder? = null
   private val random by lazy { Random() }
   internal val rootViewsSpy by lazy { RootViewsSpy.install() }
-  private val replayExecutor by lazy {
+  private val lazyReplayExecutor = lazy {
     val delegate = Executors.newSingleThreadScheduledExecutor(ReplayExecutorServiceThreadFactory())
     ReplayExecutorService(delegate, options)
   }
-  private val persistingExecutor by lazy {
+  private val replayExecutor by lazyReplayExecutor
+  private val lazyPersistingExecutor = lazy {
     val delegate =
       Executors.newSingleThreadScheduledExecutor(ReplayPersistingExecutorServiceThreadFactory())
     ReplayExecutorService(delegate, options)
   }
+  private val persistingExecutor by lazyPersistingExecutor
 
   internal val isEnabled = AtomicBoolean(false)
   internal val isManualPause = AtomicBoolean(false)
@@ -380,8 +382,20 @@ public class ReplayIntegration(
       recorder?.close()
       recorder = null
       rootViewsSpy.close()
-      replayExecutor.shutdown()
-      persistingExecutor.shutdown()
+      if (lazyReplayExecutor.isInitialized()) {
+        if (options.threadChecker.isMainThread) {
+          replayExecutor.gracefulShutdown()
+        } else {
+          replayExecutor.shutdown()
+        }
+      }
+      if (lazyPersistingExecutor.isInitialized()) {
+        if (options.threadChecker.isMainThread) {
+          persistingExecutor.gracefulShutdown()
+        } else {
+          persistingExecutor.shutdown()
+        }
+      }
       lifecycle.currentState = CLOSED
     }
   }

sentry-android-replay/src/main/java/io/sentry/android/replay/util/ReplayExecutorService.kt

@@ -57,6 +57,14 @@ internal class ReplayExecutorService(
       }
     }
   }
+
+  fun gracefulShutdown() {
+    synchronized(this) {
+      if (!isShutdown) {
+        delegate.shutdown()
+      }
+    }
+  }
 }
 
 internal class ReplayRunnable(val taskName: String, delegate: Runnable) : Runnable by delegate

sentry-android-replay/src/test/java/io/sentry/android/replay/ReplayIntegrationTest.kt

@@ -48,6 +48,7 @@ import io.sentry.transport.CurrentDateProvider
 import io.sentry.transport.ICurrentDateProvider
 import io.sentry.transport.RateLimiter
 import io.sentry.util.Random
+import io.sentry.util.thread.IThreadChecker
 import java.io.ByteArrayOutputStream
 import java.io.File
 import kotlin.test.BeforeTest
@@ -1113,20 +1114,23 @@ class ReplayIntegrationTest {
   @Test
   fun `close shuts down persisting executor so no SentryReplayPersister threads leak`() {
     fixture.options.cacheDirPath = tmpDir.newFolder().absolutePath
-    fixture.options.threadChecker = mock {
-      on { isMainThread }.thenReturn(true)
-      on { isMainThread(any<Thread>()) }.thenReturn(true)
-    }
+    fixture.options.shutdownTimeoutMillis = 0
+    val mainThreadChecker = mock<IThreadChecker>()
+    whenever(mainThreadChecker.isMainThread).thenReturn(true)
+    whenever(mainThreadChecker.isMainThread(any<Thread>())).thenReturn(true)
+    val defaultThreadChecker = fixture.options.threadChecker
 
     repeat(3) {
+      fixture.options.threadChecker = mainThreadChecker
       val replay = fixture.getSut(context)
       replay.register(fixture.scopes, fixture.options)
       replay.start()
       replay.stop()
+      fixture.options.threadChecker = defaultThreadChecker
       replay.close()
     }
 
-    Thread.sleep(200)
+    Thread.sleep(500)
 
     val leakedThreads =
       Thread.getAllStackTraces().keys.filter { it.name.startsWith("SentryReplayPersister-") }