fix(feedback): Improve shake detection sensitivity (#5366)

* fix(feedback): Improve shake detection sensitivity

Replace the threshold-counting approach (2.7g, 2 spikes in 1.5s) with
a rolling sample window based on Square's Seismic library. A shake is
now detected when >75% of accelerometer readings in a 0.5s window
exceed 13 m/s² (~1.33g), which works reliably on budget devices with
less sensitive accelerometers.

Fixes GH-5331

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

* docs: Add license attribution for Square's Seismic library

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

* docs: Add third-party code attribution guidelines to AGENTS.md

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

* Format code

* docs(changelog): Add shake detection fix entry

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

* fix(feedback): Clear message field when form is re-shown via shake

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

* fix(feedback): Synchronize SampleQueue access across threads

stop() runs on the main thread while onSensorChanged() runs on the
background HandlerThread. Without synchronization, concurrent access
to the linked list and object pool can corrupt next-pointers and
cause clear() to loop forever.

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

* ref(feedback): Replace synchronized block with handler.post for queue clear

Post queue.clear() to the HandlerThread instead of synchronizing every
sensor event. All queue access now stays single-threaded with zero
lock contention. quitSafely() drains pending messages before exiting.

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

* dont use method ref

* ref(feedback): Remove queue.clear() from stop(), rely on timestamp purge

Sensor events are delivered via fd callbacks, not Handler messages, so
posting clear() to the HandlerThread doesn't guarantee ordering with
new events after re-registration. The SampleQueue already purges stale
samples by timestamp in add(), so explicit clearing on stop is
unnecessary.

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

* ref(feedback): Restore handler.post(clear) in stop()

Both fd callbacks and posted Messages are serialized by the Looper,
so there is no concurrent access risk. Explicit clear is cleaner than
relying on timestamp purge alone.

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

* fix(feedback): Require minimum sample count before triggering shake

The 75% bit-shift formula degrades at low sample counts (e.g. 33% at
3 samples). With SENSOR_DELAY_NORMAL (~5Hz) the queue may hold only
3 samples in 0.5s. Adding a MIN_QUEUE_SIZE guard ensures the threshold
stays accurate and prevents false triggers from walking.

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

---------

Co-authored-by: Claude Opus 4.6 <noreply@anthropic.com>
Co-authored-by: Sentry Github Bot <bot+github-bot@sentry.io>

Author: 3 people

AGENTS.md

@@ -144,6 +144,17 @@ The repository is organized into multiple modules:
 4. New features must be **opt-in by default** - extend `SentryOptions` or similar Option classes with getters/setters
 5. Consider backwards compatibility
 
+### Third-Party Code Attribution
+When adapting code from third-party libraries:
+1. Add a license header at the top of the adapted file (before the `package` statement):
+   ```java
+   // Adapted from <Library Name>.
+   // Copyright <year> <copyright holder>.
+   // Licensed under the <License Name>.
+   // <source URL>
+   ```
+2. Add a full attribution entry to `THIRD_PARTY_NOTICES.md` following the existing format (Source, License, Copyright, Scope, full license text)
+
 ### Getting PR Information
 
 Use `gh pr view` to get PR details from the current branch. This is needed when adding changelog entries, which require the PR number.

CHANGELOG.md

@@ -23,6 +23,8 @@
 ### Fixes
 
 - Fix soft input keyboard not being shown on the Feedback form ([#5359](https://github.com/getsentry/sentry-java/pull/5359))
+- Fix shake-to-report not triggering on some devices due to high acceleration threshold ([#5366](https://github.com/getsentry/sentry-java/pull/5366))
+- Fix feedback form retaining previous message when shown again via shake ([#5366](https://github.com/getsentry/sentry-java/pull/5366))
 
 ### Dependencies
 

THIRD_PARTY_NOTICES.md

@@ -118,6 +118,34 @@ limitations under the License.
 
 ---
 
+## Square — Seismic (Apache 2.0)
+
+**Source:** https://github.com/square/seismic<br>
+**License:** Apache License 2.0<br>
+**Copyright:** Copyright 2010 Square, Inc.
+
+### Scope
+
+The Sentry Java SDK includes an adapted version of Square's Seismic shake detection algorithm. The rolling sample window approach and `SampleQueue`/`SamplePool` data structures in `io.sentry.android.core.SentryShakeDetector` are based on Seismic's `ShakeDetector`.
+
+```
+Copyright 2010 Square, Inc.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+     http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+```
+
+---
+
 ## Square — Curtains (Apache 2.0)
 
 **Source:** https://github.com/square/curtains (v1.2.5)<br>

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

@@ -1,3 +1,7 @@
+// Adapted from Square's Seismic library.
+// Copyright 2010 Square, Inc.
+// Licensed under the Apache License, Version 2.0.
+// https://github.com/square/seismic
 package io.sentry.android.core;
 
 import android.content.Context;
@@ -7,10 +11,8 @@
 import android.hardware.SensorManager;
 import android.os.Handler;
 import android.os.HandlerThread;
-import android.os.SystemClock;
 import io.sentry.ILogger;
 import io.sentry.SentryLevel;
-import java.util.concurrent.atomic.AtomicLong;
 import org.jetbrains.annotations.ApiStatus;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
@@ -21,30 +23,25 @@
  * <p>The accelerometer sensor (TYPE_ACCELEROMETER) does NOT require any special permissions on
  * Android. The BODY_SENSORS permission is only needed for heart rate and similar body sensors.
  *
- * <p>Requires at least {@link #SHAKE_COUNT_THRESHOLD} accelerometer readings above {@link
- * #SHAKE_THRESHOLD_GRAVITY} within {@link #SHAKE_WINDOW_MS} to trigger a shake event.
+ * <p>Uses a rolling sample window: if more than 75% of accelerometer readings in the past 0.5s
+ * exceed {@link #ACCELERATION_THRESHOLD}, a shake is detected. Based on Square's Seismic library.
  *
  * <p>Sensor events are delivered on a background {@link HandlerThread} to avoid polluting the main
  * thread.
  */
 @ApiStatus.Internal
 public final class SentryShakeDetector implements SensorEventListener {
 
-  private static final float SHAKE_THRESHOLD_GRAVITY = 2.7f;
-  private static final int SHAKE_WINDOW_MS = 1500;
-  private static final int SHAKE_COUNT_THRESHOLD = 2;
-  private static final int SHAKE_COOLDOWN_MS = 1000;
+  static final int ACCELERATION_THRESHOLD = 13;
 
   private @Nullable SensorManager sensorManager;
   private @Nullable Sensor accelerometer;
   private @Nullable HandlerThread handlerThread;
   private @Nullable Handler handler;
-  private final @NotNull AtomicLong lastShakeTimestamp = new AtomicLong(0);
   private volatile @Nullable Listener listener;
   private @NotNull ILogger logger;
 
-  private int shakeCount = 0;
-  private long firstShakeTimestamp = 0;
+  private final @NotNull SampleQueue queue = new SampleQueue();
 
   public interface Listener {
     void onShake();
@@ -94,17 +91,24 @@ public void start(final @NotNull Context context, final @NotNull Listener shakeL
 
   public void stop() {
     listener = null;
-    shakeCount = 0;
-    firstShakeTimestamp = 0;
     if (sensorManager != null) {
       sensorManager.unregisterListener(this);
     }
+    final @Nullable Handler h = handler;
+    if (h != null) {
+      h.post(
+          () -> {
+            //noinspection Convert2MethodRef
+            queue.clear();
+          });
+    }
   }
 
   /** Stops detection and releases the background thread. */
   public void close() {
     stop();
     if (handlerThread != null) {
+      // quitSafely drains pending messages (including the clear posted by stop) before exiting
       handlerThread.quitSafely();
       handlerThread = null;
       handler = null;
@@ -116,32 +120,17 @@ public void onSensorChanged(final @NotNull SensorEvent event) {
     if (event.sensor.getType() != Sensor.TYPE_ACCELEROMETER) {
       return;
     }
-    float gX = event.values[0] / SensorManager.GRAVITY_EARTH;
-    float gY = event.values[1] / SensorManager.GRAVITY_EARTH;
-    float gZ = event.values[2] / SensorManager.GRAVITY_EARTH;
-    double gForceSquared = gX * gX + gY * gY + gZ * gZ;
-    if (gForceSquared > SHAKE_THRESHOLD_GRAVITY * SHAKE_THRESHOLD_GRAVITY) {
-      long now = SystemClock.elapsedRealtime();
-
-      // Reset counter if outside the detection window
-      if (now - firstShakeTimestamp > SHAKE_WINDOW_MS) {
-        shakeCount = 0;
-        firstShakeTimestamp = now;
-      }
-
-      shakeCount++;
-
-      if (shakeCount >= SHAKE_COUNT_THRESHOLD) {
-        // Enforce cooldown so we don't fire repeatedly
-        long lastShake = lastShakeTimestamp.get();
-        if (now - lastShake > SHAKE_COOLDOWN_MS) {
-          lastShakeTimestamp.set(now);
-          shakeCount = 0;
-          final @Nullable Listener currentListener = listener;
-          if (currentListener != null) {
-            currentListener.onShake();
-          }
-        }
+    final float ax = event.values[0];
+    final float ay = event.values[1];
+    final float az = event.values[2];
+    final boolean accelerating = Math.sqrt(ax * ax + ay * ay + az * az) > ACCELERATION_THRESHOLD;
+
+    queue.add(event.timestamp, accelerating);
+    if (queue.isShaking()) {
+      queue.clear();
+      final @Nullable Listener currentListener = listener;
+      if (currentListener != null) {
+        currentListener.onShake();
       }
     }
   }
@@ -150,4 +139,97 @@ public void onSensorChanged(final @NotNull SensorEvent event) {
   public void onAccuracyChanged(final @NotNull Sensor sensor, final int accuracy) {
     // Not needed for shake detection.
   }
+
+  static class SampleQueue {
+    private static final long MAX_WINDOW_SIZE_NS = 500_000_000L; // 0.5s
+    private static final long MIN_WINDOW_SIZE_NS = MAX_WINDOW_SIZE_NS >> 1; // 0.25s
+    private static final int MIN_QUEUE_SIZE = 4;
+
+    private final @NotNull SamplePool pool = new SamplePool();
+    private @Nullable Sample oldest;
+    private @Nullable Sample newest;
+    private int sampleCount;
+    private int acceleratingCount;
+
+    void add(final long timestamp, final boolean accelerating) {
+      purge(timestamp - MAX_WINDOW_SIZE_NS);
+
+      final @NotNull Sample added = pool.acquire();
+      added.timestamp = timestamp;
+      added.accelerating = accelerating;
+      added.next = null;
+      if (newest != null) {
+        newest.next = added;
+      }
+      newest = added;
+      if (oldest == null) {
+        oldest = added;
+      }
+
+      sampleCount++;
+      if (accelerating) {
+        acceleratingCount++;
+      }
+    }
+
+    void clear() {
+      while (oldest != null) {
+        final @NotNull Sample removed = oldest;
+        oldest = removed.next;
+        pool.release(removed);
+      }
+      newest = null;
+      sampleCount = 0;
+      acceleratingCount = 0;
+    }
+
+    private void purge(final long cutoff) {
+      while (sampleCount >= MIN_QUEUE_SIZE && oldest != null && cutoff - oldest.timestamp > 0) {
+        final @NotNull Sample removed = oldest;
+        if (removed.accelerating) {
+          acceleratingCount--;
+        }
+        sampleCount--;
+        oldest = removed.next;
+        if (oldest == null) {
+          newest = null;
+        }
+        pool.release(removed);
+      }
+    }
+
+    boolean isShaking() {
+      return newest != null
+          && oldest != null
+          && sampleCount >= MIN_QUEUE_SIZE
+          && newest.timestamp - oldest.timestamp >= MIN_WINDOW_SIZE_NS
+          && acceleratingCount >= (sampleCount >> 1) + (sampleCount >> 2);
+    }
+  }
+
+  static class Sample {
+    long timestamp;
+    boolean accelerating;
+    @Nullable Sample next;
+  }
+
+  static class SamplePool {
+    private @Nullable Sample head;
+
+    @NotNull
+    Sample acquire() {
+      Sample acquired = head;
+      if (acquired == null) {
+        acquired = new Sample();
+      } else {
+        head = acquired.next;
+      }
+      return acquired;
+    }
+
+    void release(final @NotNull Sample sample) {
+      sample.next = head;
+      head = sample;
+    }
+  }
 }

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

@@ -324,6 +324,12 @@ public void setOnDismissListener(final @Nullable OnDismissListener listener) {
   @Override
   protected void onStart() {
     super.onStart();
+    // Clear the message field so subsequent show() calls start with a fresh form
+    final @NotNull EditText edtMessage =
+        findViewById(R.id.sentry_dialog_user_feedback_edt_description);
+    edtMessage.getText().clear();
+    edtMessage.setError(null);
+
     final @NotNull SentryOptions options = Sentry.getCurrentScopes().getOptions();
     final @NotNull SentryFeedbackOptions feedbackOptions = options.getFeedbackOptions();
     final @Nullable Runnable onFormOpen = feedbackOptions.getOnFormOpen();