test(replay): Add deadlock test for close() with blocked executor task

Verifies close() completes when an executor task is waiting on
lifecycleLock, ensuring shutdown happens outside the lock.

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

@@ -131,7 +131,7 @@ public class ReplayIntegration(
   private var replayCaptureStrategyProvider: ((isFullSession: Boolean) -> CaptureStrategy)? = null
   private var mainLooperHandler: MainLooperHandler = MainLooperHandler()
   private var gestureRecorderProvider: (() -> GestureRecorder)? = null
-  private val lifecycleLock = AutoClosableReentrantLock()
+  internal val lifecycleLock = AutoClosableReentrantLock()
   private val lifecycle = ReplayLifecycle()
 
   override fun register(scopes: IScopes, options: SentryOptions) {

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

@@ -25,12 +25,14 @@ import io.sentry.transport.CurrentDateProvider
 import io.sentry.transport.ICurrentDateProvider
 import io.sentry.transport.RateLimiter
 import java.time.Duration
+import java.util.concurrent.CountDownLatch
 import java.util.concurrent.Executors
 import java.util.concurrent.TimeUnit
 import java.util.concurrent.atomic.AtomicBoolean
 import kotlin.test.BeforeTest
 import kotlin.test.assertEquals
 import kotlin.test.assertNotEquals
+import kotlin.test.assertTrue
 import org.awaitility.core.ConditionTimeoutException
 import org.awaitility.kotlin.await
 import org.junit.Rule
@@ -254,6 +256,45 @@ class ReplaySmokeTest {
     assertNotEquals(falseReplay.rootViewsSpy, replay.rootViewsSpy)
     assertEquals(0, falseReplay.rootViewsSpy.listeners.size)
   }
+
+  @Test
+  fun `close does not deadlock when executor task is waiting on lifecycleLock`() {
+    fixture.options.sessionReplay.sessionSampleRate = 1.0
+    fixture.options.cacheDirPath = tmpDir.newFolder().absolutePath
+
+    val replay = fixture.getSut(context)
+    replay.register(fixture.scopes, fixture.options)
+    replay.start()
+
+    val taskBlocked = CountDownLatch(1)
+    val lockReleased = CountDownLatch(1)
+
+    // hold lifecycleLock on this thread
+    val token = replay.lifecycleLock.acquire()
+
+    // submit a task on the executor that tries to acquire the same lock — it will block
+    replay.replayExecutor.submit {
+      taskBlocked.countDown()
+      replay.lifecycleLock.acquire().use {}
+    }
+
+    // wait for the executor task to actually be running and blocked
+    assertTrue(taskBlocked.await(2, TimeUnit.SECONDS))
+
+    // release the lock, then close — if shutdown were inside the lock this would deadlock
+    token.close()
+
+    // close() must complete within a reasonable time
+    val closedInTime = AtomicBoolean(false)
+    val closeThread = Thread {
+      replay.close()
+      closedInTime.set(true)
+    }
+    closeThread.start()
+    closeThread.join(5000)
+
+    assertTrue(closedInTime.get(), "close() deadlocked")
+  }
 }
 
 private class ExampleActivity : Activity() {