react-native-reanimated 4.7.0 → 4.7.1

package/Common/cpp/reanimated/LayoutAnimations/LayoutAnimationsUtils.h

@@ -3,6 +3,7 @@
 #include <folly/dynamic.h>
 #include <react/debug/react_native_assert.h>
 #include <react/renderer/components/rnreanimated/Props.h>
+#include <react/renderer/components/view/ViewProps.h>
 #include <react/renderer/mounting/MountingOverrideDelegate.h>
 #include <react/renderer/mounting/ShadowView.h>
 #include <reanimated/LayoutAnimations/LayoutAnimationsManager.h>
@@ -59,11 +60,18 @@ struct Snapshot {
 };
 
 typedef enum class ExitingState : std::uint8_t {
-  UNDEFINED = 1,
-  WAITING = 2,
-  ANIMATING = 3,
-  DEAD = 4,
-  DELETED = 5,
+  // React still renders the view
+  LIVE = 1,
+  // React deletes the view in the current transaction and the proxy has not decided how it exits yet
+  DECISION_PENDING = 2,
+  // withheld until its exiting descendants finish
+  WAITING = 3,
+  // withheld while its own exiting animation runs
+  ANIMATING = 4,
+  // its exiting animation finished, it is torn down at the next flush
+  COMPLETED = 5,
+  // the proxy has emitted its Remove and Delete
+  TORN_DOWN = 6,
 } ExitingState;
 
 struct MutationNode;
@@ -102,17 +110,18 @@ struct LightNode {
   folly::dynamic accumulatedRawProps = nullptr;
   bool propsNeedResolve = false;
 #endif
-  ExitingState state = ExitingState::UNDEFINED;
+  ExitingState state = ExitingState::LIVE;
   std::weak_ptr<LightNode> parent;
   std::vector<std::shared_ptr<LightNode>> children;
   int exitingChildrenCount = 0;
 
   bool isExiting() const {
-    return state != ExitingState::UNDEFINED;
+    return state != ExitingState::LIVE;
   }
 
   void setExitingState(ExitingState newState) {
-    const bool startsExiting = !isExiting() && newState != ExitingState::UNDEFINED;
+    react_native_assert(newState != ExitingState::LIVE && "A light node never becomes live again");
+    const bool startsExiting = !isExiting();
     state = newState;
     if (!startsExiting) {
       return;
@@ -255,6 +264,15 @@ static inline std::shared_ptr<LightNode> findParentRNSScreen(const std::shared_p
   return current;
 }
 
+static inline bool isInSubtree(std::shared_ptr<LightNode> node, const std::shared_ptr<LightNode> &root) {
+  for (; node; node = node->parent.lock()) {
+    if (node == root) {
+      return true;
+    }
+  }
+  return false;
+}
+
 static inline bool isSETBoundary(const std::shared_ptr<LightNode> &node) {
   return !std::strcmp(node->current.componentName, "REASharedTransitionBoundary");
 }
@@ -283,4 +301,13 @@ static inline bool hasLayoutChanged(const ShadowViewMutation &mutation) {
   return mutation.oldChildShadowView.layoutMetrics.frame != mutation.newChildShadowView.layoutMetrics.frame;
 }
 
+static inline bool isViewKind(const ShadowView &view) {
+  return view.traits.check(ShadowNodeTraits::Trait::ViewKind);
+}
+
+static inline const ViewProps &getViewProps(const ShadowView &view) {
+  react_native_assert(isViewKind(view) && "Only ViewKind views have ViewProps");
+  return static_cast<const ViewProps &>(*view.props);
+}
+
 } // namespace reanimated

package/Common/cpp/reanimated/LayoutAnimations/PropsDiffer.h

@@ -90,8 +90,8 @@ class PropsDiffer {
   explicit PropsDiffer(jsi::Runtime &rt, const ShadowView &sourceView, const ShadowView &targetView)
       : sourceView_(sourceView),
         targetView_(targetView),
-        sourceViewProps_(static_cast<const ViewProps &>(*sourceView.props)),
-        targetViewProps_(static_cast<const ViewProps &>(*targetView.props)),
+        sourceViewProps_(getViewProps(sourceView)),
+        targetViewProps_(getViewProps(targetView)),
         sourceValues_(rt),
         targetValues_(rt) {}
 

package/Common/cpp/reanimated/LayoutAnimations/SharedTransitions.cpp

@@ -59,7 +59,7 @@ void LayoutAnimationsProxy::findSharedElementsOnScreen(
     return;
   }
   std::optional<SharedTag> sharedTag;
-  {
+  if (node->current.traits.check(ShadowNodeTraits::Trait::ViewKind)) {
     auto lock = std::unique_lock<std::mutex>(sharedTransitionManager_->mutex_);
     const auto it = sharedTransitionManager_->tagToName_.find(node->current.tag);
     if (it != sharedTransitionManager_->tagToName_.end()) {
@@ -316,6 +316,7 @@ void LayoutAnimationsProxy::overrideTransform(
   if (!transform) {
     return;
   }
+  react_native_assert(isViewKind(shadowView) && "Only ViewKind views have ViewProps");
 #ifdef ANDROID
   auto array = folly::dynamic::array(folly::dynamic::object("matrix", transform->operator folly::dynamic()));
   const folly::dynamic newTransformDynamic = folly::dynamic::object("transform", array);
@@ -492,9 +493,10 @@ void LayoutAnimationsProxy::hideTransitioningViews(
 }
 
 // The hide in hideTransitioningViews is not stored in the light tree, so a
-// later Update for the same view carries full opacity and would show the view
-// again. Force opacity 0 on every outgoing Update for a hidden view until the
-// restore in cleanupSharedTransitions removes its tag from hiddenViewTags_.
+// later Update or Insert for the same view carries full opacity and would show
+// the view again. Force opacity 0 on every outgoing Update and Insert for a
+// hidden view until the restore in cleanupSharedTransitions removes its tag
+// from hiddenViewTags_.
 void LayoutAnimationsProxy::keepTransitioningViewsHidden(
     ShadowViewMutationList &filteredMutations,
     const PropsParserContext &propsParserContext) const {
@@ -502,11 +504,9 @@ void LayoutAnimationsProxy::keepTransitioningViewsHidden(
     return;
   }
   for (auto &mutation : filteredMutations) {
-    if (mutation.type == ShadowViewMutation::Update && hiddenViewTags_.contains(mutation.newChildShadowView.tag)) {
-      mutation = ShadowViewMutation::UpdateMutation(
-          mutation.oldChildShadowView,
-          cloneViewWithoutOpacity(mutation.newChildShadowView, propsParserContext),
-          mutation.parentTag);
+    const bool writesProps = mutation.type == ShadowViewMutation::Update || mutation.type == ShadowViewMutation::Insert;
+    if (writesProps && hiddenViewTags_.contains(mutation.newChildShadowView.tag)) {
+      mutation.newChildShadowView = cloneViewWithoutOpacity(mutation.newChildShadowView, propsParserContext);
     }
   }
 }
@@ -642,7 +642,7 @@ void LayoutAnimationsProxy::cleanupSharedTransitions(
     if (!parent) {
       continue;
     }
-    const auto opacity = static_cast<const ViewProps &>(*view.props).opacity;
+    const auto opacity = getViewProps(view).opacity;
     filteredMutations.push_back(ShadowViewMutation::UpdateMutation(
         cloneViewWithoutOpacity(view, propsParserContext),
         cloneViewWithOpacity(view, opacity, propsParserContext),
@@ -721,7 +721,7 @@ std::optional<Transform> LayoutAnimationsProxy::parseParentTransforms(
   while (currentNode) {
     resolveLightNodeProps(currentNode);
     const auto &view = useViewsOnScreen ? viewOnScreen(currentNode) : currentNode->current;
-    const auto &props = static_cast<const ViewProps &>(*view.props);
+    const auto &props = getViewProps(view);
     auto origin = props.transformOrigin;
     const auto &viewSize = view.layoutMetrics.frame.size;
     if (origin.xy[0].unit == facebook::react::UnitType::Percent) {

package/Common/cpp/reanimated/NativeModules/ReanimatedModuleProxy.cpp

@@ -78,6 +78,14 @@ constexpr bool shouldUseSynchronousUpdatesInPerformOperations() {
 }
 #endif
 
+std::shared_ptr<SynchronousWritesTracker> makeSynchronousWritesTracker() {
+  if constexpr (
+      shouldUseSynchronousUpdatesInPerformOperations() && !StaticFeatureFlags::getFlag("USE_ANIMATION_BACKEND")) {
+    return std::make_shared<SynchronousWritesTracker>();
+  }
+  return nullptr;
+}
+
 std::pair<UpdatesBatch, UpdatesBatch> partitionUpdates(UpdatesBatch &&updatesBatch, const bool allowPartialUpdates) {
   const auto isSynchronous = [&](const std::string &keyStr, [[maybe_unused]] const folly::dynamic &value) {
     if (!isSynchronousPropName(keyStr)) {
@@ -162,6 +170,7 @@ ReanimatedModuleProxy::ReanimatedModuleProxy(
       getAnimationTimestamp_(platformDepMethodsHolder.getAnimationTimestamp),
 #ifdef __APPLE__
       forceScreenSnapshot_(platformDepMethodsHolder.forceScreenSnapshotFunction),
+      readMountedViewProps_(platformDepMethodsHolder.readMountedViewPropsFunction),
 #endif
       staticPropsRegistry_(std::make_shared<StaticPropsRegistry>()),
       updatesRegistryManager_(std::make_shared<UpdatesRegistryManager>(staticPropsRegistry_)),
@@ -193,6 +202,7 @@ ReanimatedModuleProxy::ReanimatedModuleProxy(
 #ifdef ANDROID
       filterUnmountedTagsFunction_(platformDepMethodsHolder.filterUnmountedTagsFunction),
 #endif // ANDROID
+      synchronousWritesTracker_(makeSynchronousWritesTracker()),
       subscribeForKeyboardEventsFunction_(platformDepMethodsHolder.subscribeForKeyboardEvents),
       unsubscribeFromKeyboardEventsFunction_(platformDepMethodsHolder.unsubscribeFromKeyboardEvents) {
   // Add registries in order of their priority (from the lowest to the
@@ -868,6 +878,30 @@ void ReanimatedModuleProxy::performNonLayoutOperations() {
   applySynchronousUpdates(partitionUpdates(std::move(updatesBatch), true).first);
 }
 
+bool ReanimatedModuleProxy::hasSynchronousWritesTracker() const {
+  return synchronousWritesTracker_ != nullptr;
+}
+
+void ReanimatedModuleProxy::rewriteSynchronousProps() {
+  if (!synchronousWritesTracker_) {
+    return;
+  }
+  const auto families = synchronousWritesTracker_->getFamiliesToRewrite();
+  if (!families.empty()) {
+    UpdatesBatch registryValues;
+    {
+      auto lock = updatesRegistryManager_->lock();
+      for (const auto &family : families) {
+        folly::dynamic props = folly::dynamic::object;
+        updatesRegistryManager_->mergeRegistryProps(family->getTag(), props);
+        registryValues.emplace_back(family, std::move(props));
+      }
+    }
+    writeSynchronousPropsToViews(partitionUpdates(std::move(registryValues), true).first);
+  }
+  synchronousWritesTracker_->onRewrite();
+}
+
 AnimationMutations ReanimatedModuleProxy::collectNonLayoutAnimationUpdates() {
   ReanimatedSystraceSection s("ReanimatedModuleProxy::collectNonLayoutAnimationUpdates");
 
@@ -1040,7 +1074,13 @@ void ReanimatedModuleProxy::applySynchronousUpdates(const UpdatesBatch &synchron
     layoutAnimationsProxyRegistry_->applySynchronousProps(
         synchronousUpdatesBatch, DynamicFeatureFlags::getFlag("TRACK_SYNCHRONOUS_PROPS_IN_LAYOUT_ANIMATIONS"));
   }
+  if (synchronousWritesTracker_) {
+    synchronousWritesTracker_->onSynchronousWrite(synchronousUpdatesBatch);
+  }
+  writeSynchronousPropsToViews(synchronousUpdatesBatch);
+}
 
+void ReanimatedModuleProxy::writeSynchronousPropsToViews(const UpdatesBatch &synchronousUpdatesBatch) {
 #ifdef ANDROID
   if (!synchronousUpdatesBatch.empty()) {
     serializeSynchronousPropsToBuffers(
@@ -1201,10 +1241,19 @@ void ReanimatedModuleProxy::initializeFabric(const std::shared_ptr<UIManager> &u
   // TODO: with the animation backend we still need a way to handleNodeRemovals,
   // for now we leave this to leak the memory, a fix will come in a follow-up
   mountHook_ = std::make_shared<ReanimatedMountHook>(
-      uiManager_, updatesRegistryManager_, viewStylesRepository_, layoutAnimationsProxyRegistry_, request);
+      uiManager_,
+      updatesRegistryManager_,
+      viewStylesRepository_,
+      layoutAnimationsProxyRegistry_,
+      synchronousWritesTracker_,
+      request);
 
   commitHook_ = std::make_shared<ReanimatedCommitHook>(
-      uiManager_, updatesRegistryManager_, viewStylesRepository_, layoutAnimationsProxyRegistry_);
+      uiManager_,
+      updatesRegistryManager_,
+      viewStylesRepository_,
+      layoutAnimationsProxyRegistry_,
+      synchronousWritesTracker_);
 }
 
 void ReanimatedModuleProxy::initializeLayoutAnimationsProxyRegistry() {
@@ -1234,6 +1283,9 @@ void ReanimatedModuleProxy::initializeLayoutAnimationsProxyRegistry() {
     });
   };
 
+  constexpr bool keepsSynchronousPropsInReinserts =
+      shouldUseSynchronousUpdatesInPerformOperations() && !StaticFeatureFlags::getFlag("USE_ANIMATION_BACKEND");
+
   const LayoutAnimationsProxyDependencies dependencies{
       layoutAnimationsManager_,
       componentDescriptorRegistry,
@@ -1245,9 +1297,11 @@ void ReanimatedModuleProxy::initializeLayoutAnimationsProxyRegistry() {
 #ifdef ANDROID
       filterUnmountedTagsFunction_,
       jsInvoker_,
+      keepsSynchronousPropsInReinserts ? makeSynchronousPropsReader() : nullptr,
 #endif
 #ifdef __APPLE__
       forceScreenSnapshot_,
+      keepsSynchronousPropsInReinserts ? readMountedViewProps_ : nullptr,
 #endif
   };
 
@@ -1258,6 +1312,25 @@ void ReanimatedModuleProxy::initializeLayoutAnimationsProxyRegistry() {
   }
 }
 
+#ifdef ANDROID
+SynchronousPropsReader ReanimatedModuleProxy::makeSynchronousPropsReader() {
+  if (!ReactNativeFeatureFlags::enableAccumulatedUpdatesInRawPropsAndroid()) {
+    return nullptr;
+  }
+  return [weakThis = weak_from_this()](const Tag tag) {
+    const auto strongThis = weakThis.lock();
+    return strongThis ? strongThis->readSynchronousProps(tag) : folly::dynamic::object();
+  };
+}
+
+folly::dynamic ReanimatedModuleProxy::readSynchronousProps(const Tag tag) {
+  folly::dynamic synchronousProps = folly::dynamic::object;
+  auto lock = updatesRegistryManager_->lock();
+  updatesRegistryManager_->mergeRegistryProps(tag, synchronousProps, isSynchronousPropName);
+  return synchronousProps;
+}
+#endif // ANDROID
+
 #ifdef IS_REANIMATED_EXAMPLE_APP
 
 std::string format(bool b) {

package/Common/cpp/reanimated/NativeModules/ReanimatedModuleProxy.h

@@ -21,6 +21,7 @@
 #include <reanimated/Fabric/ShadowTreeCloner.h>
 #include <reanimated/Fabric/updates/AnimatedPropsRegistry.h>
 #include <reanimated/Fabric/updates/OperationsLoop.h>
+#include <reanimated/Fabric/updates/SynchronousWritesTracker.h>
 #include <reanimated/Fabric/updates/UpdatesRegistryManager.h>
 #include <reanimated/LayoutAnimations/LayoutAnimationsManager.h>
 #include <reanimated/LayoutAnimations/LayoutAnimationsProxyRegistry.h>
@@ -108,6 +109,8 @@ class ReanimatedModuleProxy : public std::enable_shared_from_this<ReanimatedModu
 
   void performOperations();
   void performNonLayoutOperations();
+  bool hasSynchronousWritesTracker() const;
+  void rewriteSynchronousProps();
   void flushLayoutAnimationOperations();
   void executeLayoutAnimationsRequests();
 
@@ -205,6 +208,11 @@ class ReanimatedModuleProxy : public std::enable_shared_from_this<ReanimatedModu
 
   void commitUpdates(const std::unordered_map<SurfaceId, PropsMap> &propsMapBySurface);
   void applySynchronousUpdates(const UpdatesBatch &synchronousUpdatesBatch);
+  void writeSynchronousPropsToViews(const UpdatesBatch &synchronousUpdatesBatch);
+#ifdef ANDROID
+  SynchronousPropsReader makeSynchronousPropsReader();
+  folly::dynamic readSynchronousProps(Tag tag);
+#endif
 
   std::shared_ptr<UIManagerAnimationBackend> getAnimationBackend();
   AnimationMutations runGrandCallback(AnimationTimestamp timestamp, GrandCallbackSource source);
@@ -239,6 +247,7 @@ class ReanimatedModuleProxy : public std::enable_shared_from_this<ReanimatedModu
 
 #ifdef __APPLE__
   ForceScreenSnapshotFunction forceScreenSnapshot_;
+  ReadMountedViewPropsFunction readMountedViewProps_;
 #endif
   const std::shared_ptr<StaticPropsRegistry> staticPropsRegistry_;
   const std::shared_ptr<UpdatesRegistryManager> updatesRegistryManager_;
@@ -253,9 +262,10 @@ class ReanimatedModuleProxy : public std::enable_shared_from_this<ReanimatedModu
 
   const SynchronouslyUpdateUIPropsFunction synchronouslyUpdateUIPropsFunction_;
   const PreserveMountedTagsFunction filterUnmountedTagsFunction_;
+  const std::shared_ptr<SynchronousWritesTracker> synchronousWritesTracker_;
 
 #ifdef ANDROID
-  // Reused across `applySynchronousUpdates` calls to avoid per-frame heap
+  // Reused across `writeSynchronousPropsToViews` calls to avoid per-frame heap
   // allocations. Access only on the UI thread.
   std::vector<int> synchronousPropsIntBuffer_;
   std::vector<double> synchronousPropsDoubleBuffer_;

package/Common/cpp/reanimated/Tools/PlatformDepMethodsHolder.h

@@ -6,6 +6,7 @@
 
 #include <folly/dynamic.h>
 #include <jsi/jsi.h>
+#include <react/renderer/core/Props.h>
 #include <react/renderer/core/ReactPrimitives.h>
 
 #include <memory>
@@ -47,7 +48,8 @@ using KeyboardEventSubscribeFunction = std::function<int(std::function<void(int,
 using KeyboardEventUnsubscribeFunction = std::function<void(int)>;
 using MaybeFlushUIUpdatesQueueFunction = std::function<void()>;
 
-using ForceScreenSnapshotFunction = std::function<void(Tag tag)>;
+using ForceScreenSnapshotFunction = std::function<bool(Tag tag)>;
+using ReadMountedViewPropsFunction = std::function<Props::Shared(Tag tag)>;
 
 using PlatformAttachPseudoSelectorFunction = std::function<void(Tag, PseudoSelector, std::function<void(bool)>)>;
 using PlatformDetachPseudoSelectorFunction = std::function<void(Tag, PseudoSelector)>;
@@ -59,6 +61,7 @@ struct PlatformDepMethodsHolder {
 #endif // ANDROID
 #ifdef __APPLE__
   ForceScreenSnapshotFunction forceScreenSnapshotFunction;
+  ReadMountedViewPropsFunction readMountedViewPropsFunction;
 #endif
   SynchronouslyUpdateUIPropsFunction synchronouslyUpdateUIPropsFunction;
   GetAnimationTimestampFunction getAnimationTimestamp;

package/android/src/main/cpp/reanimated/android/NativeProxy.cpp

@@ -138,6 +138,14 @@ void NativeProxy::performNonLayoutOperations() {
   reanimatedModuleProxy_->performNonLayoutOperations();
 }
 
+bool NativeProxy::hasSynchronousWritesTracker() {
+  return reanimatedModuleProxy_->hasSynchronousWritesTracker();
+}
+
+void NativeProxy::rewriteSynchronousProps() {
+  reanimatedModuleProxy_->rewriteSynchronousProps();
+}
+
 bool NativeProxy::getIsReducedMotion() {
   static const auto method = getJniMethod<jboolean()>("getIsReducedMotion");
   return method(javaPart_.get());
@@ -151,9 +159,11 @@ void NativeProxy::registerNatives() {
   registerHybrid(
       {makeNativeMethod("initHybrid", NativeProxy::initHybrid),
        makeNativeMethod("installJSIBindings", NativeProxy::installJSIBindings),
-       makeNativeMethod("isAnyHandlerWaitingForEvent", NativeProxy::isAnyHandlerWaitingForEvent),
-       makeNativeMethod("performOperations", NativeProxy::performOperations),
-       makeNativeMethod("performNonLayoutOperations", NativeProxy::performNonLayoutOperations),
+       makeNativeMethod("isAnyHandlerWaitingForEventCpp", NativeProxy::isAnyHandlerWaitingForEvent),
+       makeNativeMethod("performOperationsCpp", NativeProxy::performOperations),
+       makeNativeMethod("performNonLayoutOperationsCpp", NativeProxy::performNonLayoutOperations),
+       makeNativeMethod("hasSynchronousWritesTracker", NativeProxy::hasSynchronousWritesTracker),
+       makeNativeMethod("rewriteSynchronousProps", NativeProxy::rewriteSynchronousProps),
        makeNativeMethod("invalidateCpp", NativeProxy::invalidateCpp),
        makeNativeMethod("toggleSlowAnimationsOnUIRuntime", NativeProxy::toggleSlowAnimationsOnUIRuntime)});
 }

package/android/src/main/cpp/reanimated/android/NativeProxy.h

@@ -55,6 +55,8 @@ class NativeProxy : public jni::HybridClass<NativeProxy>, std::enable_shared_fro
   bool isAnyHandlerWaitingForEvent(const std::string &eventName, const int emitterReactTag);
   void performOperations();
   void performNonLayoutOperations();
+  bool hasSynchronousWritesTracker();
+  void rewriteSynchronousProps();
   bool getIsReducedMotion();
   void requestRender(std::function<void(double)> onRender);
   void registerEventHandler();

package/android/src/main/java/com/swmansion/reanimated/NativeProxy.kt

@@ -8,8 +8,11 @@ import com.facebook.jni.HybridData
 import com.facebook.proguard.annotations.DoNotStrip
 import com.facebook.react.bridge.NativeModule
 import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.UIManager
+import com.facebook.react.bridge.UIManagerListener
 import com.facebook.react.bridge.UiThreadUtil
 import com.facebook.react.common.annotations.FrameworkAPI
+import com.facebook.react.common.annotations.UnstableReactNativeAPI
 import com.facebook.react.fabric.FabricUIManager
 import com.facebook.react.turbomodule.core.CallInvokerHolderImpl
 import com.facebook.react.uimanager.IllegalViewOperationException
@@ -30,6 +33,8 @@ import com.swmansion.reanimated.sensor.ReanimatedSensorContainer
 import com.swmansion.reanimated.sensor.ReanimatedSensorType
 import java.lang.ref.WeakReference
 import java.util.concurrent.atomic.AtomicBoolean
+import java.util.concurrent.locks.ReentrantReadWriteLock
+import kotlin.concurrent.write
 
 @Suppress("KotlinJniMissingFunction")
 @OptIn(FrameworkAPI::class)
@@ -64,10 +69,27 @@ open class NativeProxy {
      */
     private val mInvalidated = AtomicBoolean(false)
 
+    // Guards the C++ state that invalidateCpp() destroys against calls from the UI thread.
+    private val mNativeStateLock = ReentrantReadWriteLock()
+
     @field:DoNotStrip
     @Suppress("unused")
     private val mHybridData: HybridData
 
+    @OptIn(UnstableReactNativeAPI::class)
+    private val mountListener =
+        object : UIManagerListener {
+            override fun willDispatchViewUpdates(uiManager: UIManager) = Unit
+
+            override fun willMountItems(uiManager: UIManager) = Unit
+
+            override fun didMountItems(uiManager: UIManager) = ifNotInvalidated(Unit) { rewriteSynchronousProps() }
+
+            override fun didDispatchMountItems(uiManager: UIManager) = Unit
+
+            override fun didScheduleMountItems(uiManager: UIManager) = Unit
+        }
+
     constructor(context: ReactApplicationContext, nodesManager: NodesManager) {
         context.assertOnJSQueueThread()
 
@@ -109,6 +131,10 @@ open class NativeProxy {
         if (BuildConfig.DEBUG) {
             checkCppVersion() // injectCppVersion should be called during initHybrid above
         }
+        if (hasSynchronousWritesTracker()) {
+            @OptIn(UnstableReactNativeAPI::class)
+            mFabricUIManager.addUIManagerEventListener(mountListener)
+        }
     }
 
     private external fun initHybrid(
@@ -117,31 +143,67 @@ open class NativeProxy {
         fabricUIManager: FabricUIManager,
     ): HybridData
 
-    external fun isAnyHandlerWaitingForEvent(
+    private external fun isAnyHandlerWaitingForEventCpp(
         eventName: String,
         emitterReactTag: Int,
     ): Boolean
 
-    external fun performOperations()
+    private external fun performOperationsCpp()
+
+    private external fun performNonLayoutOperationsCpp()
+
+    private external fun hasSynchronousWritesTracker(): Boolean
 
-    external fun performNonLayoutOperations()
+    private external fun rewriteSynchronousProps()
 
     external fun installJSIBindings()
 
     private external fun invalidateCpp()
 
-    external fun toggleSlowAnimationsOnUIRuntime()
+    private external fun toggleSlowAnimationsOnUIRuntime()
 
     protected fun getHybridData(): HybridData = mHybridData
 
+    // tryLock, because the UI thread may hold the UI runtime lock, which could deadlock with invalidate()
+    private inline fun <T> ifNotInvalidated(
+        fallback: T,
+        block: () -> T,
+    ): T {
+        val readLock = mNativeStateLock.readLock()
+        if (!readLock.tryLock()) {
+            return fallback
+        }
+        try {
+            if (mInvalidated.get()) {
+                return fallback
+            }
+            return block()
+        } finally {
+            readLock.unlock()
+        }
+    }
+
+    fun isAnyHandlerWaitingForEvent(
+        eventName: String,
+        emitterReactTag: Int,
+    ): Boolean = ifNotInvalidated(false) { isAnyHandlerWaitingForEventCpp(eventName, emitterReactTag) }
+
+    fun performOperations() = ifNotInvalidated(Unit) { performOperationsCpp() }
+
+    fun performNonLayoutOperations() = ifNotInvalidated(Unit) { performNonLayoutOperationsCpp() }
+
     fun invalidate() {
         if (mInvalidated.getAndSet(true)) {
             return
         }
+        @OptIn(UnstableReactNativeAPI::class)
+        mFabricUIManager.removeUIManagerEventListener(mountListener)
         pseudoSelectorManager.invalidate()
         cssPlatformTransitionsManager.invalidate()
-        if (mHybridData.isValid) {
-            invalidateCpp()
+        mNativeStateLock.write {
+            if (mHybridData.isValid) {
+                invalidateCpp()
+            }
         }
     }
 
@@ -152,7 +214,7 @@ open class NativeProxy {
         }
         mNodesManager!!.enableSlowAnimations(slowAnimationsEnabled, animationsDragFactor)
         cssPlatformTransitionsManager.enableSlowAnimations(slowAnimationsEnabled, animationsDragFactor)
-        toggleSlowAnimationsOnUIRuntime()
+        ifNotInvalidated(Unit) { toggleSlowAnimationsOnUIRuntime() }
     }
 
     private fun addDevMenuOption() {
@@ -175,8 +237,12 @@ open class NativeProxy {
 
     @DoNotStrip
     fun requestRender(callback: AnimationFrameCallback) {
+        val guardedCallback =
+            object : NodesManager.OnAnimationFrame {
+                override fun onAnimationFrame(timestampMs: Double) = ifNotInvalidated(Unit) { callback.onAnimationFrame(timestampMs) }
+            }
         UiThreadUtil.assertOnUiThread()
-        mNodesManager!!.postOnAnimation(callback)
+        mNodesManager!!.postOnAnimation(guardedCallback)
     }
 
     @DoNotStrip fun getReanimatedJavaVersion(): String = BuildConfig.REANIMATED_VERSION_JAVA
@@ -250,6 +316,10 @@ open class NativeProxy {
             }.apply { isAccessible = true }
     }
 
+    private val getViewExistsMethod by lazy {
+        runCatching { mountingManager.javaClass.getMethod("getViewExists", Int::class.javaPrimitiveType) }.getOrNull()
+    }
+
     @DoNotStrip
     fun synchronouslyUpdateUIProps(
         intBuffer: IntArray,
@@ -258,9 +328,13 @@ open class NativeProxy {
         cssPlatformTransitionsManager.onPropsWrittenSynchronously()
         SynchronousPropsBufferParser.parse(intBuffer, doubleBuffer) { viewTag, props ->
             try {
+                // The props stay in the registry, and the commit hook applies them to the shadow tree.
+                if (getViewExistsMethod?.invoke(mountingManager, viewTag) == false) {
+                    return@parse
+                }
                 updatePropsSynchronouslyMethod.invoke(mountingManager, viewTag, props)
             } catch (e: Exception) {
-                Log.w("Reanimated", "synchronouslyUpdateUIProps failed for tag $viewTag", e)
+                Log.w("Reanimated", "synchronouslyUpdateUIProps failed for tag $viewTag: ${e.cause ?: e}")
             }
         }
     }
@@ -330,6 +404,7 @@ open class NativeProxy {
     fun registerEventHandler(handler: EventHandler) {
         handler.mCustomEventNamesResolver = mNodesManager!!.getEventNameResolver()
         handler.isInDrawPassProvider = { mNodesManager!!.isInDrawPass() }
+        handler.nativeCallGuard = { receive -> ifNotInvalidated(Unit, receive) }
         mNodesManager!!.registerEventHandler(handler)
     }
 

package/android/src/main/java/com/swmansion/reanimated/NodesManager.kt

@@ -199,9 +199,7 @@ class NodesManager(
                 Trace.beginSection("onEventDispatch")
             }
 
-            if (mNativeProxy == null) {
-                return
-            }
+            val nativeProxy = mNativeProxy ?: return
             // Events can be dispatched from any thread so we have to make sure handleEvent is run from
             // the UI thread.
             if (UiThreadUtil.isOnUiThread()) {
@@ -213,7 +211,7 @@ class NodesManager(
             } else {
                 val eventName = mCustomEventNamesResolver.resolveCustomEventName(event.eventName) ?: return
                 val viewTag = event.viewTag
-                val shouldSaveEvent = mNativeProxy!!.isAnyHandlerWaitingForEvent(eventName, viewTag)
+                val shouldSaveEvent = nativeProxy.isAnyHandlerWaitingForEvent(eventName, viewTag)
                 if (shouldSaveEvent) {
                     mEventQueue.offer(CopiedEvent(event))
                 }

package/android/src/main/java/com/swmansion/reanimated/nativeProxy/EventHandler.kt

@@ -14,6 +14,7 @@ class EventHandler : RCTModernEventEmitter {
 
     var mCustomEventNamesResolver: UIManagerModule.CustomEventNamesResolver? = null
     internal var isInDrawPassProvider: (() -> Boolean)? = null
+    internal var nativeCallGuard: (() -> Unit) -> Unit = { it() }
 
     @DoNotStrip
     private constructor(hybridData: HybridData) {
@@ -32,7 +33,7 @@ class EventHandler : RCTModernEventEmitter {
         category: Int,
     ) {
         val resolvedEventName = mCustomEventNamesResolver!!.resolveCustomEventName(eventName) ?: eventName
-        receiveEvent(resolvedEventName, targetTag, params, isInDrawPass())
+        nativeCallGuard { receiveEvent(resolvedEventName, targetTag, params, isInDrawPass()) }
     }
 
     override fun receiveEvent(
@@ -42,7 +43,7 @@ class EventHandler : RCTModernEventEmitter {
         params: WritableMap?,
     ) {
         val resolvedEventName = mCustomEventNamesResolver!!.resolveCustomEventName(eventName) ?: eventName
-        receiveEvent(resolvedEventName, targetTag, params, isInDrawPass())
+        nativeCallGuard { receiveEvent(resolvedEventName, targetTag, params, isInDrawPass()) }
     }
 
     override fun receiveEvent(
@@ -51,7 +52,7 @@ class EventHandler : RCTModernEventEmitter {
         params: WritableMap?,
     ) {
         val resolvedEventName = mCustomEventNamesResolver!!.resolveCustomEventName(eventName) ?: eventName
-        receiveEvent(resolvedEventName, targetTag, params, isInDrawPass())
+        nativeCallGuard { receiveEvent(resolvedEventName, targetTag, params, isInDrawPass()) }
     }
 
     override fun receiveTouches(

package/android/src/main/java/com/swmansion/reanimated/sensor/ReanimatedSensor.kt

@@ -26,7 +26,7 @@ internal class ReanimatedSensor(
     init {
         val wm = reactContext.get()!!.getSystemService(Context.WINDOW_SERVICE) as WindowManager
         val display = wm.defaultDisplay
-        listener = ReanimatedSensorListener(setter, interval.toDouble(), display)
+        listener = ReanimatedSensorListener(setter, interval.toDouble(), display, sensorType)
         sensorManager =
             reactContext.get()!!.getSystemService(Context.SENSOR_SERVICE) as SensorManager
         this.interval = if (interval == -1) DEFAULT_INTERVAL else interval