fix(android): Re-arm shake detector on re-register (JAVA-618)

The closed latch added to neutralize a warm-up drained after close()
was permanent, so re-registering the same integration (e.g. a second
Sentry.init reusing the same options) left shake detection off with no
recovery. register() now re-arms the detector via reopen(), which the
stale-warm-up path (init()) deliberately does not, preserving the
drain-after-close guard.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

Author: runningcode

sentry-android-core/src/main/java/io/sentry/android/core/FeedbackShakeIntegration.java

@@ -50,6 +50,11 @@ public void register(final @NotNull IScopes scopes, final @NotNull SentryOptions
       return;
     }
 
+    // Re-arm the detector in case this integration is being re-registered after a previous close()
+    // (e.g. a second Sentry.init reusing the same options), otherwise the closed latch would keep
+    // shake detection off permanently.
+    shakeDetector.reopen();
+
     // Resolving the accelerometer is the most expensive part of init (the first SensorManager
     // access), so warm it up off the main thread. start() re-runs init() on demand, so shake
     // detection still works if an activity resumes before this completes.

sentry-android-core/src/main/java/io/sentry/android/core/SentryShakeDetector.java

@@ -52,6 +52,14 @@ public SentryShakeDetector(final @NotNull ILogger logger) {
     this.logger = logger;
   }
 
+  /**
+   * Re-arms the detector after a previous {@link #close()} so it can be reused when the owning
+   * integration is registered again (e.g. a second {@code Sentry.init}).
+   */
+  synchronized void reopen() {
+    closed = false;
+  }
+
   /**
    * Initializes the sensor manager and accelerometer sensor. This is separated from start() so the
    * values can be resolved once and reused across activity transitions.

sentry-android-core/src/test/java/io/sentry/android/core/FeedbackShakeIntegrationTest.kt

@@ -12,6 +12,7 @@ import kotlin.test.BeforeTest
 import kotlin.test.Test
 import org.junit.runner.RunWith
 import org.mockito.kotlin.any
+import org.mockito.kotlin.atLeastOnce
 import org.mockito.kotlin.eq
 import org.mockito.kotlin.mock
 import org.mockito.kotlin.never
@@ -92,6 +93,24 @@ class FeedbackShakeIntegrationTest {
     verify(fixture.application, never()).getSystemService(eq(Context.SENSOR_SERVICE))
   }
 
+  @Test
+  fun `re-registering after close re-arms shake detection`() {
+    // A second Sentry.init reusing the same integration must revive shake detection rather than
+    // stay off because of the closed latch.
+    val deferredExecutor = DeferredExecutorService()
+    fixture.options.executorService = deferredExecutor
+    whenever(fixture.application.getSystemService(any())).thenReturn(null)
+
+    val sut = fixture.getSut(useShakeGesture = true)
+    sut.register(fixture.scopes, fixture.options)
+    sut.close()
+    sut.register(fixture.scopes, fixture.options)
+
+    deferredExecutor.runAll()
+
+    verify(fixture.application, atLeastOnce()).getSystemService(eq(Context.SENSOR_SERVICE))
+  }
+
   @Test
   fun `when useShakeGesture is disabled does not register activity lifecycle callbacks`() {
     val sut = fixture.getSut(useShakeGesture = false)