react-native 0.66.2 → 0.67.0-rc.3

package/ReactCommon/react/renderer/animations/LayoutAnimationKeyFrameManager.h

@@ -9,11 +9,11 @@
 
 #include <ReactCommon/RuntimeExecutor.h>
 #include <better/optional.h>
-#include <react/renderer/core/EventTarget.h>
+#include <better/set.h>
+#include <react/renderer/animations/LayoutAnimationCallbackWrapper.h>
+#include <react/renderer/animations/primitives.h>
 #include <react/renderer/core/RawValue.h>
 #include <react/renderer/debug/flags.h>
-#include <react/renderer/mounting/Differentiator.h>
-#include <react/renderer/mounting/MountingCoordinator.h>
 #include <react/renderer/mounting/MountingOverrideDelegate.h>
 #include <react/renderer/mounting/MountingTransaction.h>
 #include <react/renderer/mounting/ShadowViewMutation.h>
@@ -36,146 +36,15 @@ void PrintMutationInstructionRelative(
 #define PrintMutationInstructionRelative(a, b, c)
 #endif
 
-// This corresponds exactly with JS.
-enum class AnimationType {
-  None = 0,
-  Spring = 1,
-  Linear = 2,
-  EaseInEaseOut = 4,
-  EaseIn = 8,
-  EaseOut = 16,
-  Keyboard = 32
-};
-enum class AnimationProperty {
-  NotApplicable = 0,
-  Opacity = 1,
-  ScaleX = 2,
-  ScaleY = 4,
-  ScaleXY = 8
-};
-enum class AnimationConfigurationType { Create = 1, Update = 2, Delete = 4 };
-
-// This corresponds exactly with JS.
-struct AnimationConfig {
-  AnimationType animationType = AnimationType::None;
-  AnimationProperty animationProperty = AnimationProperty::NotApplicable;
-  double duration =
-      0; // these are perhaps better represented as uint64_t, but they
-  // come from JS as doubles
-  double delay = 0;
-  double springDamping = 0;
-  double initialVelocity = 0;
-};
-
-// This corresponds exactly with JS.
-struct LayoutAnimationConfig {
-  double duration; // ms
-  AnimationConfig createConfig;
-  AnimationConfig updateConfig;
-  AnimationConfig deleteConfig;
-};
-
-struct AnimationKeyFrame {
-  // The mutation(s) that should be executed once the animation completes.
-  // This maybe empty.
-  // For CREATE/INSERT this will contain CREATE, INSERT in that order.
-  // For REMOVE/DELETE, same.
-  std::vector<ShadowViewMutation> finalMutationsForKeyFrame;
-
-  // The type of animation this is (for configuration purposes)
-  AnimationConfigurationType type;
-
-  // Tag representing the node being animated.
-  Tag tag;
-
-  ShadowView parentView;
-
-  // ShadowView representing the start and end points of this animation.
-  ShadowView viewStart;
-  ShadowView viewEnd;
-
-  // ShadowView representing the previous frame of the animation.
-  ShadowView viewPrev;
-
-  // If an animation interrupts an existing one, the starting state may actually
-  // be halfway through the intended transition.
-  double initialProgress;
-
-  bool invalidated{false};
-
-  // In the case where some mutation conflicts with this keyframe,
-  // should we generate final synthetic UPDATE mutations for this keyframe?
-  bool generateFinalSyntheticMutations{true};
-};
-
-class LayoutAnimationCallbackWrapper {
- public:
-  LayoutAnimationCallbackWrapper(jsi::Function &&callback)
-      : callback_(std::make_shared<jsi::Function>(std::move(callback))) {}
-  LayoutAnimationCallbackWrapper() : callback_(nullptr) {}
-
-  // Copy and assignment-copy constructors should copy callback_, and not
-  // std::move it. Copying is desirable, otherwise the shared_ptr and
-  // jsi::Function will be deallocated too early.
-
-  bool readyForCleanup() const {
-    return callback_ == nullptr || *callComplete_;
-  }
-
-  void call(const RuntimeExecutor &runtimeExecutor) const {
-    if (readyForCleanup()) {
-      return;
-    }
-
-    std::weak_ptr<jsi::Function> callable = callback_;
-    std::shared_ptr<std::atomic_bool> callComplete = callComplete_;
-
-    runtimeExecutor(
-        [=, callComplete = std::move(callComplete)](jsi::Runtime &runtime) {
-          auto fn = callable.lock();
-
-          if (!fn || *callComplete) {
-            return;
-          }
-
-          fn->call(runtime);
-          *callComplete = true;
-        });
-  }
-
- private:
-  std::shared_ptr<std::atomic_bool> callComplete_ =
-      std::make_shared<std::atomic_bool>(false);
-  std::shared_ptr<jsi::Function> callback_;
-};
-
-struct LayoutAnimation {
-  SurfaceId surfaceId;
-  uint64_t startTime;
-  bool completed = false;
-  LayoutAnimationConfig layoutAnimationConfig;
-  LayoutAnimationCallbackWrapper successCallback;
-  LayoutAnimationCallbackWrapper failureCallback;
-  std::vector<AnimationKeyFrame> keyFrames;
-};
-
 class LayoutAnimationKeyFrameManager : public UIManagerAnimationDelegate,
                                        public MountingOverrideDelegate {
  public:
   LayoutAnimationKeyFrameManager(
       RuntimeExecutor runtimeExecutor,
-      LayoutAnimationStatusDelegate *delegate)
-      : runtimeExecutor_(runtimeExecutor),
-        layoutAnimationStatusDelegate_(delegate),
-        now_([]() {
-          return std::chrono::duration_cast<std::chrono::milliseconds>(
-                     std::chrono::high_resolution_clock::now()
-                         .time_since_epoch())
-              .count();
-        }) {}
-  ~LayoutAnimationKeyFrameManager() {}
-
-#pragma mark UIManagerAnimationDelegate methods
+      ContextContainer::Shared &contextContainer,
+      LayoutAnimationStatusDelegate *delegate);
+
+#pragma mark - UIManagerAnimationDelegate methods
 
   void uiManagerDidConfigureNextLayoutAnimation(
       jsi::Runtime &runtime,
@@ -191,7 +60,7 @@ class LayoutAnimationKeyFrameManager : public UIManagerAnimationDelegate,
 
   void stopSurface(SurfaceId surfaceId) override;
 
-#pragma mark MountingOverrideDelegate methods
+#pragma mark - MountingOverrideDelegate methods
 
   bool shouldOverridePullTransaction() const override;
 
@@ -205,7 +74,6 @@ class LayoutAnimationKeyFrameManager : public UIManagerAnimationDelegate,
       ShadowViewMutationList mutations) const override;
 
   // Exposed for testing.
- public:
   void uiManagerDidConfigureNextLayoutAnimation(
       LayoutAnimation layoutAnimation) const;
 
@@ -214,50 +82,47 @@ class LayoutAnimationKeyFrameManager : public UIManagerAnimationDelegate,
   // delegate is protected by a mutex; ALL method calls into this delegate are
   // also protected by the mutex! The only way to set this without a mutex is
   // via a constructor.
- public:
   void setLayoutAnimationStatusDelegate(
       LayoutAnimationStatusDelegate *delegate) const;
 
- private:
-  RuntimeExecutor runtimeExecutor_;
-  mutable std::mutex layoutAnimationStatusDelegateMutex_;
-  mutable LayoutAnimationStatusDelegate *layoutAnimationStatusDelegate_{};
+  void setClockNow(std::function<uint64_t()> now);
 
-  // Function that returns current time in milliseconds
-  std::function<uint64_t()> now_;
+  void enableSkipInvalidatedKeyFrames();
 
-  void adjustImmediateMutationIndicesForDelayedMutations(
-      SurfaceId surfaceId,
-      ShadowViewMutation &mutation,
-      bool skipLastAnimation = false,
-      bool lastAnimationOnly = false) const;
+  void enableCrashOnMissingComponentDescriptor();
 
-  void adjustDelayedMutationIndicesForMutation(
-      SurfaceId surfaceId,
-      ShadowViewMutation const &mutation,
-      bool skipLastAnimation = false) const;
+  void enableSimulateImagePropsMemoryAccess();
 
-  void getAndEraseConflictingAnimations(
-      SurfaceId surfaceId,
-      ShadowViewMutationList const &mutations,
-      std::vector<AnimationKeyFrame> &conflictingAnimations) const;
+ protected:
+  SharedComponentDescriptorRegistry componentDescriptorRegistry_;
+  mutable better::optional<LayoutAnimation> currentAnimation_{};
+  mutable std::mutex currentAnimationMutex_;
 
-  mutable std::mutex surfaceIdsToStopMutex_;
-  mutable std::vector<SurfaceId> surfaceIdsToStop_{};
+  /**
+   * All mutations of inflightAnimations_ are thread-safe as long as
+   * we keep the contract of: only mutate it within the context of
+   * `pullTransaction`. If that contract is held, this is implicitly protected
+   * by the MountingCoordinator's mutex.
+   */
+  mutable std::vector<LayoutAnimation> inflightAnimations_{};
 
- protected:
   bool hasComponentDescriptorForShadowView(ShadowView const &shadowView) const;
   ComponentDescriptor const &getComponentDescriptorForShadowView(
       ShadowView const &shadowView) const;
-  std::pair<double, double> calculateAnimationProgress(
-      uint64_t now,
-      LayoutAnimation const &animation,
-      AnimationConfig const &mutationConfig) const;
 
+  /**
+   * Given a `progress` between 0 and 1, a mutation and LayoutAnimation config,
+   * return a ShadowView with mutated props and/or LayoutMetrics.
+   *
+   * @param progress
+   * @param layoutAnimation
+   * @param animatedMutation
+   * @return
+   */
   ShadowView createInterpolatedShadowView(
       double progress,
-      ShadowView startingView,
-      ShadowView finalView) const;
+      ShadowView const &startingView,
+      ShadowView const &finalView) const;
 
   void callCallback(const LayoutAnimationCallbackWrapper &callback) const;
 
@@ -274,88 +139,58 @@ class LayoutAnimationKeyFrameManager : public UIManagerAnimationDelegate,
       AnimationKeyFrame const &keyframe,
       ShadowViewMutation::List &mutationsList,
       bool interrupted,
-      std::string logPrefix) const;
+      const std::string &logPrefix) const;
 
-  SharedComponentDescriptorRegistry componentDescriptorRegistry_;
-  mutable better::optional<LayoutAnimation> currentAnimation_{};
-  mutable std::mutex currentAnimationMutex_;
+ private:
+  RuntimeExecutor runtimeExecutor_;
+  ContextContainer::Shared contextContainer_;
 
-  /**
-   * All mutations of inflightAnimations_ are thread-safe as long as
-   * we keep the contract of: only mutate it within the context of
-   * `pullTransaction`. If that contract is held, this is implicitly protected
-   * by the MountingCoordinator's mutex.
+  mutable std::mutex layoutAnimationStatusDelegateMutex_;
+  mutable LayoutAnimationStatusDelegate *layoutAnimationStatusDelegate_{};
+  mutable std::mutex surfaceIdsToStopMutex_;
+  mutable better::set<SurfaceId> surfaceIdsToStop_{};
+  bool skipInvalidatedKeyFrames_{false};
+
+  /*
+   * Feature flag that forces a crash if component descriptor for shadow view
+   * doesn't exist. This is an unexpected state and we crash to collect extra
+   * logs.
    */
-  mutable std::vector<LayoutAnimation> inflightAnimations_{};
+  bool crashOnMissingComponentDescriptor_{false};
 
- private:
-  // A vector of callable function wrappers that are in the process of being
-  // called
-  mutable std::mutex callbackWrappersPendingMutex_;
-  mutable std::vector<std::unique_ptr<LayoutAnimationCallbackWrapper>>
-      callbackWrappersPending_{};
+  /*
+   * Feature flag that enables simulation of memory access. This is a temporary
+   * flag to diagnose where crashes are coming from in LayoutAnimations on iOS.
+   */
+  bool simulateImagePropsMemoryAccess_{false};
 
- public:
-  void setClockNow(std::function<uint64_t()> now);
-};
+  // Function that returns current time in milliseconds
+  std::function<uint64_t()> now_;
+
+  void adjustImmediateMutationIndicesForDelayedMutations(
+      SurfaceId surfaceId,
+      ShadowViewMutation &mutation,
+      bool skipLastAnimation = false,
+      bool lastAnimationOnly = false) const;
 
-static inline bool shouldFirstComeBeforeSecondRemovesOnly(
-    ShadowViewMutation const &lhs,
-    ShadowViewMutation const &rhs) noexcept {
-  // Make sure that removes on the same level are sorted - highest indices must
-  // come first.
-  return (lhs.type == ShadowViewMutation::Type::Remove &&
-          lhs.type == rhs.type) &&
-      (lhs.parentShadowView.tag == rhs.parentShadowView.tag) &&
-      (lhs.index > rhs.index);
-}
-
-static inline bool shouldFirstComeBeforeSecondMutation(
-    ShadowViewMutation const &lhs,
-    ShadowViewMutation const &rhs) noexcept {
-  if (lhs.type != rhs.type) {
-    // Deletes always come last
-    if (lhs.type == ShadowViewMutation::Type::Delete) {
-      return false;
-    }
-    if (rhs.type == ShadowViewMutation::Type::Delete) {
-      return true;
-    }
-
-    // Remove comes before insert
-    if (lhs.type == ShadowViewMutation::Type::Remove &&
-        rhs.type == ShadowViewMutation::Type::Insert) {
-      return true;
-    }
-    if (rhs.type == ShadowViewMutation::Type::Remove &&
-        lhs.type == ShadowViewMutation::Type::Insert) {
-      return false;
-    }
-
-    // Create comes before insert
-    if (lhs.type == ShadowViewMutation::Type::Create &&
-        rhs.type == ShadowViewMutation::Type::Insert) {
-      return true;
-    }
-    if (rhs.type == ShadowViewMutation::Type::Create &&
-        lhs.type == ShadowViewMutation::Type::Insert) {
-      return false;
-    }
-  } else {
-    // Make sure that removes on the same level are sorted - highest indices
-    // must come first.
-    if (lhs.type == ShadowViewMutation::Type::Remove &&
-        lhs.parentShadowView.tag == rhs.parentShadowView.tag) {
-      if (lhs.index > rhs.index) {
-        return true;
-      } else {
-        return false;
-      }
-    }
-  }
-
-  return false;
-}
+  void adjustDelayedMutationIndicesForMutation(
+      SurfaceId surfaceId,
+      ShadowViewMutation const &mutation,
+      bool skipLastAnimation = false) const;
+
+  void getAndEraseConflictingAnimations(
+      SurfaceId surfaceId,
+      ShadowViewMutationList const &mutations,
+      std::vector<AnimationKeyFrame> &conflictingAnimations) const;
+
+  /*
+   * Removes animations from `inflightAnimations_` for stopped surfaces.
+   */
+  void deleteAnimationsForStoppedSurfaces() const;
+
+  void simulateImagePropsMemoryAccess(
+      ShadowViewMutationList const &mutations) const;
+};
 
 } // namespace react
 } // namespace facebook

package/ReactCommon/react/renderer/animations/conversions.h

@@ -0,0 +1,212 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#include <better/optional.h>
+#include <react/renderer/animations/primitives.h>
+
+#include <glog/logging.h>
+
+namespace facebook {
+namespace react {
+
+static inline better::optional<AnimationType> parseAnimationType(
+    std::string param) {
+  if (param == "spring") {
+    return AnimationType::Spring;
+  }
+  if (param == "linear") {
+    return AnimationType::Linear;
+  }
+  if (param == "easeInEaseOut") {
+    return AnimationType::EaseInEaseOut;
+  }
+  if (param == "easeIn") {
+    return AnimationType::EaseIn;
+  }
+  if (param == "easeOut") {
+    return AnimationType::EaseOut;
+  }
+  if (param == "keyboard") {
+    return AnimationType::Keyboard;
+  }
+
+  LOG(ERROR) << "Error parsing animation type: " << param;
+  return {};
+}
+
+static inline better::optional<AnimationProperty> parseAnimationProperty(
+    std::string param) {
+  if (param == "opacity") {
+    return AnimationProperty::Opacity;
+  }
+  if (param == "scaleX") {
+    return AnimationProperty::ScaleX;
+  }
+  if (param == "scaleY") {
+    return AnimationProperty::ScaleY;
+  }
+  if (param == "scaleXY") {
+    return AnimationProperty::ScaleXY;
+  }
+
+  LOG(ERROR) << "Error parsing animation property: " << param;
+  return {};
+}
+
+static inline better::optional<AnimationConfig> parseAnimationConfig(
+    folly::dynamic const &config,
+    double defaultDuration,
+    bool parsePropertyType) {
+  if (config.empty() || !config.isObject()) {
+    return AnimationConfig{
+        AnimationType::Linear,
+        AnimationProperty::NotApplicable,
+        defaultDuration,
+        0,
+        0,
+        0};
+  }
+
+  auto const typeIt = config.find("type");
+  if (typeIt == config.items().end()) {
+    LOG(ERROR) << "Error parsing animation config: could not find field `type`";
+    return {};
+  }
+  auto const animationTypeParam = typeIt->second;
+  if (animationTypeParam.empty() || !animationTypeParam.isString()) {
+    LOG(ERROR)
+        << "Error parsing animation config: could not unwrap field `type`";
+    return {};
+  }
+  const auto animationType = parseAnimationType(animationTypeParam.asString());
+  if (!animationType) {
+    LOG(ERROR)
+        << "Error parsing animation config: could not parse field `type`";
+    return {};
+  }
+
+  AnimationProperty animationProperty = AnimationProperty::NotApplicable;
+  if (parsePropertyType) {
+    auto const propertyIt = config.find("property");
+    if (propertyIt == config.items().end()) {
+      LOG(ERROR)
+          << "Error parsing animation config: could not find field `property`";
+      return {};
+    }
+    auto const animationPropertyParam = propertyIt->second;
+    if (animationPropertyParam.empty() || !animationPropertyParam.isString()) {
+      LOG(ERROR)
+          << "Error parsing animation config: could not unwrap field `property`";
+      return {};
+    }
+    const auto animationPropertyParsed =
+        parseAnimationProperty(animationPropertyParam.asString());
+    if (!animationPropertyParsed) {
+      LOG(ERROR)
+          << "Error parsing animation config: could not parse field `property`";
+      return {};
+    }
+    animationProperty = *animationPropertyParsed;
+  }
+
+  double duration = defaultDuration;
+  double delay = 0;
+  double springDamping = 0.5;
+  double initialVelocity = 0;
+
+  auto const durationIt = config.find("duration");
+  if (durationIt != config.items().end()) {
+    if (durationIt->second.isDouble()) {
+      duration = durationIt->second.asDouble();
+    } else {
+      LOG(ERROR)
+          << "Error parsing animation config: field `duration` must be a number";
+      return {};
+    }
+  }
+
+  auto const delayIt = config.find("delay");
+  if (delayIt != config.items().end()) {
+    if (delayIt->second.isDouble()) {
+      delay = delayIt->second.asDouble();
+    } else {
+      LOG(ERROR)
+          << "Error parsing animation config: field `delay` must be a number";
+      return {};
+    }
+  }
+
+  auto const springDampingIt = config.find("springDamping");
+  if (springDampingIt != config.items().end() &&
+      springDampingIt->second.isDouble()) {
+    if (springDampingIt->second.isDouble()) {
+      springDamping = springDampingIt->second.asDouble();
+    } else {
+      LOG(ERROR)
+          << "Error parsing animation config: field `springDamping` must be a number";
+      return {};
+    }
+  }
+
+  auto const initialVelocityIt = config.find("initialVelocity");
+  if (initialVelocityIt != config.items().end()) {
+    if (initialVelocityIt->second.isDouble()) {
+      initialVelocity = initialVelocityIt->second.asDouble();
+    } else {
+      LOG(ERROR)
+          << "Error parsing animation config: field `initialVelocity` must be a number";
+      return {};
+    }
+  }
+
+  return better::optional<AnimationConfig>(AnimationConfig{
+      *animationType,
+      animationProperty,
+      duration,
+      delay,
+      springDamping,
+      initialVelocity});
+}
+
+// Parse animation config from JS
+static inline better::optional<LayoutAnimationConfig>
+parseLayoutAnimationConfig(folly::dynamic const &config) {
+  if (config.empty() || !config.isObject()) {
+    return {};
+  }
+
+  const auto durationIt = config.find("duration");
+  if (durationIt == config.items().end() || !durationIt->second.isDouble()) {
+    return {};
+  }
+  const double duration = durationIt->second.asDouble();
+
+  const auto createConfigIt = config.find("create");
+  const auto createConfig = createConfigIt == config.items().end()
+      ? better::optional<AnimationConfig>(AnimationConfig{})
+      : parseAnimationConfig(createConfigIt->second, duration, true);
+
+  const auto updateConfigIt = config.find("update");
+  const auto updateConfig = updateConfigIt == config.items().end()
+      ? better::optional<AnimationConfig>(AnimationConfig{})
+      : parseAnimationConfig(updateConfigIt->second, duration, false);
+
+  const auto deleteConfigIt = config.find("delete");
+  const auto deleteConfig = deleteConfigIt == config.items().end()
+      ? better::optional<AnimationConfig>(AnimationConfig{})
+      : parseAnimationConfig(deleteConfigIt->second, duration, true);
+
+  if (!createConfig || !updateConfig || !deleteConfig) {
+    return {};
+  }
+
+  return LayoutAnimationConfig{
+      duration, *createConfig, *updateConfig, *deleteConfig};
+}
+
+} // namespace react
+} // namespace facebook