fix(ios): fix shake detection crash and swizzle safety

UIWindow inherits motionEnded:withEvent: from UIResponder and may not
have its own implementation. Using method_setImplementation directly on
the inherited Method would modify UIResponder, affecting all subclasses
and causing a doesNotRecognizeSelector crash.

Fix by calling class_addMethod first to ensure UIWindow has its own
method before replacing the IMP. Also prevent duplicate NSNotification
observers on component remount, and clean up debug logging.

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

Author: antonis

packages/core/ios/RNSentry.mm

@@ -306,6 +306,10 @@ - (void)handleShakeDetected
 // that JS calls directly from startShakeListener/stopShakeListener.
 RCT_EXPORT_METHOD(enableShakeDetection)
 {
+    // Remove any existing observer first to avoid duplicate notifications
+    [[NSNotificationCenter defaultCenter] removeObserver:self
+                                                    name:RNSentryShakeDetectedNotification
+                                                  object:nil];
     [[NSNotificationCenter defaultCenter] addObserver:self
                                              selector:@selector(handleShakeDetected)
                                                  name:RNSentryShakeDetectedNotification

packages/core/ios/RNSentryShakeDetector.m

@@ -8,18 +8,15 @@
 NSNotificationName const RNSentryShakeDetectedNotification = @"RNSentryShakeDetected";
 
 static BOOL _shakeDetectionEnabled = NO;
-static IMP _originalMotionEndedIMP = NULL;
 static BOOL _swizzled = NO;
+static IMP _originalMotionEndedIMP = NULL;
 static NSTimeInterval _lastShakeTimestamp = 0;
 static const NSTimeInterval SHAKE_COOLDOWN_SECONDS = 1.0;
 
-// Intercepts UIWindow motion events before they continue up the responder chain.
-//
-// The iOS simulator routes shake (Cmd+Ctrl+Z) through UIWindow.motionEnded:withEvent:,
-// not through UIApplication.sendEvent:. React Native's dev menu also hooks UIWindow
-// via RCTSwapInstanceMethods. Because we swizzle from enableShakeDetection (which fires after
-// RN finishes loading), our IMP becomes the outermost layer: our code runs first,
-// then the saved original IMP (RN's dev menu handler) is called.
+// C function that replaces UIWindow's motionEnded:withEvent: IMP.
+// Uses method_setImplementation to install itself and saves the original IMP
+// to call afterwards, preserving the responder chain and composing with other
+// swizzles (e.g. RCTDevMenu in debug builds).
 static void
 sentry_motionEnded(UIWindow *self, SEL _cmd, UIEventSubtype motion, UIEvent *event)
 {
@@ -46,13 +43,30 @@ + (void)enable
     @synchronized(self) {
         if (!_swizzled) {
             Class windowClass = [UIWindow class];
-            Method originalMethod
-                = class_getInstanceMethod(windowClass, @selector(motionEnded:withEvent:));
-            if (originalMethod) {
-                _originalMotionEndedIMP = method_getImplementation(originalMethod);
-                method_setImplementation(originalMethod, (IMP)sentry_motionEnded);
-                _swizzled = YES;
+            SEL sel = @selector(motionEnded:withEvent:);
+
+            // UIWindow may not have its own motionEnded:withEvent: — it can inherit from
+            // UIResponder. We must ensure the method exists directly on UIWindow before
+            // replacing its IMP, otherwise the inherited method on UIResponder would be
+            // modified, affecting all UIResponder subclasses.
+            Method inheritedMethod = class_getInstanceMethod(windowClass, sel);
+            if (!inheritedMethod) {
+                return;
             }
+
+            // class_addMethod only succeeds if UIWindow does NOT already have its own
+            // implementation of motionEnded:withEvent:. In that case, we add a direct
+            // implementation to UIWindow that just calls super (the inherited IMP).
+            IMP inheritedIMP = method_getImplementation(inheritedMethod);
+            const char *types = method_getTypeEncoding(inheritedMethod);
+            class_addMethod(windowClass, sel, inheritedIMP, types);
+
+            // Now UIWindow definitely has its own motionEnded:withEvent:. Get its Method
+            // (which may be the one we just added, or a pre-existing one from e.g. RCTDevMenu)
+            // and replace the IMP with our interceptor.
+            Method ownMethod = class_getInstanceMethod(windowClass, sel);
+            _originalMotionEndedIMP = method_setImplementation(ownMethod, (IMP)sentry_motionEnded);
+            _swizzled = YES;
         }
         _shakeDetectionEnabled = YES;
     }

packages/core/src/js/feedback/ShakeToReportBug.ts

@@ -25,7 +25,6 @@ const defaultEmitterFactory: EmitterFactory = nativeModule => new NativeEventEmi
  */
 export function startShakeListener(onShake: () => void, createEmitter: EmitterFactory = defaultEmitterFactory): void {
   if (_shakeSubscription) {
-    debug.log('Shake listener is already active.');
     return;
   }
 
@@ -42,14 +41,18 @@ export function startShakeListener(onShake: () => void, createEmitter: EmitterFa
 
   const emitter = createEmitter(nativeModule);
   _shakeSubscription = emitter.addListener(OnShakeEventName, () => {
-    debug.log('Shake detected.');
     onShake();
   });
 
   // Explicitly enable native shake detection. On iOS with New Architecture (TurboModules),
   // NativeEventEmitter.addListener does not dispatch to native addListener:, so the
   // native shake listener would never start without this explicit call.
-  (nativeModule as { enableShakeDetection?: () => void }).enableShakeDetection?.();
+  const module = nativeModule as { enableShakeDetection?: () => void };
+  if (module.enableShakeDetection) {
+    module.enableShakeDetection();
+  } else {
+    debug.warn('enableShakeDetection is not available on the native module.');
+  }
 }
 
 /**