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

package/harmony/reanimated/src/main/cpp/Common/cpp/reanimated/CSS/misc/ViewStylesRepository.cpp

@@ -0,0 +1,155 @@
+#include <reanimated/CSS/misc/ViewStylesRepository.h>
+
+#include <memory>
+#include <string>
+
+namespace reanimated::css {
+
+ViewStylesRepository::ViewStylesRepository(
+    const std::shared_ptr<StaticPropsRegistry> &staticPropsRegistry,
+    const std::shared_ptr<AnimatedPropsRegistry> &animatedPropsRegistry)
+    : staticPropsRegistry_(staticPropsRegistry), animatedPropsRegistry_(animatedPropsRegistry) {}
+
+jsi::Value ViewStylesRepository::getNodeProp(
+    const std::shared_ptr<const ShadowNode> &shadowNode,
+    const std::string &propName) {
+  int tag = shadowNode->getTag();
+
+  auto &cachedNode = shadowNodeCache_[tag];
+  updateCacheIfNeeded(cachedNode, shadowNode);
+
+  if (propName == "width" || propName == "height" || propName == "top" || propName == "left") {
+    const auto &layoutMetrics = cachedNode.layoutMetrics;
+
+    if (propName == "width") {
+      return {layoutMetrics.frame.size.width};
+    } else if (propName == "height") {
+      return {layoutMetrics.frame.size.height};
+    } else if (propName == "top") {
+      return {layoutMetrics.frame.origin.y};
+    } else if (propName == "left") {
+      return {layoutMetrics.frame.origin.x};
+    }
+  } else {
+    const auto &viewProps = cachedNode.viewProps;
+
+    if (propName == "opacity") {
+      return {viewProps->opacity};
+    } else if (propName == "zIndex") {
+      return viewProps->zIndex.has_value() ? jsi::Value(*viewProps->zIndex) : jsi::Value(0);
+    } else if (propName == "backgroundColor") {
+      return {static_cast<int32_t>(*viewProps->backgroundColor)};
+    }
+  }
+
+  throw std::runtime_error("[Reanimated] Unsupported property: " + propName);
+}
+
+jsi::Value ViewStylesRepository::getParentNodeProp(
+    const std::shared_ptr<const ShadowNode> &shadowNode,
+    const std::string &propName) {
+  const auto surfaceId = shadowNode->getSurfaceId();
+  const auto &shadowTreeRegistry = uiManager_->getShadowTreeRegistry();
+
+  std::shared_ptr<const ShadowNode> parentNode = nullptr;
+
+  shadowTreeRegistry.visit(surfaceId, [&](ShadowTree const &shadowTree) {
+    auto currentRevision = shadowTree.getCurrentRevision();
+    parentNode = dom::getParentNode(currentRevision.rootShadowNode, *shadowNode);
+  });
+
+  if (!parentNode) {
+    return jsi::Value::undefined();
+  }
+
+  return getNodeProp(parentNode, propName);
+}
+
+folly::dynamic ViewStylesRepository::getStyleProp(const Tag tag, const PropertyPath &propertyPath) {
+  auto animatedValue = getPropertyValue(animatedPropsRegistry_->get(tag), propertyPath);
+  if (!animatedValue.isNull()) {
+    return animatedValue;
+  }
+
+  return getPropertyValue(staticPropsRegistry_->get(tag), propertyPath);
+}
+
+void ViewStylesRepository::clearNodesCache() {
+  shadowNodeCache_.clear();
+}
+
+void ViewStylesRepository::updateCacheIfNeeded(
+    CachedShadowNode &cachedNode,
+    const std::shared_ptr<const ShadowNode> &shadowNode) {
+  auto newestCloneOfShadowNode = uiManager_->getNewestCloneOfShadowNode(*shadowNode);
+
+  // Check if newestCloneOfShadowNode is valid (is already mounted / not
+  // yet unmounted)
+  if (!newestCloneOfShadowNode) {
+    return;
+  }
+
+  auto layoutableShadowNode = dynamic_cast<const LayoutableShadowNode *>(newestCloneOfShadowNode.get());
+  if (!layoutableShadowNode) {
+    return;
+  }
+
+  cachedNode.layoutMetrics = layoutableShadowNode->layoutMetrics_;
+  cachedNode.viewProps = std::static_pointer_cast<const ViewProps>(newestCloneOfShadowNode->getProps());
+}
+
+folly::dynamic ViewStylesRepository::getPropertyValue(const folly::dynamic &value, const PropertyPath &propertyPath) {
+  const folly::dynamic *currentValue = &value;
+
+  for (size_t i = 0; i < propertyPath.size(); ++i) {
+    if (currentValue->isNull() || currentValue->empty()) {
+      return {};
+    }
+
+    const auto &propName = propertyPath[i];
+
+    if (!currentValue->isObject()) {
+      return {};
+    }
+
+    if (propName == "transform") {
+      auto transformIt = currentValue->find("transform");
+      if (transformIt == currentValue->items().end()) {
+        return {};
+      }
+
+      const auto &transform = transformIt->second;
+      if (!transform.isArray()) {
+        return {};
+      }
+
+      if (i + 1 >= propertyPath.size()) {
+        return transform;
+      }
+
+      const std::string &transformPropName = propertyPath[i + 1];
+
+      for (const auto &transformEntry : transform) {
+        if (transformEntry.isObject()) {
+          auto transformPropIt = transformEntry.find(transformPropName);
+          if (transformPropIt != transformEntry.items().end()) {
+            return transformPropIt->second;
+          }
+        }
+      }
+
+      return {};
+    }
+
+    auto propIt = currentValue->find(propName);
+    if (propIt == currentValue->items().end()) {
+      return {};
+    }
+
+    currentValue = &propIt->second;
+  }
+
+  return *currentValue;
+}
+
+} // namespace reanimated::css

package/harmony/reanimated/src/main/cpp/Common/cpp/reanimated/CSS/misc/ViewStylesRepository.h

@@ -0,0 +1,53 @@
+#pragma once
+
+#include <reanimated/CSS/common/definitions.h>
+#include <reanimated/CSS/registries/StaticPropsRegistry.h>
+#include <reanimated/Fabric/updates/AnimatedPropsRegistry.h>
+
+#include <react/renderer/components/view/ViewProps.h>
+#include <react/renderer/core/LayoutableShadowNode.h>
+#include <react/renderer/dom/DOM.h>
+
+#include <memory>
+#include <string>
+#include <unordered_map>
+
+namespace reanimated::css {
+
+using namespace facebook;
+using namespace react;
+
+struct CachedShadowNode {
+  LayoutMetrics layoutMetrics;
+  std::shared_ptr<const ViewProps> viewProps;
+};
+
+class ViewStylesRepository {
+ public:
+  ViewStylesRepository(
+      const std::shared_ptr<StaticPropsRegistry> &staticPropsRegistry,
+      const std::shared_ptr<AnimatedPropsRegistry> &animatedPropsRegistry);
+
+  void setUIManager(const std::shared_ptr<UIManager> &uiManager) {
+    uiManager_ = uiManager;
+  }
+
+  jsi::Value getNodeProp(const std::shared_ptr<const ShadowNode> &shadowNode, const std::string &propName);
+  jsi::Value getParentNodeProp(const std::shared_ptr<const ShadowNode> &shadowNode, const std::string &propName);
+  folly::dynamic getStyleProp(Tag tag, const PropertyPath &propertyPath);
+
+  void clearNodesCache();
+
+ private:
+  std::shared_ptr<UIManager> uiManager_;
+  std::shared_ptr<StaticPropsRegistry> staticPropsRegistry_;
+  std::shared_ptr<AnimatedPropsRegistry> animatedPropsRegistry_;
+
+  std::unordered_map<int, CachedShadowNode> shadowNodeCache_;
+
+  void updateCacheIfNeeded(CachedShadowNode &cachedNode, const std::shared_ptr<const ShadowNode> &shadowNode);
+
+  static folly::dynamic getPropertyValue(const folly::dynamic &value, const PropertyPath &propertyPath);
+};
+
+} // namespace reanimated::css

package/harmony/reanimated/src/main/cpp/Common/cpp/reanimated/CSS/progress/AnimationProgressProvider.cpp

@@ -0,0 +1,170 @@
+#include <reanimated/CSS/progress/AnimationProgressProvider.h>
+
+#include <memory>
+#include <utility>
+
+namespace reanimated::css {
+
+AnimationProgressProvider::AnimationProgressProvider(
+    const double timestamp,
+    const double duration,
+    const double delay,
+    const double iterationCount,
+    const AnimationDirection direction,
+    EasingFunction easingFunction,
+    const std::shared_ptr<KeyframeEasingFunctions> &keyframeEasingFunctions)
+    : RawProgressProvider(timestamp, duration, delay),
+      iterationCount_(iterationCount),
+      direction_(direction),
+      easingFunction_(std::move(easingFunction)),
+      keyframeEasingFunctions_(keyframeEasingFunctions) {}
+
+void AnimationProgressProvider::setIterationCount(double iterationCount) {
+  iterationCount_ = iterationCount;
+}
+
+void AnimationProgressProvider::setDirection(AnimationDirection direction) {
+  direction_ = direction;
+}
+
+void AnimationProgressProvider::setEasingFunction(const EasingFunction &easingFunction) {
+  easingFunction_ = easingFunction;
+}
+
+AnimationDirection AnimationProgressProvider::getDirection() const {
+  return direction_;
+}
+
+double AnimationProgressProvider::getGlobalProgress() const {
+  return applyAnimationDirection(rawProgress_.value_or(0));
+}
+
+AnimationProgressState AnimationProgressProvider::getState(const double timestamp) const {
+  if (shouldFinish(timestamp)) {
+    return AnimationProgressState::Finished;
+  }
+  if (pauseTimestamp_ > 0) {
+    return AnimationProgressState::Paused;
+  }
+  if (timestamp < getStartTimestamp(timestamp) || !rawProgress_.has_value()) {
+    return AnimationProgressState::Pending;
+  }
+  return AnimationProgressState::Running;
+}
+
+double AnimationProgressProvider::getPauseTimestamp() const {
+  return pauseTimestamp_;
+}
+
+double AnimationProgressProvider::getTotalPausedTime(const double timestamp) const {
+  return pauseTimestamp_ > 0 ? (totalPausedTime_ + (timestamp - pauseTimestamp_)) : totalPausedTime_;
+}
+
+double AnimationProgressProvider::getStartTimestamp(const double timestamp) const {
+  // Start timestamp is the timestamp when the first animation keyframe
+  // should be applied (it depends on the animation delay and the total
+  // time when the animation was paused)
+  return creationTimestamp_ + delay_ + getTotalPausedTime(timestamp);
+}
+
+double AnimationProgressProvider::getKeyframeProgress(const double fromOffset, const double toOffset) const {
+  if (fromOffset == toOffset) {
+    return 1;
+  }
+
+  const auto keyframeProgress = (getGlobalProgress() - fromOffset) / (toOffset - fromOffset);
+
+  // Use the overridden easing function if it was overridden for the
+  // current keyframe
+  const auto easingFunctionIt = keyframeEasingFunctions_->find(fromOffset);
+  if (easingFunctionIt != keyframeEasingFunctions_->end()) {
+    return easingFunctionIt->second(keyframeProgress);
+  }
+
+  return easingFunction_(keyframeProgress);
+}
+
+void AnimationProgressProvider::pause(const double timestamp) {
+  pauseTimestamp_ = timestamp;
+}
+
+void AnimationProgressProvider::play(const double timestamp) {
+  if (pauseTimestamp_ > 0) {
+    totalPausedTime_ += timestamp - pauseTimestamp_;
+  }
+  pauseTimestamp_ = 0;
+}
+
+void AnimationProgressProvider::resetProgress() {
+  RawProgressProvider::resetProgress();
+  currentIteration_ = 1;
+  previousIterationsDuration_ = 0;
+}
+
+bool AnimationProgressProvider::shouldFinish(const double timestamp) const {
+  if (iterationCount_ == 0) {
+    return true;
+  }
+  if (iterationCount_ == -1) {
+    return false;
+  }
+  const auto elapsedDuration = timestamp - getStartTimestamp(timestamp);
+  return elapsedDuration >= duration_ * iterationCount_;
+}
+
+std::optional<double> AnimationProgressProvider::calculateRawProgress(const double timestamp) {
+  const double currentIterationElapsedTime =
+      timestamp - (creationTimestamp_ + delay_ + previousIterationsDuration_ + getTotalPausedTime(timestamp));
+
+  if (currentIterationElapsedTime < 0) {
+    return std::nullopt;
+  }
+
+  const double iterationProgress = updateIterationProgress(currentIterationElapsedTime);
+
+  if (shouldFinish(timestamp)) {
+    // Override current progress for the last update in the last iteration to
+    // ensure that animation finishes exactly at the specified iteration
+    const double intPart = std::floor(iterationCount_);
+    return intPart == iterationCount_ ? 1 : iterationCount_ - intPart;
+  }
+
+  return iterationProgress;
+}
+
+double AnimationProgressProvider::updateIterationProgress(const double currentIterationElapsedTime) {
+  if (duration_ == 0) {
+    return 1;
+  }
+  // We can increase curentIteration by more than just one iteration if the
+  // animation delay is negative, thus we are using this division to get the
+  // number of iterations that have passed since the previous animation update
+  // (deltaIterations can be greater than for the first update of the
+  // animation with the negative delay)
+  const double progress = currentIterationElapsedTime / duration_;
+  const auto deltaIterations = static_cast<unsigned>(progress);
+
+  if (deltaIterations > 0) {
+    currentIteration_ += deltaIterations;
+    previousIterationsDuration_ = (currentIteration_ - 1) * duration_;
+  }
+
+  // If the current iteration changes, the progress must be updated
+  // respectively not to contain the progress of the previous iteration
+  return progress - deltaIterations;
+}
+
+double AnimationProgressProvider::applyAnimationDirection(const double progress) const {
+  switch (direction_) {
+    case AnimationDirection::Normal:
+      return progress;
+    case AnimationDirection::Reverse:
+      return 1.0 - progress;
+    case AnimationDirection::Alternate:
+      return currentIteration_ % 2 == 0 ? 1.0 - progress : progress;
+    case AnimationDirection::AlternateReverse:
+      return currentIteration_ % 2 == 0 ? progress : 1.0 - progress;
+  }
+}
+
+} // namespace reanimated::css

package/harmony/reanimated/src/main/cpp/Common/cpp/reanimated/CSS/progress/AnimationProgressProvider.h

@@ -0,0 +1,67 @@
+#pragma once
+
+#include <reanimated/CSS/configs/CSSAnimationConfig.h>
+#include <reanimated/CSS/configs/CSSKeyframesConfig.h>
+#include <reanimated/CSS/easing/EasingFunctions.h>
+#include <reanimated/CSS/progress/KeyframeProgressProvider.h>
+#include <reanimated/CSS/progress/RawProgressProvider.h>
+
+#include <memory>
+
+namespace reanimated::css {
+
+enum class AnimationProgressState : std::uint8_t {
+  Pending, // When the animation is waiting for the delay to pass
+  Running,
+  Paused,
+  Finished
+};
+
+class AnimationProgressProvider final : public KeyframeProgressProvider, public RawProgressProvider {
+ public:
+  AnimationProgressProvider(
+      double timestamp,
+      double duration,
+      double delay,
+      double iterationCount,
+      AnimationDirection direction,
+      EasingFunction easingFunction,
+      const std::shared_ptr<KeyframeEasingFunctions> &keyframeEasingFunctions);
+
+  void setIterationCount(double iterationCount);
+  void setDirection(AnimationDirection direction);
+  void setEasingFunction(const EasingFunction &easingFunction);
+
+  AnimationDirection getDirection() const;
+  double getGlobalProgress() const override;
+  double getKeyframeProgress(double fromOffset, double toOffset) const override;
+  AnimationProgressState getState(double timestamp) const;
+  double getPauseTimestamp() const;
+  double getTotalPausedTime(double timestamp) const;
+  double getStartTimestamp(double timestamp) const;
+
+  void pause(double timestamp);
+  void play(double timestamp);
+  void resetProgress() override;
+
+ protected:
+  std::optional<double> calculateRawProgress(double timestamp) override;
+
+ private:
+  double iterationCount_;
+  AnimationDirection direction_;
+  EasingFunction easingFunction_;
+  std::shared_ptr<KeyframeEasingFunctions> keyframeEasingFunctions_;
+
+  unsigned currentIteration_ = 1;
+  double previousIterationsDuration_ = 0;
+  double pauseTimestamp_ = 0;
+  double totalPausedTime_ = 0;
+
+  bool shouldFinish(double timestamp) const;
+
+  double updateIterationProgress(double currentIterationElapsedTime);
+  double applyAnimationDirection(double iterationProgress) const;
+};
+
+} // namespace reanimated::css

package/harmony/reanimated/src/main/cpp/Common/cpp/reanimated/CSS/progress/KeyframeProgressProvider.h

@@ -0,0 +1,12 @@
+#pragma once
+
+namespace reanimated::css {
+
+class KeyframeProgressProvider {
+ public:
+  virtual double getGlobalProgress() const = 0;
+
+  virtual double getKeyframeProgress(double fromOffset, double toOffset) const = 0;
+};
+
+} // namespace reanimated::css

package/harmony/reanimated/src/main/cpp/Common/cpp/reanimated/CSS/progress/RawProgressProvider.cpp

@@ -0,0 +1,41 @@
+#include <reanimated/CSS/progress/RawProgressProvider.h>
+
+namespace reanimated::css {
+
+RawProgressProvider::RawProgressProvider(const double timestamp, const double duration, const double delay)
+    : duration_(duration), delay_(delay), creationTimestamp_(timestamp) {}
+
+void RawProgressProvider::setDuration(double duration) {
+  duration_ = duration;
+}
+
+void RawProgressProvider::setDelay(double delay) {
+  delay_ = delay;
+}
+
+void RawProgressProvider::resetProgress() {
+  rawProgress_.reset();
+  previousRawProgress_.reset();
+}
+
+void RawProgressProvider::update(const double timestamp) {
+  previousRawProgress_ = rawProgress_;
+
+  if (timestamp - creationTimestamp_ < delay_) {
+    rawProgress_.reset();
+    return;
+  }
+
+  rawProgress_ = calculateRawProgress(timestamp);
+  if (!rawProgress_.has_value()) {
+    return;
+  }
+
+  if (rawProgress_.value() < 0) {
+    rawProgress_.reset();
+  } else if (rawProgress_.value() >= 1) {
+    rawProgress_ = 1;
+  }
+}
+
+} // namespace reanimated::css

package/harmony/reanimated/src/main/cpp/Common/cpp/reanimated/CSS/progress/RawProgressProvider.h

@@ -0,0 +1,31 @@
+#pragma once
+
+#include <optional>
+namespace reanimated::css {
+
+class RawProgressProvider {
+ public:
+  RawProgressProvider(double timestamp, double duration, double delay);
+
+  void setDuration(double duration);
+  void setDelay(double delay);
+
+  virtual void resetProgress();
+  void update(double timestamp);
+
+ protected:
+  double duration_;
+  double delay_;
+  double creationTimestamp_;
+
+  std::optional<double> rawProgress_;
+  std::optional<double> previousRawProgress_;
+
+  /**
+   * Calculates the progress of the animation at the given timestamp without
+   * applying any decorations (e.g. animation direction, easing)
+   */
+  virtual std::optional<double> calculateRawProgress(double timestamp) = 0;
+};
+
+} // namespace reanimated::css