feat(feedback): implement shake gesture detection

CHANGELOG.md

@@ -1,5 +1,13 @@
 # Changelog
 
+## Unreleased
+
+### Features
+
+- Show feedback form on device shake ([#5150](https://github.com/getsentry/sentry-java/pull/5150))
+  - Enable via `options.getFeedbackOptions().setUseShakeGesture(true)` or manifest meta-data `io.sentry.feedback.use-shake-gesture`
+  - Uses the device's accelerometer — no special permissions required
+
 ## 8.34.1
 
 ### Fixes

sentry-android-core/api/sentry-android-core.api

@@ -269,6 +269,19 @@ 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 fun <init> (Landroid/app/Application;)V
+	public fun close ()V
+	public fun onActivityCreated (Landroid/app/Activity;Landroid/os/Bundle;)V
+	public fun onActivityDestroyed (Landroid/app/Activity;)V
+	public fun onActivityPaused (Landroid/app/Activity;)V
+	public fun onActivityResumed (Landroid/app/Activity;)V
+	public fun onActivitySaveInstanceState (Landroid/app/Activity;Landroid/os/Bundle;)V
+	public fun onActivityStarted (Landroid/app/Activity;)V
+	public fun onActivityStopped (Landroid/app/Activity;)V
+	public fun register (Lio/sentry/IScopes;Lio/sentry/SentryOptions;)V
+}
+
 public abstract interface class io/sentry/android/core/IDebugImagesLoader {
 	public abstract fun clearDebugImages ()V
 	public abstract fun loadDebugImages ()Ljava/util/List;
@@ -462,6 +475,18 @@ public final class io/sentry/android/core/SentryScreenshotOptions : io/sentry/Se
 	public fun trackCustomMasking ()V
 }
 
+public final class io/sentry/android/core/SentryShakeDetector : android/hardware/SensorEventListener {
+	public fun <init> (Lio/sentry/ILogger;)V
+	public fun onAccuracyChanged (Landroid/hardware/Sensor;I)V
+	public fun onSensorChanged (Landroid/hardware/SensorEvent;)V
+	public fun start (Landroid/content/Context;Lio/sentry/android/core/SentryShakeDetector$Listener;)V
+	public fun stop ()V
+}
+
+public abstract interface class io/sentry/android/core/SentryShakeDetector$Listener {
+	public abstract fun onShake ()V
+}
+
 public class io/sentry/android/core/SentryUserFeedbackButton : android/widget/Button {
 	public fun <init> (Landroid/content/Context;)V
 	public fun <init> (Landroid/content/Context;Landroid/util/AttributeSet;)V

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

@@ -410,6 +410,7 @@ static void installDefaultIntegrations(
               (Application) context, buildInfoProvider, activityFramesTracker));
       options.addIntegration(new ActivityBreadcrumbsIntegration((Application) context));
       options.addIntegration(new UserInteractionIntegration((Application) context, loadClass));
+      options.addIntegration(new FeedbackShakeIntegration((Application) context));
       if (isFragmentAvailable) {
         options.addIntegration(new FragmentLifecycleIntegration((Application) context, true, true));
       }

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

@@ -0,0 +1,188 @@
+package io.sentry.android.core;
+
+import static io.sentry.util.IntegrationUtils.addIntegrationToSdkVersion;
+
+import android.app.Activity;
+import android.app.Application;
+import android.os.Bundle;
+import io.sentry.IScopes;
+import io.sentry.Integration;
+import io.sentry.SentryLevel;
+import io.sentry.SentryOptions;
+import io.sentry.util.Objects;
+import java.io.Closeable;
+import java.io.IOException;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+/**
+ * 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}.
+ */
+public final class FeedbackShakeIntegration
+    implements Integration, Closeable, Application.ActivityLifecycleCallbacks {
+
+  private final @NotNull Application application;
+  private final @NotNull SentryShakeDetector shakeDetector;
+  private @Nullable SentryAndroidOptions options;
+  private volatile @Nullable Activity currentActivity;
+  private volatile boolean isDialogShowing = false;
+  private volatile @Nullable Runnable previousOnFormClose;
+
+  public FeedbackShakeIntegration(final @NotNull Application application) {
+    this.application = Objects.requireNonNull(application, "Application is required");
+    this.shakeDetector = new SentryShakeDetector(io.sentry.NoOpLogger.getInstance());
+  }
+
+  @Override
+  public void register(final @NotNull IScopes scopes, final @NotNull SentryOptions sentryOptions) {
+    this.options = (SentryAndroidOptions) sentryOptions;
+
+    if (!this.options.getFeedbackOptions().isUseShakeGesture()) {
+      return;
+    }
+
+    shakeDetector.init(application, options.getLogger());
+
+    addIntegrationToSdkVersion("FeedbackShake");
+    application.registerActivityLifecycleCallbacks(this);
+    options.getLogger().log(SentryLevel.DEBUG, "FeedbackShakeIntegration installed.");
+
+    // In case of a deferred init, hook into any already-resumed activity
+    final @Nullable Activity activity = CurrentActivityHolder.getInstance().getActivity();
+    if (activity != null) {
+      currentActivity = activity;
+      startShakeDetection(activity);
+    }
+  }
+
+  @Override
+  public void close() throws IOException {
+    application.unregisterActivityLifecycleCallbacks(this);
+    stopShakeDetection();
+    // 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;
+    }
+    currentActivity = 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.
+    if (isDialogShowing && currentActivity != null && currentActivity != activity) {
+      isDialogShowing = false;
+      if (options != null) {
+        options.getFeedbackOptions().setOnFormClose(previousOnFormClose);
+      }
+      previousOnFormClose = null;
+    }
+    currentActivity = activity;
+    startShakeDetection(activity);
+  }
+
+  @Override
+  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.
+    if (activity == currentActivity) {
+      stopShakeDetection();
+      // Keep currentActivity set when a dialog is showing so onActivityDestroyed
+      // can still match and clean up. Otherwise the cleanup condition
+      // (activity == currentActivity) would always be false since onPause fires
+      // before onDestroy.
+      if (!isDialogShowing) {
+        currentActivity = null;
+      }
+    }
+  }
+
+  @Override
+  public void onActivityCreated(
+      final @NotNull Activity activity, final @Nullable Bundle savedInstanceState) {}
+
+  @Override
+  public void onActivityStarted(final @NotNull Activity activity) {}
+
+  @Override
+  public void onActivityStopped(final @NotNull Activity activity) {}
+
+  @Override
+  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.
+    if (isDialogShowing && activity == currentActivity) {
+      isDialogShowing = false;
+      currentActivity = null;
+      if (options != null) {
+        options.getFeedbackOptions().setOnFormClose(previousOnFormClose);
+      }
+      previousOnFormClose = null;
+    }
+  }
+
+  private void startShakeDetection(final @NotNull Activity activity) {
+    if (options == null) {
+      return;
+    }
+    // Stop any existing detection (e.g. when transitioning between activities)
+    stopShakeDetection();
+    shakeDetector.start(
+        activity,
+        () -> {
+          final Activity active = currentActivity;
+          final Boolean inBackground = AppState.getInstance().isInBackground();
+          if (active != null
+              && options != null
+              && !isDialogShowing
+              && !Boolean.TRUE.equals(inBackground)) {
+            active.runOnUiThread(
+                () -> {
+                  if (isDialogShowing) {
+                    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 SentryUserFeedbackDialog.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);
+                  }
+                });
+          }
+        });
+  }
+
+  private void stopShakeDetection() {
+    shakeDetector.stop();
+  }
+}

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

@@ -167,6 +167,8 @@ final class ManifestMetadataReader {
 
   static final String FEEDBACK_SHOW_BRANDING = "io.sentry.feedback.show-branding";
 
+  static final String FEEDBACK_USE_SHAKE_GESTURE = "io.sentry.feedback.use-shake-gesture";
+
   static final String SPOTLIGHT_ENABLE = "io.sentry.spotlight.enable";
 
   static final String SPOTLIGHT_CONNECTION_URL = "io.sentry.spotlight.url";
@@ -661,6 +663,9 @@ static void applyMetadata(
                 metadata, logger, FEEDBACK_USE_SENTRY_USER, feedbackOptions.isUseSentryUser()));
         feedbackOptions.setShowBranding(
             readBool(metadata, logger, FEEDBACK_SHOW_BRANDING, feedbackOptions.isShowBranding()));
+        feedbackOptions.setUseShakeGesture(
+            readBool(
+                metadata, logger, FEEDBACK_USE_SHAKE_GESTURE, feedbackOptions.isUseShakeGesture()));
 
         options.setEnableSpotlight(
             readBool(metadata, logger, SPOTLIGHT_ENABLE, options.isEnableSpotlight()));