react-native-reanimated 4.7.0 → 4.7.1

package/Common/cpp/reanimated/Fabric/ReanimatedCommitHook.cpp

@@ -16,11 +16,13 @@ ReanimatedCommitHook::ReanimatedCommitHook(
     const std::shared_ptr<UIManager> &uiManager,
     const std::shared_ptr<UpdatesRegistryManager> &updatesRegistryManager,
     const std::shared_ptr<css::ViewStylesRepository> &viewStylesRepository,
-    const std::shared_ptr<LayoutAnimationsProxyRegistry> &layoutAnimationsProxyRegistry)
+    const std::shared_ptr<LayoutAnimationsProxyRegistry> &layoutAnimationsProxyRegistry,
+    const std::shared_ptr<SynchronousWritesTracker> &synchronousWritesTracker)
     : uiManager_(uiManager),
       updatesRegistryManager_(updatesRegistryManager),
       viewStylesRepository_(viewStylesRepository),
-      layoutAnimationsProxyRegistry_(layoutAnimationsProxyRegistry) {
+      layoutAnimationsProxyRegistry_(layoutAnimationsProxyRegistry),
+      synchronousWritesTracker_(synchronousWritesTracker) {
   uiManager_->registerCommitHook(*this);
   uiManager_->getShadowTreeRegistry().enumerate(
       [this](const ShadowTree &shadowTree, bool & /*stop*/) { registerLayoutAnimations(shadowTree); });
@@ -57,6 +59,9 @@ RootShadowNode::Unshared ReanimatedCommitHook::shadowTreeWillCommit(
     // A stopping surface commits an empty root; its mount is not reported on a paused Android host.
     auto lock = updatesRegistryManager_->lock();
     viewStylesRepository_->removeSurface(shadowTree.getSurfaceId());
+    if (synchronousWritesTracker_) {
+      synchronousWritesTracker_->onSurfaceStop(shadowTree.getSurfaceId());
+    }
   }
 
   auto reaShadowNode = std::reinterpret_pointer_cast<ReanimatedCommitShadowNode>(newRootShadowNode);
@@ -66,6 +71,7 @@ RootShadowNode::Unshared ReanimatedCommitHook::shadowTreeWillCommit(
     // the updates registry manager
     reaShadowNode->unsetReanimatedCommitTrait();
     reaShadowNode->setReanimatedMountTrait();
+    trackCommit(newRootShadowNode, false);
     return newRootShadowNode;
   }
 
@@ -74,6 +80,7 @@ RootShadowNode::Unshared ReanimatedCommitHook::shadowTreeWillCommit(
     // which means that all animation changes are already included.
     // Therefore, there's no need to reapply styles from the props map.
     if (commitOptions.source != ShadowTreeCommitSource::React) {
+      trackCommit(newRootShadowNode, false);
       return newRootShadowNode;
     }
   }
@@ -90,6 +97,8 @@ RootShadowNode::Unshared ReanimatedCommitHook::shadowTreeWillCommit(
     updatesRegistryManager_->cancelCommitAfterPause();
 
     rootNode = cloneShadowTreeWithNewProps(*rootNode, propsMap);
+    // Must share the registry lock with `collectProps`, or a write can get the epoch of a snapshot that lacks it.
+    trackCommit(rootNode, true);
     // If the commit comes from React Native then pause commits from
     // Reanimated since the ShadowTree to be committed by Reanimated may not
     // include the new changes from React Native yet and all changes of animated
@@ -104,4 +113,27 @@ RootShadowNode::Unshared ReanimatedCommitHook::shadowTreeWillCommit(
   return rootNode;
 }
 
+#if REACT_NATIVE_VERSION_MINOR >= 88
+void ReanimatedCommitHook::shadowTreeDidCommit(
+    const ShadowTree &,
+    const RootShadowNode::Shared &rootShadowNode,
+    const std::vector<const LayoutableShadowNode *> &) noexcept {
+  if (synchronousWritesTracker_) {
+    synchronousWritesTracker_->onDidCommit(rootShadowNode);
+  }
+}
+#endif
+
+void ReanimatedCommitHook::trackCommit(const RootShadowNode::Shared &rootShadowNode, const bool carriesRegistryValues)
+    const {
+  if (!synchronousWritesTracker_) {
+    return;
+  }
+  synchronousWritesTracker_->onWillCommit(rootShadowNode, carriesRegistryValues);
+#if REACT_NATIVE_VERSION_MINOR < 88
+  // Before 0.88 there is no `shadowTreeDidCommit`. The root that this hook returns is the only one available.
+  synchronousWritesTracker_->onDidCommit(rootShadowNode);
+#endif
+}
+
 } // namespace reanimated

package/Common/cpp/reanimated/Fabric/ReanimatedCommitHook.h

@@ -1,12 +1,15 @@
 #pragma once
 
 #include <reanimated/CSS/misc/ViewStylesRepository.h>
+#include <reanimated/Compat/ReactNativeVersionCompat.h>
+#include <reanimated/Fabric/updates/SynchronousWritesTracker.h>
 #include <reanimated/Fabric/updates/UpdatesRegistryManager.h>
 #include <reanimated/LayoutAnimations/LayoutAnimationsProxyRegistry.h>
 
 #include <react/renderer/uimanager/UIManagerCommitHook.h>
 
 #include <memory>
+#include <vector>
 
 using namespace facebook::react;
 
@@ -18,7 +21,8 @@ class ReanimatedCommitHook : public UIManagerCommitHook {
       const std::shared_ptr<UIManager> &uiManager,
       const std::shared_ptr<UpdatesRegistryManager> &updatesRegistryManager,
       const std::shared_ptr<css::ViewStylesRepository> &viewStylesRepository,
-      const std::shared_ptr<LayoutAnimationsProxyRegistry> &layoutAnimationsProxyRegistry);
+      const std::shared_ptr<LayoutAnimationsProxyRegistry> &layoutAnimationsProxyRegistry,
+      const std::shared_ptr<SynchronousWritesTracker> &synchronousWritesTracker);
 
   ~ReanimatedCommitHook() noexcept override;
 
@@ -34,11 +38,21 @@ class ReanimatedCommitHook : public UIManagerCommitHook {
       RootShadowNode::Unshared const &newRootShadowNode,
       const ShadowTreeCommitOptions &commitOptions) noexcept override;
 
+#if REACT_NATIVE_VERSION_MINOR >= 88
+  void shadowTreeDidCommit(
+      const ShadowTree &shadowTree,
+      const RootShadowNode::Shared &rootShadowNode,
+      const std::vector<const LayoutableShadowNode *> &affectedLayoutableNodes) noexcept override;
+#endif
+
  private:
+  void trackCommit(const RootShadowNode::Shared &rootShadowNode, bool carriesRegistryValues) const;
+
   std::shared_ptr<UIManager> uiManager_;
   std::shared_ptr<UpdatesRegistryManager> updatesRegistryManager_;
   std::shared_ptr<css::ViewStylesRepository> viewStylesRepository_;
   std::shared_ptr<LayoutAnimationsProxyRegistry> layoutAnimationsProxyRegistry_;
+  std::shared_ptr<SynchronousWritesTracker> synchronousWritesTracker_;
 };
 
 } // namespace reanimated

package/Common/cpp/reanimated/Fabric/ReanimatedMountHook.cpp

@@ -12,11 +12,13 @@ ReanimatedMountHook::ReanimatedMountHook(
     const std::shared_ptr<UpdatesRegistryManager> &updatesRegistryManager,
     const std::shared_ptr<css::ViewStylesRepository> &viewStylesRepository,
     const std::shared_ptr<LayoutAnimationsProxyRegistry> &layoutAnimationsProxyRegistry,
+    const std::shared_ptr<SynchronousWritesTracker> &synchronousWritesTracker,
     const std::function<void()> &requestFlush)
     : uiManager_(uiManager),
       updatesRegistryManager_(updatesRegistryManager),
       viewStylesRepository_(viewStylesRepository),
       layoutAnimationsProxyRegistry_(layoutAnimationsProxyRegistry),
+      synchronousWritesTracker_(synchronousWritesTracker),
       requestFlush_(requestFlush) {
   uiManager_->registerMountHook(*this);
 }
@@ -35,6 +37,10 @@ void ReanimatedMountHook::shadowTreeDidMount(
     return;
   }
 
+  if (synchronousWritesTracker_) {
+    synchronousWritesTracker_->onMountReport(rootShadowNode);
+  }
+
   auto reaShadowNode = std::reinterpret_pointer_cast<ReanimatedCommitShadowNode>(
       std::const_pointer_cast<RootShadowNode>(rootShadowNode));
 
@@ -73,6 +79,9 @@ void ReanimatedMountHook::shadowTreeDidUnmount(SurfaceId surfaceId, HighResTimeS
   if (layoutAnimationsProxyRegistry_) {
     layoutAnimationsProxyRegistry_->remove(surfaceId);
   }
+  if (synchronousWritesTracker_) {
+    synchronousWritesTracker_->onSurfaceStop(surfaceId);
+  }
 
   auto lock = updatesRegistryManager_->lock();
   viewStylesRepository_->removeSurface(surfaceId);

package/Common/cpp/reanimated/Fabric/ReanimatedMountHook.h

@@ -2,6 +2,7 @@
 
 #include <reanimated/CSS/misc/ViewStylesRepository.h>
 #include <reanimated/Fabric/ShadowTreeCloner.h>
+#include <reanimated/Fabric/updates/SynchronousWritesTracker.h>
 #include <reanimated/Fabric/updates/UpdatesRegistryManager.h>
 #include <reanimated/LayoutAnimations/LayoutAnimationsProxyRegistry.h>
 
@@ -20,6 +21,7 @@ class ReanimatedMountHook : public UIManagerMountHook {
       const std::shared_ptr<UpdatesRegistryManager> &updatesRegistryManager,
       const std::shared_ptr<css::ViewStylesRepository> &viewStylesRepository,
       const std::shared_ptr<LayoutAnimationsProxyRegistry> &layoutAnimationsProxyRegistry,
+      const std::shared_ptr<SynchronousWritesTracker> &synchronousWritesTracker,
       const std::function<void()> &requestFlush);
   ~ReanimatedMountHook() noexcept override;
 
@@ -32,6 +34,7 @@ class ReanimatedMountHook : public UIManagerMountHook {
   const std::shared_ptr<UpdatesRegistryManager> updatesRegistryManager_;
   const std::shared_ptr<css::ViewStylesRepository> viewStylesRepository_;
   const std::shared_ptr<LayoutAnimationsProxyRegistry> layoutAnimationsProxyRegistry_;
+  const std::shared_ptr<SynchronousWritesTracker> synchronousWritesTracker_;
   const std::function<void()> requestFlush_;
 };
 

package/Common/cpp/reanimated/Fabric/updates/SynchronousWritesTracker.cpp

@@ -0,0 +1,103 @@
+#include <reanimated/Fabric/updates/SynchronousWritesTracker.h>
+
+#include <algorithm>
+
+namespace reanimated {
+
+void SynchronousWritesTracker::onWillCommit(
+    const RootShadowNode::Shared &rootShadowNode,
+    const bool carriesRegistryValues) {
+  auto lock = std::scoped_lock{mutex_};
+  const auto threadId = std::this_thread::get_id();
+  pendingCommits_.erase(threadId);
+  if (rootShadowNode->getChildren().empty()) {
+    return;
+  }
+  const auto surfaceId = rootShadowNode->getSurfaceId();
+  auto &surface = surfaces_[surfaceId];
+  if (carriesRegistryValues) {
+    surface.epoch++;
+  }
+  pendingCommits_.emplace(threadId, PendingCommit{surfaceId, surface.epoch});
+}
+
+void SynchronousWritesTracker::onDidCommit(const RootShadowNode::Shared &rootShadowNode) {
+  auto lock = std::scoped_lock{mutex_};
+  const auto pendingCommit = pendingCommits_.extract(std::this_thread::get_id());
+  if (pendingCommit.empty() || pendingCommit.mapped().surfaceId != rootShadowNode->getSurfaceId()) {
+    return;
+  }
+  const auto surfaceIt = surfaces_.find(pendingCommit.mapped().surfaceId);
+  if (surfaceIt == surfaces_.end()) {
+    return;
+  }
+  rememberRoot(surfaceIt->second, rootShadowNode, pendingCommit.mapped().epoch);
+}
+
+void SynchronousWritesTracker::rememberRoot(
+    SurfaceState &surface,
+    const RootShadowNode::Shared &rootShadowNode,
+    const Epoch epoch) {
+  auto &committedRoots = surface.committedRoots;
+  while (!committedRoots.empty() && committedRoots.front().rootShadowNode.expired()) {
+    committedRoots.pop_front();
+  }
+  committedRoots.push_back({rootShadowNode, epoch});
+}
+
+void SynchronousWritesTracker::onSynchronousWrite(const UpdatesBatch &synchronousUpdatesBatch) {
+  auto lock = std::scoped_lock{mutex_};
+  for (const auto &[shadowNodeFamily, props] : synchronousUpdatesBatch) {
+    const auto surfaceIt = surfaces_.find(shadowNodeFamily->getSurfaceId());
+    if (surfaceIt == surfaces_.end() || surfaceIt->second.epoch == surfaceIt->second.mountedEpoch) {
+      continue;
+    }
+    auto &surface = surfaceIt->second;
+    surface.writes.insert_or_assign(shadowNodeFamily->getTag(), Write{shadowNodeFamily, surface.epoch});
+  }
+}
+
+void SynchronousWritesTracker::onMountReport(const RootShadowNode::Shared &mountedRootShadowNode) {
+  auto lock = std::scoped_lock{mutex_};
+  const auto surfaceIt = surfaces_.find(mountedRootShadowNode->getSurfaceId());
+  if (surfaceIt == surfaces_.end()) {
+    return;
+  }
+  auto &surface = surfaceIt->second;
+  auto &committedRoots = surface.committedRoots;
+  const auto it = std::find_if(committedRoots.begin(), committedRoots.end(), [&](const CommittedRoot &root) {
+    return root.rootShadowNode.lock() == mountedRootShadowNode;
+  });
+  if (it == committedRoots.end()) {
+    return;
+  }
+  surface.reportedEpoch = it->epoch;
+  committedRoots.erase(committedRoots.begin(), it + 1);
+}
+
+void SynchronousWritesTracker::onSurfaceStop(const SurfaceId surfaceId) {
+  auto lock = std::scoped_lock{mutex_};
+  surfaces_.erase(surfaceId);
+}
+
+std::vector<ShadowNodeFamily::Shared> SynchronousWritesTracker::getFamiliesToRewrite() const {
+  auto lock = std::scoped_lock{mutex_};
+  std::vector<ShadowNodeFamily::Shared> families;
+  for (const auto &[_, surface] : surfaces_) {
+    for (const auto &[tag, write] : surface.writes) {
+      families.push_back(write.shadowNodeFamily);
+    }
+  }
+  return families;
+}
+
+void SynchronousWritesTracker::onRewrite() {
+  auto lock = std::scoped_lock{mutex_};
+  for (auto &[_, surface] : surfaces_) {
+    const auto mountedEpoch = surface.reportedEpoch;
+    surface.mountedEpoch = mountedEpoch;
+    std::erase_if(surface.writes, [mountedEpoch](const auto &entry) { return entry.second.epoch <= mountedEpoch; });
+  }
+}
+
+} // namespace reanimated

package/Common/cpp/reanimated/Fabric/updates/SynchronousWritesTracker.h

@@ -0,0 +1,74 @@
+#pragma once
+
+#include <reanimated/Fabric/updates/UpdatesRegistry.h>
+
+#include <react/renderer/components/root/RootShadowNode.h>
+#include <react/renderer/core/ShadowNodeFamily.h>
+
+#include <cstdint>
+#include <deque>
+#include <memory>
+#include <mutex>
+#include <thread>
+#include <unordered_map>
+#include <vector>
+
+using namespace facebook::react;
+
+namespace reanimated {
+
+// A React commit takes its animated values from the registries in the commit hook, but the platform can mount it
+// after newer synchronous writes. This class keeps the views with such writes until every such commit is mounted, so
+// that the platform can write their current values again after a mount.
+class SynchronousWritesTracker {
+ public:
+  void onWillCommit(const RootShadowNode::Shared &rootShadowNode, bool carriesRegistryValues);
+  void onDidCommit(const RootShadowNode::Shared &rootShadowNode);
+  void onSynchronousWrite(const UpdatesBatch &synchronousUpdatesBatch);
+  void onMountReport(const RootShadowNode::Shared &mountedRootShadowNode);
+  void onSurfaceStop(SurfaceId surfaceId);
+  std::vector<ShadowNodeFamily::Shared> getFamiliesToRewrite() const;
+  void onRewrite();
+
+ private:
+  using Epoch = uint64_t;
+
+  struct CommittedRoot {
+    std::weak_ptr<const RootShadowNode> rootShadowNode;
+    Epoch epoch;
+  };
+
+  struct Write {
+    ShadowNodeFamily::Shared shadowNodeFamily;
+    Epoch epoch;
+  };
+
+  struct PendingCommit {
+    SurfaceId surfaceId;
+    Epoch epoch;
+  };
+
+  struct SurfaceState {
+    // Number of commits that carried registry values. A write with epoch N is newer than the values in commits 1..N.
+    Epoch epoch{0};
+    // Android reports a mount at the pull, before the mount items run. The next mount callback writes the props
+    // again. That callback also runs for a dispatch that has only view commands. If such a dispatch runs before the
+    // mount items, the tracker removes the writes too early. The old value then stays on screen until the next
+    // synchronous write.
+    Epoch reportedEpoch{0};
+    Epoch mountedEpoch{0};
+    std::deque<CommittedRoot> committedRoots;
+    std::unordered_map<Tag, Write> writes;
+  };
+
+  static void rememberRoot(SurfaceState &surface, const RootShadowNode::Shared &rootShadowNode, Epoch epoch);
+
+  mutable std::mutex mutex_;
+  // Carries the epoch from `onWillCommit` (known at the registry read) to `onDidCommit` (final root, after all
+  // hooks). Both run on the committing thread, but commits on different threads can overlap on one surface, so
+  // the key is the thread. A failed or cancelled commit gets no `onDidCommit`; `onWillCommit` drops its entry.
+  std::unordered_map<std::thread::id, PendingCommit> pendingCommits_;
+  std::unordered_map<SurfaceId, SurfaceState> surfaces_;
+};
+
+} // namespace reanimated

package/Common/cpp/reanimated/Fabric/updates/UpdatesRegistry.cpp

@@ -37,6 +37,21 @@ void UpdatesRegistry::mergeInto(const Tag tag, folly::dynamic &target) const {
   target.update(it->second.second);
 }
 
+#ifdef ANDROID
+void UpdatesRegistry::mergeInto(const Tag tag, folly::dynamic &target, const PropNamePredicate isIncluded) const {
+  react_native_assert(UpdatesRegistryManager::isLockedByCurrentThread());
+  auto it = updatesRegistry_.find(tag);
+  if (it == updatesRegistry_.cend()) {
+    return;
+  }
+  for (const auto &[name, value] : it->second.second.items()) {
+    if (isIncluded(name.getString())) {
+      target[name] = value;
+    }
+  }
+}
+#endif // ANDROID
+
 void UpdatesRegistry::remove(const Tag tag) {
   react_native_assert(UpdatesRegistryManager::isLockedByCurrentThread());
   removeTag(tag);

package/Common/cpp/reanimated/Fabric/updates/UpdatesRegistry.h

@@ -29,6 +29,8 @@ struct AnimatedPropsEntry {
 };
 using UpdatesBatchAnimatedProps = std::vector<AnimatedPropsEntry>;
 
+using PropNamePredicate = bool (*)(const std::string &);
+
 using RegistryMap = std::unordered_map<Tag, std::pair<ShadowNodeFamily::Shared, folly::dynamic>>;
 
 #ifdef ANDROID
@@ -48,6 +50,9 @@ class UpdatesRegistry {
   virtual bool isEmpty() const;
   folly::dynamic get(Tag tag) const;
   void mergeInto(Tag tag, folly::dynamic &target) const;
+#ifdef ANDROID
+  void mergeInto(Tag tag, folly::dynamic &target, PropNamePredicate isIncluded) const;
+#endif
   void remove(Tag tag);
 
 #ifdef ANDROID

package/Common/cpp/reanimated/Fabric/updates/UpdatesRegistryManager.cpp

@@ -115,6 +115,16 @@ void UpdatesRegistryManager::mergeRegistryProps(const Tag viewTag, folly::dynami
 
 #ifdef ANDROID
 
+void UpdatesRegistryManager::mergeRegistryProps(
+    const Tag viewTag,
+    folly::dynamic &target,
+    const PropNamePredicate isIncluded) {
+  react_native_assert(isLockedByCurrentThread());
+  for (const auto &registry : registries_) {
+    registry->mergeInto(viewTag, target, isIncluded);
+  }
+}
+
 bool UpdatesRegistryManager::hasPropsToRevert() {
   react_native_assert(isLockedByCurrentThread());
   for (auto &registry : registries_) {

package/Common/cpp/reanimated/Fabric/updates/UpdatesRegistryManager.h

@@ -49,6 +49,9 @@ class UpdatesRegistryManager {
   void handleNodeRemovals(const RootShadowNode &rootShadowNode);
   PropsMap collectProps();
   void mergeRegistryProps(Tag viewTag, folly::dynamic &target);
+#ifdef ANDROID
+  void mergeRegistryProps(Tag viewTag, folly::dynamic &target, PropNamePredicate isIncluded);
+#endif
 
 #ifdef ANDROID
   bool hasPropsToRevert();