@@ -6,6 +6,7 @@
 
 - Allow child spans to use explicit start timestamps through `ISpan` ([#5929](https://github.com/getsentry/sentry-java/pull/5929))
 - Make `ISpan.startChild` overloads with `SpanOptions` public ([#5927](https://github.com/getsentry/sentry-java/pull/5927))
+- Add `Sentry.feedback().enableOnShake()`, `Sentry.feedback().disableOnShake()`, and `Sentry.feedback().isOnShakeEnabled()` to toggle and query shake-to-report at runtime ([#5827](https://github.com/getsentry/sentry-java/pull/5827))
 
 ### Improvements
 
 
@@ -293,9 +293,12 @@ public abstract class io/sentry/android/core/EnvelopeFileObserverIntegration : i
 	public final fun register (Lio/sentry/IScopes;Lio/sentry/SentryOptions;)V
 }
 
-public final class io/sentry/android/core/FeedbackShakeIntegration : android/app/Application$ActivityLifecycleCallbacks, io/sentry/Integration, java/io/Closeable {
+public final class io/sentry/android/core/FeedbackShakeIntegration : android/app/Application$ActivityLifecycleCallbacks, io/sentry/Integration, io/sentry/SentryFeedbackOptions$IShakeController, java/io/Closeable {
 	public fun <init> (Landroid/app/Application;)V
 	public fun close ()V
+	public fun disableOnShake ()V
+	public fun enableOnShake ()V
+	public fun isOnShakeEnabled ()Z
 	public fun onActivityCreated (Landroid/app/Activity;Landroid/os/Bundle;)V
 	public fun onActivityDestroyed (Landroid/app/Activity;)V
 	public fun onActivityPaused (Landroid/app/Activity;)V
@@ -573,7 +576,9 @@ public abstract interface class io/sentry/android/core/SentryUserFeedbackDialog$
 
 public class io/sentry/android/core/SentryUserFeedbackForm : android/app/AlertDialog {
 	protected fun onCreate (Landroid/os/Bundle;)V
+	public fun onDetachedFromWindow ()V
 	protected fun onStart ()V
+	protected fun onStop ()V
 	public fun setCancelable (Z)V
 	public fun setOnDismissListener (Landroid/content/DialogInterface$OnDismissListener;)V
 	public fun show ()V
 
@@ -4,31 +4,54 @@
 
 import android.app.Activity;
 import android.app.Application;
+import android.app.Dialog;
 import android.os.Bundle;
 import io.sentry.IScopes;
 import io.sentry.Integration;
+import io.sentry.SentryFeedbackOptions;
 import io.sentry.SentryLevel;
 import io.sentry.SentryOptions;
 import io.sentry.util.Objects;
 import java.io.Closeable;
 import java.io.IOException;
 import java.lang.ref.WeakReference;
+import java.util.concurrent.CopyOnWriteArrayList;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
+import org.jetbrains.annotations.TestOnly;
 
 /**
- * Detects shake gestures and shows the user feedback dialog when a shake is detected. Only active
- * when {@link io.sentry.SentryFeedbackOptions#isUseShakeGesture()} returns {@code true}.
+ * Detects shake gestures and shows the user feedback dialog when a shake is detected. {@link
+ * io.sentry.SentryFeedbackOptions#isUseShakeGesture()} determines the initial state; it can be
+ * toggled at runtime via {@code Sentry.feedback().enableOnShake()} and {@code
+ * Sentry.feedback().disableOnShake()}.
+ *
+ * <p>Shake detection is scoped to the resumed activity: a dialog belongs to the window of the
+ * activity that created it, so it can only ever be visible while that activity is resumed. Dialogs
+ * report themselves via {@link #onDialogVisible(Activity, Dialog)} / {@link #onDialogGone(Dialog)}
+ * and detection is then suppressed for the activity hosting them, which keeps a shake from stacking
+ * a second dialog on top of a visible one without letting a dialog on a backgrounded activity
+ * suppress detection elsewhere.
  */
 public final class FeedbackShakeIntegration
-    implements Integration, Closeable, Application.ActivityLifecycleCallbacks {
+    implements Integration,
+        Closeable,
+        Application.ActivityLifecycleCallbacks,
+        SentryFeedbackOptions.IShakeController {
 
   private final @NotNull Application application;
   private final @NotNull SentryShakeDetector shakeDetector;
   private @Nullable SentryAndroidOptions options;
+  private volatile boolean enabled = false;
   private volatile @Nullable WeakReference<Activity> currentActivityRef;
-  private volatile boolean isDialogShowing = false;
-  private volatile @Nullable Runnable previousOnFormClose;
+
+  /**
+   * The feedback dialogs that are currently visible, together with the activity hosting them. More
+   * than one can be visible at a time, e.g. when the app calls {@code Sentry.feedback().show()}
+   * while another dialog is already showing.
+   */
+  private final @NotNull CopyOnWriteArrayList<VisibleDialog> visibleDialogs =
+      new CopyOnWriteArrayList<>();
 
   public FeedbackShakeIntegration(final @NotNull Application application) {
     this.application = Objects.requireNonNull(application, "Application is required");
@@ -46,13 +69,25 @@ public void register(final @NotNull IScopes scopes, final @NotNull SentryOptions
 
     final @NotNull SentryAndroidOptions options = this.options;
 
-    if (!options.getFeedbackOptions().isUseShakeGesture()) {
+    // Always expose the runtime toggle, even when the option starts out disabled.
+    options.getFeedbackOptions().setShakeController(this);
+
+    if (options.getFeedbackOptions().isUseShakeGesture()) {
+      enableOnShake();
+    }
+  }
+
+  @Override
+  public synchronized void enableOnShake() {
+    final @Nullable SentryAndroidOptions options = this.options;
+    if (enabled || options == null) {
       return;
     }
+    enabled = true;
 
-    // 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.
+    // Re-arm the detector in case it was closed before, either by disableOnShake() or by 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
@@ -72,7 +107,7 @@ public void register(final @NotNull IScopes scopes, final @NotNull SentryOptions
     application.registerActivityLifecycleCallbacks(this);
     options.getLogger().log(SentryLevel.DEBUG, "FeedbackShakeIntegration installed.");
 
-    // In case of a deferred init, hook into any already-resumed activity
+    // In case of a deferred init or runtime enable, hook into any already-resumed activity
     final @Nullable Activity activity = CurrentActivityHolder.getInstance().getActivity();
     if (activity != null) {
       currentActivityRef = new WeakReference<>(activity);
@@ -81,34 +116,111 @@ public void register(final @NotNull IScopes scopes, final @NotNull SentryOptions
   }
 
   @Override
-  public void close() throws IOException {
+  public synchronized void disableOnShake() {
+    if (!enabled) {
+      return;
+    }
+    enabled = false;
+
     application.unregisterActivityLifecycleCallbacks(this);
     shakeDetector.close();
-    // Restore onFormClose if a dialog is still showing, since lifecycle callbacks
-    // are now unregistered and onActivityDestroyed cleanup won't fire.
-    if (isDialogShowing) {
-      isDialogShowing = false;
-      if (options != null) {
-        options.getFeedbackOptions().setOnFormClose(previousOnFormClose);
-      }
-      previousOnFormClose = null;
-    }
     currentActivityRef = null;
   }
 
   @Override
-  public void onActivityResumed(final @NotNull Activity activity) {
-    // If a dialog is showing on a different activity (e.g. user navigated via notification),
-    // clean up since the dialog's host activity is going away and onActivityDestroyed
-    // won't match currentActivity anymore.
-    final @Nullable Activity current = currentActivityRef != null ? currentActivityRef.get() : null;
-    if (isDialogShowing && current != null && current != activity) {
-      isDialogShowing = false;
-      if (options != null) {
-        options.getFeedbackOptions().setOnFormClose(previousOnFormClose);
+  public boolean isOnShakeEnabled() {
+    return enabled;
+  }
+
+  /**
+   * Reports a feedback dialog as visible on {@code host}. Shake detection is suppressed for that
+   * activity until the dialog reports back via {@link #onDialogGone(Dialog)}, so a shake can never
+   * stack a second dialog on top of a visible one — no matter how the visible one was opened.
+   */
+  void onDialogVisible(final @NotNull Activity host, final @NotNull Dialog dialog) {
+    visibleDialogs.add(new VisibleDialog(host, dialog));
+    stopShakeDetection();
+  }
+
+  /** Reports a feedback dialog as no longer visible. Safe to call more than once per dialog. */
+  void onDialogGone(final @NotNull Dialog dialog) {
+    if (!removeDialog(dialog)) {
+      return;
+    }
+    final @Nullable WeakReference<Activity> currentRef = currentActivityRef;
+    final @Nullable Activity current = currentRef == null ? null : currentRef.get();
+    if (enabled && current != null) {
+      startShakeDetection(current);
+    }
+  }
+
+  private boolean removeDialog(final @NotNull Dialog dialog) {
+    boolean removed = false;
+    for (final @NotNull VisibleDialog visibleDialog : visibleDialogs) {
+      // Drop entries whose dialog was collected without reporting back, so they can't suppress
+      // detection forever.
+      final @Nullable Dialog trackedDialog = visibleDialog.dialogRef.get();
+      if (trackedDialog == dialog) {
+        removed = visibleDialogs.remove(visibleDialog) || removed;
+      } else if (trackedDialog == null) {
+        visibleDialogs.remove(visibleDialog);
       }
-      previousOnFormClose = null;
     }
+    return removed;
+  }
+
+  private boolean hasDialogOn(final @NotNull Activity activity) {
+    for (final @NotNull VisibleDialog visibleDialog : visibleDialogs) {
+      if (visibleDialog.dialogRef.get() != null && visibleDialog.activityRef.get() == activity) {
+        return true;
+      }
+    }
+    return false;
+  }
+
+  @TestOnly
+  @Nullable
+  Activity getDialogActivity() {
+    for (final @NotNull VisibleDialog visibleDialog : visibleDialogs) {
+      if (visibleDialog.dialogRef.get() != null) {
+        return visibleDialog.activityRef.get();
+      }
+    }
+    return null;
+  }
+
+  /** Creates the dialog shown on shake. Replaceable in tests to simulate a failing show(). */
+  interface DialogFactory {
+    @NotNull
+    Dialog create(final @NotNull Activity activity);
+  }
+
+  private @NotNull DialogFactory dialogFactory =
+      activity -> new SentryUserFeedbackForm.Builder(activity).create();
+
+  @TestOnly
+  void setDialogFactory(final @NotNull DialogFactory dialogFactory) {
+    this.dialogFactory = dialogFactory;
+  }
+
+  private static final class VisibleDialog {
+    private final @NotNull WeakReference<Activity> activityRef;
+    private final @NotNull WeakReference<Dialog> dialogRef;
+
+    VisibleDialog(final @NotNull Activity activity, final @NotNull Dialog dialog) {
+      this.activityRef = new WeakReference<>(activity);
+      this.dialogRef = new WeakReference<>(dialog);
+    }
+  }
+
+  @Override
+  public void close() throws IOException {
+    disableOnShake();
+    visibleDialogs.clear();
+  }
+
+  @Override
+  public void onActivityResumed(final @NotNull Activity activity) {
     currentActivityRef = new WeakReference<>(activity);
     startShakeDetection(activity);
   }
@@ -118,16 +230,11 @@ public void onActivityPaused(final @NotNull Activity activity) {
     // Only stop if this is the activity we're tracking. When transitioning between
     // activities, B.onResume may fire before A.onPause — stopping unconditionally
     // would kill shake detection for the new activity.
-    final @Nullable Activity current = currentActivityRef != null ? currentActivityRef.get() : null;
+    final @Nullable WeakReference<Activity> currentRef = currentActivityRef;
+    final @Nullable Activity current = currentRef != null ? currentRef.get() : null;
     if (activity == current) {
       stopShakeDetection();
-      // Keep currentActivityRef set when a dialog is showing so onActivityDestroyed
-      // can still match and clean up. Otherwise the cleanup condition
-      // (activity == current) would always be false since onPause fires
-      // before onDestroy.
-      if (!isDialogShowing) {
-        currentActivityRef = null;
-      }
+      currentActivityRef = null;
     }
   }
 
@@ -146,67 +253,58 @@ public void onActivitySaveInstanceState(
       final @NotNull Activity activity, final @NotNull Bundle outState) {}
 
   @Override
-  public void onActivityDestroyed(final @NotNull Activity activity) {
-    // Only reset if this is the activity that hosts the dialog — the dialog cannot
-    // outlive its host activity being destroyed.
-    final @Nullable Activity current = currentActivityRef != null ? currentActivityRef.get() : null;
-    if (isDialogShowing && activity == current) {
-      isDialogShowing = false;
-      currentActivityRef = null;
-      if (options != null) {
-        options.getFeedbackOptions().setOnFormClose(previousOnFormClose);
-      }
-      previousOnFormClose = null;
-    }
-  }
+  public void onActivityDestroyed(final @NotNull Activity activity) {}
 
   private void startShakeDetection(final @NotNull Activity activity) {
     if (options == null) {
       return;
     }
     // Stop any existing detection (e.g. when transitioning between activities)
     stopShakeDetection();
+    // A dialog is already visible here, so a shake could only stack a second one on top of it.
+    // The dialog has no detector of its own in this case: SentryUserFeedbackForm only starts one
+    // while shake-to-report is globally disabled, which is exactly when this integration is not
+    // detecting either.
+    if (hasDialogOn(activity)) {
+      return;
+    }
     shakeDetector.start(
         activity,
         () -> {
           final @Nullable WeakReference<Activity> ref = currentActivityRef;
           final Activity active = ref != null ? ref.get() : null;
           final Boolean inBackground = AppState.getInstance().isInBackground();
-          if (active != null
-              && options != null
-              && !isDialogShowing
-              && !Boolean.TRUE.equals(inBackground)) {
-            active.runOnUiThread(
-                () -> {
-                  if (isDialogShowing || active.isFinishing() || active.isDestroyed()) {
-                    return;
-                  }
-                  try {
-                    isDialogShowing = true;
-                    final Runnable captured = options.getFeedbackOptions().getOnFormClose();
-                    previousOnFormClose = captured;
-                    options
-                        .getFeedbackOptions()
-                        .setOnFormClose(
-                            () -> {
-                              isDialogShowing = false;
-                              options.getFeedbackOptions().setOnFormClose(captured);
-                              if (captured != null) {
-                                captured.run();
-                              }
-                              previousOnFormClose = null;
-                            });
-                    new SentryUserFeedbackForm.Builder(active).create().show();
-                  } catch (Throwable e) {
-                    isDialogShowing = false;
-                    options.getFeedbackOptions().setOnFormClose(previousOnFormClose);
-                    previousOnFormClose = null;
-                    options
-                        .getLogger()
-                        .log(SentryLevel.ERROR, "Failed to show feedback dialog on shake.", e);
-                  }
-                });
+          if (active == null
+              || options == null
+              || !enabled
+              || hasDialogOn(active)
+              || Boolean.TRUE.equals(inBackground)) {
+            return;
           }
+          active.runOnUiThread(
+              () -> {
+                // Re-check on the main thread: shake-to-report may have been disabled, or an
+                // earlier queued shake may have shown a dialog in the meantime (the dialog reports
+                // itself synchronously in onStart).
+                if (!enabled
+                    || hasDialogOn(active)
+                    || active.isFinishing()
+                    || active.isDestroyed()) {
+                  return;
+                }
+                @Nullable Dialog dialog = null;
+                try {
+                  dialog = dialogFactory.create(active);
+                  dialog.show();
+                } catch (Throwable e) {
+                  if (dialog != null) {
+                    onDialogGone(dialog);
+                  }
+                  options
+                      .getLogger()
+                      .log(SentryLevel.ERROR, "Failed to show feedback dialog on shake.", e);
+                }
+              });
         });
   }