@react-native-ohos/react-native-reanimated 3.18.2-rc.2 → 3.18.2

package/harmony/reanimated/src/main/cpp/Common/cpp/reanimated/Fabric/PropsRegistry.h

@@ -1,68 +1,68 @@
-#pragma once
-#ifdef RCT_NEW_ARCH_ENABLED
-
-#include <react/renderer/components/root/RootShadowNode.h>
-#include <react/renderer/core/ShadowNode.h>
-
-#include <unordered_map>
-#include <utility>
-
-using namespace facebook;
-using namespace react;
-
-namespace reanimated {
-
-class PropsRegistry {
- public:
-  std::lock_guard<std::mutex> createLock() const;
-  // returns a lock you need to hold when calling any of the methods below
-
-  void update(const ShadowNode::Shared &shadowNode, folly::dynamic &&props);
-
-  void for_each(std::function<void(
-                    const ShadowNodeFamily &family,
-                    const folly::dynamic &props)> callback) const;
-
-  void remove(const Tag tag);
-
-  void pauseReanimatedCommits() {
-    isPaused_ = true;
-  }
-
-  bool shouldReanimatedSkipCommit() {
-    return isPaused_;
-  }
-
-  void unpauseReanimatedCommits() {
-    isPaused_ = false;
-  }
-
-  void pleaseCommitAfterPause() {
-    shouldCommitAfterPause_ = true;
-  }
-
-  bool shouldCommitAfterPause() {
-    return shouldCommitAfterPause_.exchange(false);
-  }
-
-  bool isEmpty() {
-    return map_.empty();
-  }
-
-  void markNodeAsRemovable(const ShadowNode::Shared &shadowNode);
-  void unmarkNodeAsRemovable(Tag viewTag);
-  void handleNodeRemovals(const RootShadowNode &rootShadowNode);
-
- private:
-  std::unordered_map<Tag, std::pair<ShadowNode::Shared, folly::dynamic>> map_;
-  std::unordered_map<Tag, ShadowNode::Shared> removableShadowNodes_;
-
-  mutable std::mutex mutex_; // Protects `map_`.
-
-  std::atomic<bool> isPaused_;
-  std::atomic<bool> shouldCommitAfterPause_;
-};
-
-} // namespace reanimated
-
-#endif // RCT_NEW_ARCH_ENABLED
+#pragma once
+#ifdef RCT_NEW_ARCH_ENABLED
+
+#include <react/renderer/components/root/RootShadowNode.h>
+#include <react/renderer/core/ShadowNode.h>
+
+#include <unordered_map>
+#include <utility>
+
+using namespace facebook;
+using namespace react;
+
+namespace reanimated {
+
+class PropsRegistry {
+ public:
+  std::lock_guard<std::mutex> createLock() const;
+  // returns a lock you need to hold when calling any of the methods below
+
+  void update(const ShadowNode::Shared &shadowNode, folly::dynamic &&props);
+
+  void for_each(std::function<void(
+                    const ShadowNodeFamily &family,
+                    const folly::dynamic &props)> callback) const;
+
+  void remove(const Tag tag);
+
+  void pauseReanimatedCommits() {
+    isPaused_ = true;
+  }
+
+  bool shouldReanimatedSkipCommit() {
+    return isPaused_;
+  }
+
+  void unpauseReanimatedCommits() {
+    isPaused_ = false;
+  }
+
+  void pleaseCommitAfterPause() {
+    shouldCommitAfterPause_ = true;
+  }
+
+  bool shouldCommitAfterPause() {
+    return shouldCommitAfterPause_.exchange(false);
+  }
+
+  bool isEmpty() {
+    return map_.empty();
+  }
+
+  void markNodeAsRemovable(const ShadowNode::Shared &shadowNode);
+  void unmarkNodeAsRemovable(Tag viewTag);
+  void handleNodeRemovals(const RootShadowNode &rootShadowNode);
+
+ private:
+  std::unordered_map<Tag, std::pair<ShadowNode::Shared, folly::dynamic>> map_;
+  std::unordered_map<Tag, ShadowNode::Shared> removableShadowNodes_;
+
+  mutable std::mutex mutex_; // Protects `map_`.
+
+  std::atomic<bool> isPaused_;
+  std::atomic<bool> shouldCommitAfterPause_;
+};
+
+} // namespace reanimated
+
+#endif // RCT_NEW_ARCH_ENABLED

package/harmony/reanimated/src/main/cpp/Common/cpp/reanimated/Fabric/ReanimatedCommitHook.cpp

@@ -1,101 +1,101 @@
-#ifdef RCT_NEW_ARCH_ENABLED
-
-#include <reanimated/Fabric/ReanimatedCommitHook.h>
-#include <reanimated/Fabric/ReanimatedCommitShadowNode.h>
-#include <reanimated/Fabric/ShadowTreeCloner.h>
-
-#include <react/renderer/core/ComponentDescriptor.h>
-
-#include <unordered_map>
-#include <vector>
-
-using namespace facebook::react;
-
-namespace reanimated {
-
-ReanimatedCommitHook::ReanimatedCommitHook(
-    const std::shared_ptr<PropsRegistry> &propsRegistry,
-    const std::shared_ptr<UIManager> &uiManager,
-    const std::shared_ptr<LayoutAnimationsProxy> &layoutAnimationsProxy)
-    : propsRegistry_(propsRegistry),
-      uiManager_(uiManager),
-      layoutAnimationsProxy_(layoutAnimationsProxy) {
-  uiManager_->registerCommitHook(*this);
-}
-
-ReanimatedCommitHook::~ReanimatedCommitHook() noexcept {
-  uiManager_->unregisterCommitHook(*this);
-}
-
-void ReanimatedCommitHook::maybeInitializeLayoutAnimations(
-    SurfaceId surfaceId) {
-  auto lock = std::unique_lock<std::mutex>(mutex_);
-  if (surfaceId > currentMaxSurfaceId_) {
-    // when a new surfaceId is observed we call setMountingOverrideDelegate
-    // for all yet unseen surfaces
-    uiManager_->getShadowTreeRegistry().enumerate(
-        [strongThis = shared_from_this()](
-            const ShadowTree &shadowTree, bool &stop) {
-          // Executed synchronously.
-          if (shadowTree.getSurfaceId() <= strongThis->currentMaxSurfaceId_) {
-            // the set function actually adds our delegate to a list, so we
-            // shouldn't invoke it twice for the same surface
-            return;
-          }
-          shadowTree.getMountingCoordinator()->setMountingOverrideDelegate(
-              strongThis->layoutAnimationsProxy_);
-        });
-    currentMaxSurfaceId_ = surfaceId;
-  }
-}
-
-RootShadowNode::Unshared ReanimatedCommitHook::shadowTreeWillCommit(
-    ShadowTree const &,
-    RootShadowNode::Shared const &,
-    RootShadowNode::Unshared const &newRootShadowNode) noexcept {
-  maybeInitializeLayoutAnimations(newRootShadowNode->getSurfaceId());
-
-  auto reaShadowNode =
-      std::reinterpret_pointer_cast<ReanimatedCommitShadowNode>(
-          newRootShadowNode);
-
-  if (reaShadowNode->hasReanimatedCommitTrait()) {
-    // ShadowTree commited by Reanimated, no need to apply updates from
-    // PropsRegistry
-    reaShadowNode->unsetReanimatedCommitTrait();
-    reaShadowNode->setReanimatedMountTrait();
-    return newRootShadowNode;
-  }
-
-  // ShadowTree not commited by Reanimated, apply updates from PropsRegistry
-  reaShadowNode->unsetReanimatedMountTrait();
-  RootShadowNode::Unshared rootNode = newRootShadowNode;
-  PropsMap propsMap;
-
-  {
-    auto lock = propsRegistry_->createLock();
-
-    propsRegistry_->for_each(
-        [&](const ShadowNodeFamily &family, const folly::dynamic &props) {
-          propsMap[&family].emplace_back(props);
-        });
-
-    rootNode = cloneShadowTreeWithNewProps(*rootNode, propsMap);
-
-    // 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
-    // props will be applied in ReanimatedCommitHook by iterating over
-    // PropsRegistry.
-    // This is very important, since if we didn't pause Reanimated commits,
-    // it could lead to RN commits being delayed until the animation is finished
-    // (very bad).
-    propsRegistry_->pauseReanimatedCommits();
-  }
-
-  return rootNode;
-}
-
-} // namespace reanimated
-
-#endif // RCT_NEW_ARCH_ENABLED
+#ifdef RCT_NEW_ARCH_ENABLED
+
+#include <reanimated/Fabric/ReanimatedCommitHook.h>
+#include <reanimated/Fabric/ReanimatedCommitShadowNode.h>
+#include <reanimated/Fabric/ShadowTreeCloner.h>
+
+#include <react/renderer/core/ComponentDescriptor.h>
+
+#include <unordered_map>
+#include <vector>
+
+using namespace facebook::react;
+
+namespace reanimated {
+
+ReanimatedCommitHook::ReanimatedCommitHook(
+    const std::shared_ptr<PropsRegistry> &propsRegistry,
+    const std::shared_ptr<UIManager> &uiManager,
+    const std::shared_ptr<LayoutAnimationsProxy> &layoutAnimationsProxy)
+    : propsRegistry_(propsRegistry),
+      uiManager_(uiManager),
+      layoutAnimationsProxy_(layoutAnimationsProxy) {
+  uiManager_->registerCommitHook(*this);
+}
+
+ReanimatedCommitHook::~ReanimatedCommitHook() noexcept {
+  uiManager_->unregisterCommitHook(*this);
+}
+
+void ReanimatedCommitHook::maybeInitializeLayoutAnimations(
+    SurfaceId surfaceId) {
+  auto lock = std::unique_lock<std::mutex>(mutex_);
+  if (surfaceId > currentMaxSurfaceId_) {
+    // when a new surfaceId is observed we call setMountingOverrideDelegate
+    // for all yet unseen surfaces
+    uiManager_->getShadowTreeRegistry().enumerate(
+        [strongThis = shared_from_this()](
+            const ShadowTree &shadowTree, bool &stop) {
+          // Executed synchronously.
+          if (shadowTree.getSurfaceId() <= strongThis->currentMaxSurfaceId_) {
+            // the set function actually adds our delegate to a list, so we
+            // shouldn't invoke it twice for the same surface
+            return;
+          }
+          shadowTree.getMountingCoordinator()->setMountingOverrideDelegate(
+              strongThis->layoutAnimationsProxy_);
+        });
+    currentMaxSurfaceId_ = surfaceId;
+  }
+}
+
+RootShadowNode::Unshared ReanimatedCommitHook::shadowTreeWillCommit(
+    ShadowTree const &,
+    RootShadowNode::Shared const &,
+    RootShadowNode::Unshared const &newRootShadowNode) noexcept {
+  maybeInitializeLayoutAnimations(newRootShadowNode->getSurfaceId());
+
+  auto reaShadowNode =
+      std::reinterpret_pointer_cast<ReanimatedCommitShadowNode>(
+          newRootShadowNode);
+
+  if (reaShadowNode->hasReanimatedCommitTrait()) {
+    // ShadowTree commited by Reanimated, no need to apply updates from
+    // PropsRegistry
+    reaShadowNode->unsetReanimatedCommitTrait();
+    reaShadowNode->setReanimatedMountTrait();
+    return newRootShadowNode;
+  }
+
+  // ShadowTree not commited by Reanimated, apply updates from PropsRegistry
+  reaShadowNode->unsetReanimatedMountTrait();
+  RootShadowNode::Unshared rootNode = newRootShadowNode;
+  PropsMap propsMap;
+
+  {
+    auto lock = propsRegistry_->createLock();
+
+    propsRegistry_->for_each(
+        [&](const ShadowNodeFamily &family, const folly::dynamic &props) {
+          propsMap[&family].emplace_back(props);
+        });
+
+    rootNode = cloneShadowTreeWithNewProps(*rootNode, propsMap);
+
+    // 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
+    // props will be applied in ReanimatedCommitHook by iterating over
+    // PropsRegistry.
+    // This is very important, since if we didn't pause Reanimated commits,
+    // it could lead to RN commits being delayed until the animation is finished
+    // (very bad).
+    propsRegistry_->pauseReanimatedCommits();
+  }
+
+  return rootNode;
+}
+
+} // namespace reanimated
+
+#endif // RCT_NEW_ARCH_ENABLED

package/harmony/reanimated/src/main/cpp/Common/cpp/reanimated/Fabric/ReanimatedCommitHook.h

@@ -1,51 +1,51 @@
-#pragma once
-#ifdef RCT_NEW_ARCH_ENABLED
-
-#include <reanimated/Fabric/PropsRegistry.h>
-#include <reanimated/LayoutAnimations/LayoutAnimationsProxy.h>
-
-#include <react/renderer/uimanager/UIManagerCommitHook.h>
-
-#include <memory>
-
-using namespace facebook::react;
-
-namespace reanimated {
-
-class ReanimatedCommitHook
-    : public UIManagerCommitHook,
-      public std::enable_shared_from_this<ReanimatedCommitHook> {
- public:
-  ReanimatedCommitHook(
-      const std::shared_ptr<PropsRegistry> &propsRegistry,
-      const std::shared_ptr<UIManager> &uiManager,
-      const std::shared_ptr<LayoutAnimationsProxy> &layoutAnimationsProxy);
-
-  ~ReanimatedCommitHook() noexcept override;
-
-  void commitHookWasRegistered(UIManager const &) noexcept override {}
-
-  void commitHookWasUnregistered(UIManager const &) noexcept override {}
-
-  void maybeInitializeLayoutAnimations(SurfaceId surfaceId);
-
-  RootShadowNode::Unshared shadowTreeWillCommit(
-      ShadowTree const &shadowTree,
-      RootShadowNode::Shared const &oldRootShadowNode,
-      RootShadowNode::Unshared const &newRootShadowNode) noexcept override;
-
- private:
-  std::shared_ptr<PropsRegistry> propsRegistry_;
-
-  std::shared_ptr<UIManager> uiManager_;
-
-  std::shared_ptr<LayoutAnimationsProxy> layoutAnimationsProxy_;
-
-  SurfaceId currentMaxSurfaceId_ = -1;
-
-  std::mutex mutex_; // Protects `currentMaxSurfaceId_`.
-};
-
-} // namespace reanimated
-
-#endif // RCT_NEW_ARCH_ENABLED
+#pragma once
+#ifdef RCT_NEW_ARCH_ENABLED
+
+#include <reanimated/Fabric/PropsRegistry.h>
+#include <reanimated/LayoutAnimations/LayoutAnimationsProxy.h>
+
+#include <react/renderer/uimanager/UIManagerCommitHook.h>
+
+#include <memory>
+
+using namespace facebook::react;
+
+namespace reanimated {
+
+class ReanimatedCommitHook
+    : public UIManagerCommitHook,
+      public std::enable_shared_from_this<ReanimatedCommitHook> {
+ public:
+  ReanimatedCommitHook(
+      const std::shared_ptr<PropsRegistry> &propsRegistry,
+      const std::shared_ptr<UIManager> &uiManager,
+      const std::shared_ptr<LayoutAnimationsProxy> &layoutAnimationsProxy);
+
+  ~ReanimatedCommitHook() noexcept override;
+
+  void commitHookWasRegistered(UIManager const &) noexcept override {}
+
+  void commitHookWasUnregistered(UIManager const &) noexcept override {}
+
+  void maybeInitializeLayoutAnimations(SurfaceId surfaceId);
+
+  RootShadowNode::Unshared shadowTreeWillCommit(
+      ShadowTree const &shadowTree,
+      RootShadowNode::Shared const &oldRootShadowNode,
+      RootShadowNode::Unshared const &newRootShadowNode) noexcept override;
+
+ private:
+  std::shared_ptr<PropsRegistry> propsRegistry_;
+
+  std::shared_ptr<UIManager> uiManager_;
+
+  std::shared_ptr<LayoutAnimationsProxy> layoutAnimationsProxy_;
+
+  SurfaceId currentMaxSurfaceId_ = -1;
+
+  std::mutex mutex_; // Protects `currentMaxSurfaceId_`.
+};
+
+} // namespace reanimated
+
+#endif // RCT_NEW_ARCH_ENABLED

package/harmony/reanimated/src/main/cpp/Common/cpp/reanimated/Fabric/ReanimatedCommitShadowNode.h

@@ -1,49 +1,49 @@
-#pragma once
-#ifdef RCT_NEW_ARCH_ENABLED
-
-#include <react/renderer/core/ShadowNode.h>
-
-using namespace facebook::react;
-
-namespace reanimated {
-
-// We use this trait to mark that a commit was created by Reanimated.
-// Traits are copied when nodes are cloned, so this information
-// won't be lost unless someone explicitly overrides it.
-// We need this information to skip unnecessary updates in
-// the commit hook.
-// Currently RN traits go up to 10, so hopefully
-// the arbitrarily chosen numbers 27 and 28 will be safe :)
-
-// We have to use 2 traits, because we want to distinguish reanimated
-// commits both in the commit hook and mount hook. If we only had one trait
-// and didn't remove it in the commit hook, then any node that would clone
-// this node would also have our commit trait, rendering this trait useless.
-constexpr ShadowNodeTraits::Trait ReanimatedCommitTrait{1 << 27};
-constexpr ShadowNodeTraits::Trait ReanimatedMountTrait{1 << 28};
-
-class ReanimatedCommitShadowNode : public ShadowNode {
- public:
-  inline void setReanimatedCommitTrait() {
-    traits_.set(ReanimatedCommitTrait);
-  }
-  inline void unsetReanimatedCommitTrait() {
-    traits_.unset(ReanimatedCommitTrait);
-  }
-  inline bool hasReanimatedCommitTrait() {
-    return traits_.check(ReanimatedCommitTrait);
-  }
-  inline void setReanimatedMountTrait() {
-    traits_.set(ReanimatedMountTrait);
-  }
-  inline void unsetReanimatedMountTrait() {
-    traits_.unset(ReanimatedMountTrait);
-  }
-  inline bool hasReanimatedMountTrait() {
-    return traits_.check(ReanimatedMountTrait);
-  }
-};
-
-} // namespace reanimated
-
-#endif // RCT_NEW_ARCH_ENABLED
+#pragma once
+#ifdef RCT_NEW_ARCH_ENABLED
+
+#include <react/renderer/core/ShadowNode.h>
+
+using namespace facebook::react;
+
+namespace reanimated {
+
+// We use this trait to mark that a commit was created by Reanimated.
+// Traits are copied when nodes are cloned, so this information
+// won't be lost unless someone explicitly overrides it.
+// We need this information to skip unnecessary updates in
+// the commit hook.
+// Currently RN traits go up to 10, so hopefully
+// the arbitrarily chosen numbers 27 and 28 will be safe :)
+
+// We have to use 2 traits, because we want to distinguish reanimated
+// commits both in the commit hook and mount hook. If we only had one trait
+// and didn't remove it in the commit hook, then any node that would clone
+// this node would also have our commit trait, rendering this trait useless.
+constexpr ShadowNodeTraits::Trait ReanimatedCommitTrait{1 << 27};
+constexpr ShadowNodeTraits::Trait ReanimatedMountTrait{1 << 28};
+
+class ReanimatedCommitShadowNode : public ShadowNode {
+ public:
+  inline void setReanimatedCommitTrait() {
+    traits_.set(ReanimatedCommitTrait);
+  }
+  inline void unsetReanimatedCommitTrait() {
+    traits_.unset(ReanimatedCommitTrait);
+  }
+  inline bool hasReanimatedCommitTrait() {
+    return traits_.check(ReanimatedCommitTrait);
+  }
+  inline void setReanimatedMountTrait() {
+    traits_.set(ReanimatedMountTrait);
+  }
+  inline void unsetReanimatedMountTrait() {
+    traits_.unset(ReanimatedMountTrait);
+  }
+  inline bool hasReanimatedMountTrait() {
+    return traits_.check(ReanimatedMountTrait);
+  }
+};
+
+} // namespace reanimated
+
+#endif // RCT_NEW_ARCH_ENABLED