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

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

@@ -1,95 +1,104 @@
-#ifdef RCT_NEW_ARCH_ENABLED
-
-#include <reanimated/Fabric/ShadowTreeCloner.h>
-
-#include <ranges>
-#include <utility>
-
-namespace reanimated {
-
-Props::Shared mergeProps(
-    const ShadowNode &shadowNode,
-    const PropsMap &propsMap,
-    const ShadowNodeFamily &family) {
-  const auto it = propsMap.find(&family);
-
-  if (it == propsMap.end()) {
-    return ShadowNodeFragment::propsPlaceholder();
-  }
-
-  PropsParserContext propsParserContext{
-      shadowNode.getSurfaceId(), *shadowNode.getContextContainer()};
-  const auto &propsVector = it->second;
-  auto newProps = shadowNode.getProps();
-
-#ifdef ANDROID
-  if (propsVector.size() > 1) {
-    folly::dynamic newPropsDynamic = folly::dynamic::object;
-    for (const auto &props : propsVector) {
-      newPropsDynamic = folly::dynamic::merge(
-          props.operator folly::dynamic(), newPropsDynamic);
-    }
-    return shadowNode.getComponentDescriptor().cloneProps(
-        propsParserContext, newProps, RawProps(newPropsDynamic));
-  }
-#endif
-
-  for (const auto &props : propsVector) {
-    newProps = shadowNode.getComponentDescriptor().cloneProps(
-        propsParserContext, newProps, RawProps(props));
-  }
-
-  return newProps;
-}
-
-ShadowNode::Unshared cloneShadowTreeWithNewPropsRecursive(
-    const ShadowNode &shadowNode,
-    const ChildrenMap &childrenMap,
-    const PropsMap &propsMap) {
-  const auto family = &shadowNode.getFamily();
-  const auto affectedChildrenIt = childrenMap.find(family);
-  auto children = shadowNode.getChildren();
-
-  if (affectedChildrenIt != childrenMap.end()) {
-    for (const auto index : affectedChildrenIt->second) {
-      children[index] = cloneShadowTreeWithNewPropsRecursive(
-          *children[index], childrenMap, propsMap);
-    }
-  }
-
-  return shadowNode.clone(
-      {mergeProps(shadowNode, propsMap, *family),
-       std::make_shared<ShadowNode::ListOfShared>(children),
-       shadowNode.getState()});
-}
-
-RootShadowNode::Unshared cloneShadowTreeWithNewProps(
-    const RootShadowNode &oldRootNode,
-    const PropsMap &propsMap) {
-  ChildrenMap childrenMap;
-
-  for (auto &[family, _] : propsMap) {
-    const auto ancestors = family->getAncestors(oldRootNode);
-
-    for (const auto &[parentNode, index] :
-         std::ranges::reverse_view(ancestors)) {
-      const auto parentFamily = &parentNode.get().getFamily();
-      auto &affectedChildren = childrenMap[parentFamily];
-
-      if (affectedChildren.contains(index)) {
-        continue;
-      }
-
-      affectedChildren.insert(index);
-    }
-  }
-
-  // This cast is safe, because this function returns a clone
-  // of the oldRootNode, which is an instance of RootShadowNode
-  return std::static_pointer_cast<RootShadowNode>(
-      cloneShadowTreeWithNewPropsRecursive(oldRootNode, childrenMap, propsMap));
-}
-
-} // namespace reanimated
-
-#endif // RCT_NEW_ARCH_ENABLED
+#include <reanimated/Fabric/ShadowTreeCloner.h>
+#include <reanimated/Tools/ReanimatedSystraceSection.h>
+
+#include <memory>
+#include <ranges>
+#include <utility>
+
+namespace reanimated {
+
+Props::Shared mergeProps(const ShadowNode &shadowNode, const PropsMap &propsMap, const ShadowNodeFamily &family) {
+  ReanimatedSystraceSection s("ShadowTreeCloner::mergeProps");
+
+  const auto it = propsMap.find(&family);
+
+  if (it == propsMap.end()) {
+    return ShadowNodeFragment::propsPlaceholder();
+  }
+
+  PropsParserContext propsParserContext{shadowNode.getSurfaceId(), *shadowNode.getContextContainer()};
+  const auto &propsVector = it->second;
+  auto newProps = shadowNode.getProps();
+
+#ifdef ANDROID
+  if (propsVector.size() > 1) {
+    folly::dynamic newPropsDynamic = folly::dynamic::object;
+    for (const auto &props : propsVector) {
+      newPropsDynamic = folly::dynamic::merge(props.operator folly::dynamic(), newPropsDynamic);
+    }
+    return shadowNode.getComponentDescriptor().cloneProps(propsParserContext, newProps, RawProps(newPropsDynamic));
+  }
+#endif
+
+  for (const auto &props : propsVector) {
+    newProps = shadowNode.getComponentDescriptor().cloneProps(propsParserContext, newProps, RawProps(props));
+  }
+
+  return newProps;
+}
+
+std::shared_ptr<ShadowNode> cloneShadowTreeWithNewPropsRecursive(
+    const ShadowNode &shadowNode,
+    const ChildrenMap &childrenMap,
+    const PropsMap &propsMap) {
+  const auto family = &shadowNode.getFamily();
+  const auto affectedChildrenIt = childrenMap.find(family);
+  auto children = shadowNode.getChildren();
+
+  if (affectedChildrenIt != childrenMap.end()) {
+    for (const auto index : affectedChildrenIt->second) {
+      children[index] = cloneShadowTreeWithNewPropsRecursive(*children[index], childrenMap, propsMap);
+    }
+  }
+
+  return shadowNode.clone(
+      {mergeProps(shadowNode, propsMap, *family),
+       std::make_shared<std::vector<std::shared_ptr<const ShadowNode>>>(children),
+       shadowNode.getState(),
+       false});
+}
+
+RootShadowNode::Unshared cloneShadowTreeWithNewProps(const RootShadowNode &oldRootNode, const PropsMap &propsMap) {
+  ReanimatedSystraceSection s("ShadowTreeCloner::cloneShadowTreeWithNewProps");
+
+  ChildrenMap childrenMap;
+
+  {
+    ReanimatedSystraceSection s("ShadowTreeCloner::prepareChildrenMap");
+
+    for (auto &[family, _] : propsMap) {
+      const auto ancestors = family->getAncestors(oldRootNode);
+
+//      for (const auto &[parentNode, index] : std::ranges::reverse_view(ancestors)) {
+//        const auto parentFamily = &parentNode.get().getFamily();
+//        auto &affectedChildren = childrenMap[parentFamily];
+//
+//        if (affectedChildren.contains(index)) {
+//          continue;
+//        }
+//
+//        affectedChildren.insert(index);
+//      }
+       //TODO     
+       for (auto it = ancestors.rbegin(); it != ancestors.rend(); ++it) {
+          const auto &[parentNode, index] = *it;
+          
+          const auto parentFamily = &parentNode.get().getFamily();
+          auto &affectedChildren = childrenMap[parentFamily];
+        
+          if (affectedChildren.find(index) != affectedChildren.end()) {
+            continue;
+          }
+        
+          affectedChildren.insert(index);
+       }          
+    }
+  }
+
+  // This cast is safe, because this function returns a clone
+  // of the oldRootNode, which is an instance of RootShadowNode
+  return std::static_pointer_cast<RootShadowNode>(
+      cloneShadowTreeWithNewPropsRecursive(oldRootNode, childrenMap, propsMap));
+}
+
+} // namespace reanimated

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

@@ -1,29 +1,22 @@
-#pragma once
-#ifdef RCT_NEW_ARCH_ENABLED
-
-#include <react/renderer/core/PropsParserContext.h>
-#include <react/renderer/uimanager/UIManager.h>
-
-#include <memory>
-#include <type_traits>
-#include <unordered_map>
-#include <unordered_set>
-#include <vector>
-
-using namespace facebook;
-using namespace react;
-
-namespace reanimated {
-
-using PropsMap =
-    std::unordered_map<const ShadowNodeFamily *, std::vector<RawProps>>;
-using ChildrenMap =
-    std::unordered_map<const ShadowNodeFamily *, std::unordered_set<int>>;
-
-RootShadowNode::Unshared cloneShadowTreeWithNewProps(
-    const RootShadowNode &oldRootNode,
-    const PropsMap &propsMap);
-
-} // namespace reanimated
-
-#endif // RCT_NEW_ARCH_ENABLED
+#pragma once
+
+#include <react/renderer/core/PropsParserContext.h>
+#include <react/renderer/uimanager/UIManager.h>
+
+#include <memory>
+#include <type_traits>
+#include <unordered_map>
+#include <unordered_set>
+#include <vector>
+
+using namespace facebook;
+using namespace react;
+
+namespace reanimated {
+
+using PropsMap = std::unordered_map<const ShadowNodeFamily *, std::vector<RawProps>>;
+using ChildrenMap = std::unordered_map<const ShadowNodeFamily *, std::unordered_set<int>>;
+
+RootShadowNode::Unshared cloneShadowTreeWithNewProps(const RootShadowNode &oldRootNode, const PropsMap &propsMap);
+
+} // namespace reanimated

package/harmony/reanimated/src/main/cpp/Common/cpp/reanimated/Fabric/updates/AnimatedPropsRegistry.cpp

@@ -0,0 +1,72 @@
+#include <reanimated/Fabric/updates/AnimatedPropsRegistry.h>
+#include <reanimated/Tools/FeatureFlags.h>
+
+#include <memory>
+#include <utility>
+
+namespace reanimated {
+
+#if REACT_NATIVE_MINOR_VERSION >= 81
+static inline std::shared_ptr<const ShadowNode> shadowNodeFromValue(
+    jsi::Runtime &rt,
+    const jsi::Value &shadowNodeWrapper) {
+  return Bridging<std::shared_ptr<const ShadowNode>>::fromJs(rt, shadowNodeWrapper);
+}
+#endif
+
+void AnimatedPropsRegistry::update(jsi::Runtime &rt, const jsi::Value &operations, const double timestamp) {
+  auto operationsArray = operations.asObject(rt).asArray(rt);
+
+  for (size_t i = 0, length = operationsArray.size(rt); i < length; ++i) {
+    auto item = operationsArray.getValueAtIndex(rt, i).asObject(rt);
+    auto shadowNodeWrapper = item.getProperty(rt, "shadowNodeWrapper");
+    auto shadowNode = shadowNodeFromValue(rt, shadowNodeWrapper);
+
+    const jsi::Value &updates = item.getProperty(rt, "updates");
+    addUpdatesToBatch(shadowNode, jsi::dynamicFromValue(rt, updates));
+
+    if constexpr (StaticFeatureFlags::getFlag("FORCE_REACT_RENDER_FOR_SETTLED_ANIMATIONS")) {
+      timestampMap_[shadowNode->getTag()] = timestamp;
+    }
+  }
+}
+
+void AnimatedPropsRegistry::remove(const Tag tag) {
+  updatesRegistry_.erase(tag);
+}
+
+jsi::Value AnimatedPropsRegistry::getUpdatesOlderThanTimestamp(jsi::Runtime &rt, const double timestamp) {
+  std::vector<std::pair<Tag, std::reference_wrapper<const folly::dynamic>>> updates;
+
+  for (const auto &[viewTag, pair] : updatesRegistry_) {
+    if (timestampMap_.at(viewTag) < timestamp) {
+      updates.emplace_back(viewTag, std::cref(pair.second));
+    }
+  }
+
+  const jsi::Array array(rt, updates.size());
+  size_t i = 0;
+  for (const auto &[viewTag, styleProps] : updates) {
+    const jsi::Object item(rt);
+    item.setProperty(rt, "viewTag", viewTag);
+    item.setProperty(rt, "styleProps", jsi::valueFromDynamic(rt, styleProps.get()));
+    array.setValueAtIndex(rt, i++, item);
+  }
+
+  return jsi::Value(rt, array);
+}
+
+void AnimatedPropsRegistry::removeUpdatesOlderThanTimestamp(const double timestamp) {
+  for (auto it = timestampMap_.begin(); it != timestampMap_.end();) {
+    const auto viewTag = it->first;
+    const auto viewTimestamp = it->second;
+    if (viewTimestamp < timestamp) {
+      it = timestampMap_.erase(it);
+      updatesRegistry_.erase(viewTag);
+    } else {
+      it++;
+    }
+  }
+}
+
+} // namespace reanimated

package/harmony/reanimated/src/main/cpp/Common/cpp/reanimated/Fabric/updates/AnimatedPropsRegistry.h

@@ -0,0 +1,25 @@
+#pragma once
+
+#include <reanimated/Fabric/updates/UpdatesRegistry.h>
+
+#include <react/renderer/uimanager/UIManager.h>
+
+#include <memory>
+#include <string>
+#include <unordered_map>
+#include <vector>
+
+namespace reanimated {
+
+class AnimatedPropsRegistry : public UpdatesRegistry {
+ public:
+  void update(jsi::Runtime &rt, const jsi::Value &operations, double timestamp);
+  void remove(Tag tag) override;
+  jsi::Value getUpdatesOlderThanTimestamp(jsi::Runtime &rt, double timestamp);
+  void removeUpdatesOlderThanTimestamp(double timestamp);
+
+ private:
+  std::unordered_map<Tag, double> timestampMap_; // viewTag -> timestamp, protected by `mutex_`
+};
+
+} // namespace reanimated

package/harmony/reanimated/src/main/cpp/Common/cpp/reanimated/Fabric/updates/UpdatesRegistry.cpp

@@ -0,0 +1,160 @@
+#include <reanimated/Fabric/updates/UpdatesRegistry.h>
+
+#include <memory>
+#include <string>
+#include <unordered_set>
+#include <utility>
+#include <vector>
+
+namespace reanimated {
+
+std::lock_guard<std::mutex> UpdatesRegistry::lock() const {
+  return std::lock_guard<std::mutex>{mutex_};
+}
+
+bool UpdatesRegistry::isEmpty() const {
+  return updatesRegistry_.empty();
+}
+
+folly::dynamic UpdatesRegistry::get(const Tag tag) const {
+  std::lock_guard<std::mutex> lock{mutex_};
+
+  auto it = updatesRegistry_.find(tag);
+  if (it == updatesRegistry_.cend()) {
+    return nullptr;
+  }
+  return it->second.second;
+}
+
+void UpdatesRegistry::flushUpdates(UpdatesBatch &updatesBatch) {
+  auto copiedUpdatesBatch = std::move(updatesBatch_);
+  updatesBatch_.clear();
+
+  // Store all updates in the registry for later use in the commit hook
+  flushUpdatesToRegistry(copiedUpdatesBatch);
+  // Flush the updates to the updatesBatch used to apply current changes
+  for (auto &[shadowNode, props] : copiedUpdatesBatch) {
+    updatesBatch.emplace_back(shadowNode, std::move(props));
+  }
+}
+
+void UpdatesRegistry::collectProps(PropsMap &propsMap) {
+  std::lock_guard<std::mutex> lock{mutex_};
+
+  auto copiedRegistry = updatesRegistry_;
+  for (const auto &[tag, pair] : copiedRegistry) {
+    const auto &[shadowNode, props] = pair;
+    auto &family = shadowNode->getFamily();
+    auto it = propsMap.find(&family);
+
+    if (it == propsMap.cend()) {
+      auto propsVector = std::vector<RawProps>{};
+      propsVector.emplace_back(RawProps(props));
+      propsMap.emplace(&family, propsVector);
+    } else {
+      it->second.push_back(RawProps(props));
+    }
+  }
+}
+
+void UpdatesRegistry::addUpdatesToBatch(
+    const std::shared_ptr<const ShadowNode> &shadowNode,
+    const folly::dynamic &props) {
+  updatesBatch_.emplace_back(shadowNode, props);
+}
+
+void UpdatesRegistry::setInUpdatesRegistry(
+    const std::shared_ptr<const ShadowNode> &shadowNode,
+    const folly::dynamic &props) {
+  const auto tag = shadowNode->getTag();
+#ifdef ANDROID
+  updatePropsToRevert(tag, &props);
+#endif
+  updatesRegistry_[tag] = std::make_pair(shadowNode, props);
+}
+
+folly::dynamic UpdatesRegistry::getUpdatesFromRegistry(const Tag tag) const {
+  auto it = updatesRegistry_.find(tag);
+  if (it == updatesRegistry_.cend()) {
+    return folly::dynamic();
+  }
+  return it->second.second;
+}
+
+void UpdatesRegistry::removeFromUpdatesRegistry(const Tag tag) {
+#ifdef ANDROID
+  updatePropsToRevert(tag);
+#endif
+  updatesRegistry_.erase(tag);
+}
+
+void UpdatesRegistry::flushUpdatesToRegistry(const UpdatesBatch &updatesBatch) {
+  for (auto &[shadowNode, props] : updatesBatch) {
+    const auto tag = shadowNode->getTag();
+    auto it = updatesRegistry_.find(tag);
+
+    if (it == updatesRegistry_.cend()) {
+      updatesRegistry_[tag] = std::make_pair(shadowNode, props);
+    } else {
+      it->second.second.update(props);
+    }
+  }
+}
+
+#ifdef ANDROID
+
+bool UpdatesRegistry::hasPropsToRevert() const {
+  return !propsToRevertMap_.empty();
+}
+
+void UpdatesRegistry::collectPropsToRevert(PropsToRevertMap &propsToRevertMap) {
+  std::lock_guard<std::mutex> lock{mutex_};
+
+  for (const auto &[tag, pair] : propsToRevertMap_) {
+    const auto &[shadowNode, props] = pair;
+    const auto it = propsToRevertMap.find(tag);
+    if (it == propsToRevertMap.end()) {
+      propsToRevertMap[tag] = {shadowNode, props};
+    } else {
+      it->second.props.insert(props.begin(), props.end());
+    }
+  }
+
+  propsToRevertMap_.clear();
+}
+
+void UpdatesRegistry::updatePropsToRevert(const Tag tag, const folly::dynamic *newProps) {
+  auto it = updatesRegistry_.find(tag);
+  if (it == updatesRegistry_.end()) {
+    return;
+  }
+
+  const auto &shadowNode = it->second.first;
+  const auto &registryProps = it->second.second;
+  if (propsToRevertMap_.find(tag) == propsToRevertMap_.end()) {
+    propsToRevertMap_[tag] = {shadowNode, std::unordered_set<std::string>()};
+  }
+
+  if (newProps == nullptr) {
+    // If newProps is not provided, revert all props from registry
+    for (const auto &propName : registryProps.keys()) {
+      propsToRevertMap_[tag].props.emplace(propName.asString());
+    }
+  } else {
+    // If newProps is provided, revert only props that are in registry but not
+    // in newProps
+    for (const auto &propName : registryProps.keys()) {
+      if (newProps->find(propName) == newProps->items().end()) {
+        propsToRevertMap_[tag].props.emplace(propName.asString());
+      }
+    }
+  }
+
+  if (propsToRevertMap_[tag].props.empty()) {
+    propsToRevertMap_.erase(tag);
+  }
+}
+
+#endif
+
+} // namespace reanimated

package/harmony/reanimated/src/main/cpp/Common/cpp/reanimated/Fabric/updates/UpdatesRegistry.h

@@ -0,0 +1,71 @@
+#pragma once
+
+#include <reanimated/Fabric/ShadowTreeCloner.h>
+
+#include <react/renderer/core/ShadowNode.h>
+
+#include <jsi/jsi.h>
+#include <memory>
+#include <string>
+#include <unordered_map>
+#include <unordered_set>
+#include <utility>
+#include <vector>
+
+namespace reanimated {
+
+using namespace facebook;
+using namespace react;
+
+using UpdatesBatch = std::vector<std::pair<std::shared_ptr<const ShadowNode>, folly::dynamic>>;
+using RegistryMap = std::unordered_map<Tag, std::pair<std::shared_ptr<const ShadowNode>, folly::dynamic>>;
+
+#ifdef ANDROID
+struct PropsToRevert {
+  std::shared_ptr<const ShadowNode> shadowNode;
+  std::unordered_set<std::string> props;
+};
+
+using PropsToRevertMap = std::unordered_map<Tag, PropsToRevert>;
+#endif
+
+class UpdatesRegistry {
+ public:
+  virtual ~UpdatesRegistry() {}
+
+  std::lock_guard<std::mutex> lock() const;
+
+  virtual bool isEmpty() const;
+  folly::dynamic get(Tag tag) const;
+  virtual void remove(Tag tag) = 0;
+
+#ifdef ANDROID
+  bool hasPropsToRevert() const;
+  void collectPropsToRevert(PropsToRevertMap &propsToRevertMap);
+#endif
+
+  void flushUpdates(UpdatesBatch &updatesBatch);
+  void collectProps(PropsMap &propsMap);
+
+ protected:
+  mutable std::mutex mutex_;
+  RegistryMap updatesRegistry_;
+
+  void addUpdatesToBatch(const std::shared_ptr<const ShadowNode> &shadowNode, const folly::dynamic &props);
+  folly::dynamic getUpdatesFromRegistry(const Tag tag) const;
+  void setInUpdatesRegistry(const std::shared_ptr<const ShadowNode> &shadowNode, const folly::dynamic &props);
+  void removeFromUpdatesRegistry(Tag tag);
+
+ private:
+  UpdatesBatch updatesBatch_;
+
+  void flushUpdatesToRegistry(const UpdatesBatch &updatesBatch);
+
+#ifdef ANDROID
+  PropsToRevertMap propsToRevertMap_;
+
+  void updatePropsToRevert(Tag tag, const folly::dynamic *newProps = nullptr);
+#endif
+};
+
+} // namespace reanimated