@react-native-ohos/react-native-reanimated 4.0.1 → 4.0.2

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

@@ -1,170 +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
+#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

@@ -1,67 +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
+#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

@@ -1,12 +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
+#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

@@ -1,41 +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
+#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

@@ -1,31 +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
+#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