Merge 0141709 into 8558cac

romtsn · web-flow · commit 7b2a325be0ba · 2026-05-05T12:45:41.000+02:00
diff --git a/AGENTS.md b/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.
diff --git a/CHANGELOG.md b/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
 
diff --git a/THIRD_PARTY_NOTICES.md b/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>
diff --git a/sentry-android-core/src/main/java/io/sentry/android/core/SentryShakeDetector.java b/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,25 @@ 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);
     }
+    // Post clear to the HandlerThread so all queue access stays single-threaded
+    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 +121,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 +140,96 @@ 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
+          && 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;
+    }
+  }
 }
diff --git a/sentry-android-core/src/main/java/io/sentry/android/core/SentryUserFeedbackForm.java b/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();
diff --git a/sentry-android-core/src/test/java/io/sentry/android/core/SentryShakeDetectorTest.kt b/sentry-android-core/src/test/java/io/sentry/android/core/SentryShakeDetectorTest.kt
