@react-native-ohos/react-native-reanimated 4.0.0-rc.1 → 4.0.2-beta.1

package/harmony/reanimated/src/main/cpp/Common/cpp/reanimated/CSS/utils/props.cpp

@@ -1,149 +1,149 @@
-#include <reanimated/CSS/utils/props.h>
-
-#include <string>
-#include <utility>
-
-namespace reanimated::css {
-
-bool isDiscreteProperty(const std::string &propName, const std::string &componentName) {
-  const auto &interpolators = getComponentInterpolators(componentName);
-  const auto it = interpolators.find(propName);
-  if (it == interpolators.end()) {
-    return false;
-  }
-  return it->second->isDiscreteProperty();
-}
-
-bool areArraysDifferentRecursive(const folly::dynamic &oldArray, const folly::dynamic &newArray) {
-  if (oldArray.size() != newArray.size()) {
-    return true;
-  }
-
-  for (size_t i = 0; i < oldArray.size(); i++) {
-    const auto [oldChangedProp, newChangedProp] = getChangedPropsRecursive(oldArray[i], newArray[i]);
-
-    if (!oldChangedProp.isNull() || !newChangedProp.isNull()) {
-      return true;
-    }
-  }
-
-  return false;
-}
-
-std::pair<folly::dynamic, folly::dynamic> getChangedPropsRecursive(
-    const folly::dynamic &oldProp,
-    const folly::dynamic &newProp) {
-  if (!oldProp.isObject() || !newProp.isObject()) {
-    // Primitive values comparison
-    if (oldProp != newProp) {
-      return {oldProp, newProp};
-    }
-    return {folly::dynamic(), folly::dynamic()};
-  }
-
-  if (oldProp.isArray() && newProp.isArray()) {
-    // Arrays comparison
-    if (areArraysDifferentRecursive(oldProp, newProp)) {
-      return {oldProp, newProp};
-    }
-    return {folly::dynamic(), folly::dynamic()};
-  }
-
-  folly::dynamic oldResult = folly::dynamic::object;
-  folly::dynamic newResult = folly::dynamic::object;
-  bool oldHasChanges = false;
-  bool newHasChanges = false;
-
-  // Check for removed properties
-  for (const auto &item : oldProp.items()) {
-    const auto &propName = item.first.asString();
-    if (!newProp.count(propName)) {
-      const auto &oldValue = item.second;
-      oldResult[propName] = oldValue;
-      oldHasChanges = true;
-    }
-  }
-
-  // Check for new and changed properties
-  for (const auto &item : newProp.items()) {
-    const auto &propName = item.first.asString();
-    const auto &newValue = item.second;
-
-    if (oldProp.count(propName)) {
-      const auto &oldValue = oldProp[propName];
-      auto [oldChangedProp, newChangedProp] = getChangedPropsRecursive(oldValue, newValue);
-
-      if (!oldChangedProp.isNull() && !newChangedProp.isNull()) {
-        oldResult[propName] = std::move(oldChangedProp);
-        newResult[propName] = std::move(newChangedProp);
-        oldHasChanges = true;
-        newHasChanges = true;
-      }
-    } else {
-      newResult[propName] = newValue;
-      newHasChanges = true;
-    }
-  }
-
-  return {
-      oldHasChanges ? std::move(oldResult) : folly::dynamic(), newHasChanges ? std::move(newResult) : folly::dynamic()};
-}
-
-std::pair<folly::dynamic, folly::dynamic>
-getChangedValueForProp(const folly::dynamic &oldObject, const folly::dynamic &newObject, const std::string &propName) {
-  const bool oldHasProperty = oldObject.count(propName);
-  const bool newHasProperty = newObject.count(propName);
-
-  if (oldHasProperty && newHasProperty) {
-    const auto &oldVal = oldObject[propName];
-    const auto &newVal = newObject[propName];
-
-    if (oldVal.isObject() && newVal.isObject()) {
-      return getChangedPropsRecursive(oldVal, newVal);
-    } else if (oldVal != newVal) {
-      return {oldVal, newVal};
-    }
-
-    return {folly::dynamic(), folly::dynamic()};
-  }
-
-  if (oldHasProperty) {
-    const auto &oldVal = oldObject[propName];
-    return {oldVal, folly::dynamic()};
-  } else if (newHasProperty) {
-    const auto &newVal = newObject[propName];
-    return {folly::dynamic(), newVal};
-  }
-
-  return {folly::dynamic(), folly::dynamic()};
-}
-
-ChangedProps getChangedProps(
-    const folly::dynamic &oldProps,
-    const folly::dynamic &newProps,
-    const PropertyNames &allowedProperties) {
-  folly::dynamic oldResult = folly::dynamic::object;
-  folly::dynamic newResult = folly::dynamic::object;
-  PropertyNames changedPropertyNames;
-
-  for (const auto &propName : allowedProperties) {
-    auto [oldChangedProp, newChangedProp] = getChangedValueForProp(oldProps, newProps, propName);
-
-    const auto hasOldChangedProp = !oldChangedProp.isNull();
-    const auto hasNewChangedProp = !newChangedProp.isNull();
-
-    if (hasOldChangedProp) {
-      oldResult[propName] = std::move(oldChangedProp);
-    }
-    if (hasNewChangedProp) {
-      newResult[propName] = std::move(newChangedProp);
-    }
-    if (hasOldChangedProp || hasNewChangedProp) {
-      changedPropertyNames.push_back(propName);
-    }
-  }
-
-  return {std::move(oldResult), std::move(newResult), std::move(changedPropertyNames)};
-}
-
-} // namespace reanimated::css
+#include <reanimated/CSS/utils/props.h>
+
+#include <string>
+#include <utility>
+
+namespace reanimated::css {
+
+bool isDiscreteProperty(const std::string &propName, const std::string &componentName) {
+  const auto &interpolators = getComponentInterpolators(componentName);
+  const auto it = interpolators.find(propName);
+  if (it == interpolators.end()) {
+    return false;
+  }
+  return it->second->isDiscreteProperty();
+}
+
+bool areArraysDifferentRecursive(const folly::dynamic &oldArray, const folly::dynamic &newArray) {
+  if (oldArray.size() != newArray.size()) {
+    return true;
+  }
+
+  for (size_t i = 0; i < oldArray.size(); i++) {
+    const auto [oldChangedProp, newChangedProp] = getChangedPropsRecursive(oldArray[i], newArray[i]);
+
+    if (!oldChangedProp.isNull() || !newChangedProp.isNull()) {
+      return true;
+    }
+  }
+
+  return false;
+}
+
+std::pair<folly::dynamic, folly::dynamic> getChangedPropsRecursive(
+    const folly::dynamic &oldProp,
+    const folly::dynamic &newProp) {
+  if (!oldProp.isObject() || !newProp.isObject()) {
+    // Primitive values comparison
+    if (oldProp != newProp) {
+      return {oldProp, newProp};
+    }
+    return {folly::dynamic(), folly::dynamic()};
+  }
+
+  if (oldProp.isArray() && newProp.isArray()) {
+    // Arrays comparison
+    if (areArraysDifferentRecursive(oldProp, newProp)) {
+      return {oldProp, newProp};
+    }
+    return {folly::dynamic(), folly::dynamic()};
+  }
+
+  folly::dynamic oldResult = folly::dynamic::object;
+  folly::dynamic newResult = folly::dynamic::object;
+  bool oldHasChanges = false;
+  bool newHasChanges = false;
+
+  // Check for removed properties
+  for (const auto &item : oldProp.items()) {
+    const auto &propName = item.first.asString();
+    if (!newProp.count(propName)) {
+      const auto &oldValue = item.second;
+      oldResult[propName] = oldValue;
+      oldHasChanges = true;
+    }
+  }
+
+  // Check for new and changed properties
+  for (const auto &item : newProp.items()) {
+    const auto &propName = item.first.asString();
+    const auto &newValue = item.second;
+
+    if (oldProp.count(propName)) {
+      const auto &oldValue = oldProp[propName];
+      auto [oldChangedProp, newChangedProp] = getChangedPropsRecursive(oldValue, newValue);
+
+      if (!oldChangedProp.isNull() && !newChangedProp.isNull()) {
+        oldResult[propName] = std::move(oldChangedProp);
+        newResult[propName] = std::move(newChangedProp);
+        oldHasChanges = true;
+        newHasChanges = true;
+      }
+    } else {
+      newResult[propName] = newValue;
+      newHasChanges = true;
+    }
+  }
+
+  return {
+      oldHasChanges ? std::move(oldResult) : folly::dynamic(), newHasChanges ? std::move(newResult) : folly::dynamic()};
+}
+
+std::pair<folly::dynamic, folly::dynamic>
+getChangedValueForProp(const folly::dynamic &oldObject, const folly::dynamic &newObject, const std::string &propName) {
+  const bool oldHasProperty = oldObject.count(propName);
+  const bool newHasProperty = newObject.count(propName);
+
+  if (oldHasProperty && newHasProperty) {
+    const auto &oldVal = oldObject[propName];
+    const auto &newVal = newObject[propName];
+
+    if (oldVal.isObject() && newVal.isObject()) {
+      return getChangedPropsRecursive(oldVal, newVal);
+    } else if (oldVal != newVal) {
+      return {oldVal, newVal};
+    }
+
+    return {folly::dynamic(), folly::dynamic()};
+  }
+
+  if (oldHasProperty) {
+    const auto &oldVal = oldObject[propName];
+    return {oldVal, folly::dynamic()};
+  } else if (newHasProperty) {
+    const auto &newVal = newObject[propName];
+    return {folly::dynamic(), newVal};
+  }
+
+  return {folly::dynamic(), folly::dynamic()};
+}
+
+ChangedProps getChangedProps(
+    const folly::dynamic &oldProps,
+    const folly::dynamic &newProps,
+    const PropertyNames &allowedProperties) {
+  folly::dynamic oldResult = folly::dynamic::object;
+  folly::dynamic newResult = folly::dynamic::object;
+  PropertyNames changedPropertyNames;
+
+  for (const auto &propName : allowedProperties) {
+    auto [oldChangedProp, newChangedProp] = getChangedValueForProp(oldProps, newProps, propName);
+
+    const auto hasOldChangedProp = !oldChangedProp.isNull();
+    const auto hasNewChangedProp = !newChangedProp.isNull();
+
+    if (hasOldChangedProp) {
+      oldResult[propName] = std::move(oldChangedProp);
+    }
+    if (hasNewChangedProp) {
+      newResult[propName] = std::move(newChangedProp);
+    }
+    if (hasOldChangedProp || hasNewChangedProp) {
+      changedPropertyNames.push_back(propName);
+    }
+  }
+
+  return {std::move(oldResult), std::move(newResult), std::move(changedPropertyNames)};
+}
+
+} // namespace reanimated::css

package/harmony/reanimated/src/main/cpp/Common/cpp/reanimated/CSS/utils/props.h

@@ -1,32 +1,32 @@
-#pragma once
-
-#include <reanimated/CSS/InterpolatorRegistry.h>
-#include <reanimated/CSS/common/definitions.h>
-
-#include <memory>
-#include <string>
-#include <unordered_map>
-#include <unordered_set>
-#include <utility>
-
-namespace reanimated::css {
-
-struct ChangedProps {
-  const folly::dynamic oldProps;
-  const folly::dynamic newProps;
-  const PropertyNames changedPropertyNames;
-};
-
-bool isDiscreteProperty(const std::string &propName, const std::string &componentName);
-
-// We need to specify it here because there are 2 methods referencing
-// each other in the recursion and areArraysDifferentRecursive must be
-// aware that getChangedPropsRecursive exists
-std::pair<folly::dynamic, folly::dynamic> getChangedPropsRecursive(
-    const folly::dynamic &oldProp,
-    const folly::dynamic &newProp);
-
-ChangedProps
-getChangedProps(const folly::dynamic &oldProps, const folly::dynamic &newProps, const PropertyNames &allowedProperties);
-
-} // namespace reanimated::css
+#pragma once
+
+#include <reanimated/CSS/InterpolatorRegistry.h>
+#include <reanimated/CSS/common/definitions.h>
+
+#include <memory>
+#include <string>
+#include <unordered_map>
+#include <unordered_set>
+#include <utility>
+
+namespace reanimated::css {
+
+struct ChangedProps {
+  const folly::dynamic oldProps;
+  const folly::dynamic newProps;
+  const PropertyNames changedPropertyNames;
+};
+
+bool isDiscreteProperty(const std::string &propName, const std::string &componentName);
+
+// We need to specify it here because there are 2 methods referencing
+// each other in the recursion and areArraysDifferentRecursive must be
+// aware that getChangedPropsRecursive exists
+std::pair<folly::dynamic, folly::dynamic> getChangedPropsRecursive(
+    const folly::dynamic &oldProp,
+    const folly::dynamic &newProp);
+
+ChangedProps
+getChangedProps(const folly::dynamic &oldProps, const folly::dynamic &newProps, const PropertyNames &allowedProperties);
+
+} // namespace reanimated::css

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

@@ -1,113 +1,113 @@
-#include <reanimated/Fabric/ReanimatedCommitHook.h>
-#include <reanimated/Fabric/ReanimatedCommitShadowNode.h>
-#include <reanimated/Fabric/ShadowTreeCloner.h>
-#include <reanimated/Tools/FeatureFlags.h>
-#include <reanimated/Tools/ReanimatedSystraceSection.h>
-
-#include <react/renderer/core/ComponentDescriptor.h>
-
-#include <memory>
-#include <unordered_map>
-#include <vector>
-
-using namespace facebook::react;
-
-namespace reanimated {
-
-ReanimatedCommitHook::ReanimatedCommitHook(
-    const std::shared_ptr<UIManager> &uiManager,
-    const std::shared_ptr<UpdatesRegistryManager> &updatesRegistryManager,
-    const std::shared_ptr<LayoutAnimationsProxyCommon> &layoutAnimationsProxy)
-    : uiManager_(uiManager),
-      updatesRegistryManager_(updatesRegistryManager),
-      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;
-      }
-      // TODO: We should consider registering a new instance of proxy for each surface.
-      // The current approach will encounter problems on platforms where it is more common to have multiple surfaces.
-      strongThis->layoutAnimationsProxy_->startSurface(shadowTree.getSurfaceId());
-      shadowTree.getMountingCoordinator()->setMountingOverrideDelegate(strongThis->layoutAnimationsProxy_);
-    });
-    currentMaxSurfaceId_ = surfaceId;
-  }
-}
-
-RootShadowNode::Unshared ReanimatedCommitHook::shadowTreeWillCommit(
-    ShadowTree const &,
-    RootShadowNode::Shared const &,
-    RootShadowNode::Unshared const &newRootShadowNode
-#if REACT_NATIVE_MINOR_VERSION >= 80
-    ,
-    const ShadowTreeCommitOptions &commitOptions
-#endif
-    ) noexcept {
-  ReanimatedSystraceSection s("ReanimatedCommitHook::shadowTreeWillCommit");
-
-  maybeInitializeLayoutAnimations(newRootShadowNode->getSurfaceId());
-
-  auto reaShadowNode = std::reinterpret_pointer_cast<ReanimatedCommitShadowNode>(newRootShadowNode);
-
-  if (reaShadowNode->hasReanimatedCommitTrait()) {
-    // ShadowTree commited by Reanimated, no need to apply updates from
-    // the updates registry manager
-    reaShadowNode->unsetReanimatedCommitTrait();
-    reaShadowNode->setReanimatedMountTrait();
-    return newRootShadowNode;
-  }
-
-#if REACT_NATIVE_MINOR_VERSION >= 80
-  if constexpr (StaticFeatureFlags::getFlag("USE_COMMIT_HOOK_ONLY_FOR_REACT_COMMITS")) {
-    // State updates are based on the currently committed ShadowTree,
-    // 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) {
-      return newRootShadowNode;
-    }
-  }
-#endif
-
-  // ShadowTree not commited by Reanimated, apply updates from the updates
-  // registry manager
-  reaShadowNode->unsetReanimatedMountTrait();
-  RootShadowNode::Unshared rootNode = newRootShadowNode;
-
-  {
-    auto lock = updatesRegistryManager_->lock();
-
-    PropsMap propsMap = updatesRegistryManager_->collectProps();
-    updatesRegistryManager_->cancelCommitAfterPause();
-
-    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 UpdatesRegistryManager
-    // 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). We don't pause Reanimated commits for state updates coming
-    // from React Native as this would break sticky header animations.
-    updatesRegistryManager_->pauseReanimatedCommits();
-  }
-
-  return rootNode;
-}
-
-} // namespace reanimated
+#include <reanimated/Fabric/ReanimatedCommitHook.h>
+#include <reanimated/Fabric/ReanimatedCommitShadowNode.h>
+#include <reanimated/Fabric/ShadowTreeCloner.h>
+#include <reanimated/Tools/FeatureFlags.h>
+#include <reanimated/Tools/ReanimatedSystraceSection.h>
+
+#include <react/renderer/core/ComponentDescriptor.h>
+
+#include <memory>
+#include <unordered_map>
+#include <vector>
+
+using namespace facebook::react;
+
+namespace reanimated {
+
+ReanimatedCommitHook::ReanimatedCommitHook(
+    const std::shared_ptr<UIManager> &uiManager,
+    const std::shared_ptr<UpdatesRegistryManager> &updatesRegistryManager,
+    const std::shared_ptr<LayoutAnimationsProxyCommon> &layoutAnimationsProxy)
+    : uiManager_(uiManager),
+      updatesRegistryManager_(updatesRegistryManager),
+      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;
+      }
+      // TODO: We should consider registering a new instance of proxy for each surface.
+      // The current approach will encounter problems on platforms where it is more common to have multiple surfaces.
+      strongThis->layoutAnimationsProxy_->startSurface(shadowTree.getSurfaceId());
+      shadowTree.getMountingCoordinator()->setMountingOverrideDelegate(strongThis->layoutAnimationsProxy_);
+    });
+    currentMaxSurfaceId_ = surfaceId;
+  }
+}
+
+RootShadowNode::Unshared ReanimatedCommitHook::shadowTreeWillCommit(
+    ShadowTree const &,
+    RootShadowNode::Shared const &,
+    RootShadowNode::Unshared const &newRootShadowNode
+#if REACT_NATIVE_MINOR_VERSION >= 80
+    ,
+    const ShadowTreeCommitOptions &commitOptions
+#endif
+    ) noexcept {
+  ReanimatedSystraceSection s("ReanimatedCommitHook::shadowTreeWillCommit");
+
+  maybeInitializeLayoutAnimations(newRootShadowNode->getSurfaceId());
+
+  auto reaShadowNode = std::reinterpret_pointer_cast<ReanimatedCommitShadowNode>(newRootShadowNode);
+
+  if (reaShadowNode->hasReanimatedCommitTrait()) {
+    // ShadowTree commited by Reanimated, no need to apply updates from
+    // the updates registry manager
+    reaShadowNode->unsetReanimatedCommitTrait();
+    reaShadowNode->setReanimatedMountTrait();
+    return newRootShadowNode;
+  }
+
+#if REACT_NATIVE_MINOR_VERSION >= 80
+  if constexpr (StaticFeatureFlags::getFlag("USE_COMMIT_HOOK_ONLY_FOR_REACT_COMMITS")) {
+    // State updates are based on the currently committed ShadowTree,
+    // 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) {
+      return newRootShadowNode;
+    }
+  }
+#endif
+
+  // ShadowTree not commited by Reanimated, apply updates from the updates
+  // registry manager
+  reaShadowNode->unsetReanimatedMountTrait();
+  RootShadowNode::Unshared rootNode = newRootShadowNode;
+
+  {
+    auto lock = updatesRegistryManager_->lock();
+
+    PropsMap propsMap = updatesRegistryManager_->collectProps();
+    updatesRegistryManager_->cancelCommitAfterPause();
+
+    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 UpdatesRegistryManager
+    // 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). We don't pause Reanimated commits for state updates coming
+    // from React Native as this would break sticky header animations.
+    updatesRegistryManager_->pauseReanimatedCommits();
+  }
+
+  return rootNode;
+}
+
+} // namespace reanimated