react-native-tvos 0.64.2-2 → 0.66.3-0

package/ReactCommon/react/renderer/core/EventQueue.cpp

@@ -14,26 +14,54 @@ namespace facebook {
 namespace react {
 
 EventQueue::EventQueue(
-    EventPipe eventPipe,
-    StatePipe statePipe,
+    EventQueueProcessor eventProcessor,
     std::unique_ptr<EventBeat> eventBeat)
-    : eventPipe_(std::move(eventPipe)),
-      statePipe_(std::move(statePipe)),
+    : eventProcessor_(std::move(eventProcessor)),
       eventBeat_(std::move(eventBeat)) {
   eventBeat_->setBeatCallback(
       std::bind(&EventQueue::onBeat, this, std::placeholders::_1));
 }
 
-void EventQueue::enqueueEvent(const RawEvent &rawEvent) const {
+void EventQueue::enqueueEvent(RawEvent &&rawEvent) const {
   {
     std::lock_guard<std::mutex> lock(queueMutex_);
-    eventQueue_.push_back(rawEvent);
+    eventQueue_.push_back(std::move(rawEvent));
   }
 
   onEnqueue();
 }
 
-void EventQueue::enqueueStateUpdate(const StateUpdate &stateUpdate) const {
+void EventQueue::enqueueUniqueEvent(RawEvent &&rawEvent) const {
+  {
+    std::lock_guard<std::mutex> lock(queueMutex_);
+
+    auto repeatedEvent = eventQueue_.rend();
+
+    for (auto it = eventQueue_.rbegin(); it != eventQueue_.rend(); ++it) {
+      if (it->type == rawEvent.type &&
+          it->eventTarget == rawEvent.eventTarget) {
+        repeatedEvent = it;
+        break;
+      } else if (it->eventTarget == rawEvent.eventTarget) {
+        // It is necessary to maintain order of different event types
+        // for the same target. If the same target has event types A1, B1
+        // in the event queue and event A2 occurs. A1 has to stay in the
+        // queue.
+        break;
+      }
+    }
+
+    if (repeatedEvent == eventQueue_.rend()) {
+      eventQueue_.push_back(std::move(rawEvent));
+    } else {
+      *repeatedEvent = std::move(rawEvent);
+    }
+  }
+
+  onEnqueue();
+}
+
+void EventQueue::enqueueStateUpdate(StateUpdate &&stateUpdate) const {
   {
     std::lock_guard<std::mutex> lock(queueMutex_);
     if (!stateUpdateQueue_.empty()) {
@@ -42,19 +70,15 @@ void EventQueue::enqueueStateUpdate(const StateUpdate &stateUpdate) const {
         stateUpdateQueue_.pop_back();
       }
     }
-    stateUpdateQueue_.push_back(stateUpdate);
+    stateUpdateQueue_.push_back(std::move(stateUpdate));
   }
 
   onEnqueue();
 }
 
-void EventQueue::onEnqueue() const {
-  // Default implementation does nothing.
-}
-
 void EventQueue::onBeat(jsi::Runtime &runtime) const {
-  flushEvents(runtime);
   flushStateUpdates();
+  flushEvents(runtime);
 }
 
 void EventQueue::flushEvents(jsi::Runtime &runtime) const {
@@ -71,30 +95,7 @@ void EventQueue::flushEvents(jsi::Runtime &runtime) const {
     eventQueue_.clear();
   }
 
-  {
-    std::lock_guard<std::mutex> lock(EventEmitter::DispatchMutex());
-
-    for (const auto &event : queue) {
-      if (event.eventTarget) {
-        event.eventTarget->retain(runtime);
-      }
-    }
-  }
-
-  for (const auto &event : queue) {
-    eventPipe_(
-        runtime, event.eventTarget.get(), event.type, event.payloadFactory);
-  }
-
-  // No need to lock `EventEmitter::DispatchMutex()` here.
-  // The mutex protects from a situation when the `instanceHandle` can be
-  // deallocated during accessing, but that's impossible at this point because
-  // we have a strong pointer to it.
-  for (const auto &event : queue) {
-    if (event.eventTarget) {
-      event.eventTarget->release(runtime);
-    }
-  }
+  eventProcessor_.flushEvents(runtime, std::move(queue));
 }
 
 void EventQueue::flushStateUpdates() const {
@@ -111,9 +112,7 @@ void EventQueue::flushStateUpdates() const {
     stateUpdateQueue_.clear();
   }
 
-  for (const auto &stateUpdate : stateUpdateQueue) {
-    statePipe_(stateUpdate);
-  }
+  eventProcessor_.flushStateUpdates(std::move(stateUpdateQueue));
 }
 
 } // namespace react

package/ReactCommon/react/renderer/core/EventQueue.h

@@ -13,9 +13,8 @@
 
 #include <jsi/jsi.h>
 #include <react/renderer/core/EventBeat.h>
-#include <react/renderer/core/EventPipe.h>
+#include <react/renderer/core/EventQueueProcessor.h>
 #include <react/renderer/core/RawEvent.h>
-#include <react/renderer/core/StatePipe.h>
 #include <react/renderer/core/StateUpdate.h>
 
 namespace facebook {
@@ -28,8 +27,7 @@ namespace react {
 class EventQueue {
  public:
   EventQueue(
-      EventPipe eventPipe,
-      StatePipe statePipe,
+      EventQueueProcessor eventProcessor,
       std::unique_ptr<EventBeat> eventBeat);
   virtual ~EventQueue() = default;
 
@@ -37,13 +35,20 @@ class EventQueue {
    * Enqueues and (probably later) dispatch a given event.
    * Can be called on any thread.
    */
-  void enqueueEvent(const RawEvent &rawEvent) const;
+  void enqueueEvent(RawEvent &&rawEvent) const;
+
+  /*
+   * Enqueues and (probably later) dispatches a given event.
+   * Deletes last RawEvent from the queue if it has the same type and target.
+   * Can be called on any thread.
+   */
+  void enqueueUniqueEvent(RawEvent &&rawEvent) const;
 
   /*
    * Enqueues and (probably later) dispatch a given state update.
    * Can be called on any thread.
    */
-  void enqueueStateUpdate(const StateUpdate &stateUpdate) const;
+  void enqueueStateUpdate(StateUpdate &&stateUpdate) const;
 
  protected:
   /*
@@ -51,19 +56,20 @@ class EventQueue {
    * Override in subclasses to trigger beat `request` and/or beat `induce`.
    * Default implementation does nothing.
    */
-  virtual void onEnqueue() const;
+  virtual void onEnqueue() const = 0;
   void onBeat(jsi::Runtime &runtime) const;
 
   void flushEvents(jsi::Runtime &runtime) const;
   void flushStateUpdates() const;
 
-  const EventPipe eventPipe_;
-  const StatePipe statePipe_;
+  EventQueueProcessor eventProcessor_;
+
   const std::unique_ptr<EventBeat> eventBeat_;
   // Thread-safe, protected by `queueMutex_`.
   mutable std::vector<RawEvent> eventQueue_;
   mutable std::vector<StateUpdate> stateUpdateQueue_;
   mutable std::mutex queueMutex_;
+  mutable bool hasContinuousEventStarted_{false};
 };
 
 } // namespace react

package/ReactCommon/react/renderer/core/EventQueueProcessor.cpp

@@ -0,0 +1,82 @@
+/*
+ * 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 "EventQueue.h"
+
+#include "EventEmitter.h"
+#include "ShadowNodeFamily.h"
+
+namespace facebook {
+namespace react {
+
+EventQueueProcessor::EventQueueProcessor(
+    EventPipe eventPipe,
+    StatePipe statePipe)
+    : eventPipe_(std::move(eventPipe)), statePipe_(std::move(statePipe)) {}
+
+void EventQueueProcessor::flushEvents(
+    jsi::Runtime &runtime,
+    std::vector<RawEvent> &&events) const {
+  {
+    std::lock_guard<std::mutex> lock(EventEmitter::DispatchMutex());
+
+    for (const auto &event : events) {
+      if (event.eventTarget) {
+        event.eventTarget->retain(runtime);
+      }
+    }
+  }
+
+  for (auto const &event : events) {
+    if (event.category == RawEvent::Category::ContinuousEnd) {
+      hasContinuousEventStarted_ = false;
+    }
+
+    auto reactPriority = hasContinuousEventStarted_
+        ? ReactEventPriority::Default
+        : ReactEventPriority::Discrete;
+
+    if (event.category == RawEvent::Category::Continuous) {
+      reactPriority = ReactEventPriority::Default;
+    }
+
+    if (event.category == RawEvent::Category::Discrete) {
+      reactPriority = ReactEventPriority::Discrete;
+    }
+
+    eventPipe_(
+        runtime,
+        event.eventTarget.get(),
+        event.type,
+        reactPriority,
+        event.payloadFactory);
+
+    if (event.category == RawEvent::Category::ContinuousStart) {
+      hasContinuousEventStarted_ = true;
+    }
+  }
+
+  // No need to lock `EventEmitter::DispatchMutex()` here.
+  // The mutex protects from a situation when the `instanceHandle` can be
+  // deallocated during accessing, but that's impossible at this point because
+  // we have a strong pointer to it.
+  for (const auto &event : events) {
+    if (event.eventTarget) {
+      event.eventTarget->release(runtime);
+    }
+  }
+}
+
+void EventQueueProcessor::flushStateUpdates(
+    std::vector<StateUpdate> &&states) const {
+  for (const auto &stateUpdate : states) {
+    statePipe_(stateUpdate);
+  }
+}
+
+} // namespace react
+} // namespace facebook

package/ReactCommon/react/renderer/core/EventQueueProcessor.h

@@ -0,0 +1,36 @@
+/*
+ * 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.
+ */
+
+#pragma once
+
+#include <vector>
+
+#include <jsi/jsi.h>
+#include <react/renderer/core/EventPipe.h>
+#include <react/renderer/core/RawEvent.h>
+#include <react/renderer/core/StatePipe.h>
+#include <react/renderer/core/StateUpdate.h>
+
+namespace facebook {
+namespace react {
+
+class EventQueueProcessor {
+ public:
+  EventQueueProcessor(EventPipe eventPipe, StatePipe statePipe);
+
+  void flushEvents(jsi::Runtime &runtime, std::vector<RawEvent> &&events) const;
+  void flushStateUpdates(std::vector<StateUpdate> &&states) const;
+
+ private:
+  EventPipe const eventPipe_;
+  StatePipe const statePipe_;
+
+  mutable bool hasContinuousEventStarted_{false};
+};
+
+} // namespace react
+} // namespace facebook

package/ReactCommon/react/renderer/core/EventTarget.cpp

@@ -7,6 +7,8 @@
 
 #include "EventTarget.h"
 
+#include <react/debug/react_native_assert.h>
+
 namespace facebook {
 namespace react {
 
@@ -38,8 +40,8 @@ void EventTarget::retain(jsi::Runtime &runtime) const {
   // particular implementation of JSI was able to detect this inconsistency and
   // dealt with it, but some JSI implementation may not support this feature and
   // that case will lead to a crash in those environments.
-  assert(!strongInstanceHandle_.isNull());
-  assert(!strongInstanceHandle_.isUndefined());
+  react_native_assert(!strongInstanceHandle_.isNull());
+  react_native_assert(!strongInstanceHandle_.isUndefined());
 }
 
 void EventTarget::release(jsi::Runtime &runtime) const {

package/ReactCommon/react/renderer/core/LayoutConstraints.h

@@ -21,8 +21,9 @@ namespace react {
  */
 struct LayoutConstraints {
   Size minimumSize{0, 0};
-  Size maximumSize{std::numeric_limits<Float>::infinity(),
-                   std::numeric_limits<Float>::infinity()};
+  Size maximumSize{
+      std::numeric_limits<Float>::infinity(),
+      std::numeric_limits<Float>::infinity()};
   LayoutDirection layoutDirection{LayoutDirection::Undefined};
 
   /*
@@ -39,6 +40,12 @@ inline bool operator==(
       std::tie(rhs.minimumSize, rhs.maximumSize, rhs.layoutDirection);
 }
 
+inline bool operator!=(
+    const LayoutConstraints &lhs,
+    const LayoutConstraints &rhs) {
+  return !(lhs == rhs);
+}
+
 } // namespace react
 } // namespace facebook
 

package/ReactCommon/react/renderer/core/LayoutMetrics.cpp

@@ -0,0 +1,65 @@
+/*
+ * 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 <react/renderer/debug/DebugStringConvertible.h>
+#include <react/renderer/debug/flags.h>
+
+#include "LayoutMetrics.h"
+
+namespace facebook {
+namespace react {
+
+#if RN_DEBUG_STRING_CONVERTIBLE
+
+std::string getDebugName(LayoutMetrics const &object) {
+  return "LayoutMetrics";
+}
+
+std::vector<DebugStringConvertibleObject> getDebugProps(
+    LayoutMetrics const &object,
+    DebugStringConvertibleOptions options) {
+  return {
+      {"frame",
+       "{x:" + getDebugDescription(object.frame.origin.x, {}) +
+           ",y:" + getDebugDescription(object.frame.origin.y, {}) +
+           ",width:" + getDebugDescription(object.frame.size.width, {}) +
+           ",height:" + getDebugDescription(object.frame.size.height, {}) +
+           "}"},
+      {"contentInsets",
+       "{top:" + getDebugDescription(object.contentInsets.top, {}) +
+           ",right:" + getDebugDescription(object.contentInsets.right, {}) +
+           ",bottom:" + getDebugDescription(object.contentInsets.bottom, {}) +
+           ",left:" + getDebugDescription(object.contentInsets.left, {}) + "}"},
+      {"borderWidth",
+       "{top:" + getDebugDescription(object.borderWidth.top, {}) +
+           ",right:" + getDebugDescription(object.borderWidth.right, {}) +
+           ",bottom:" + getDebugDescription(object.borderWidth.bottom, {}) +
+           ",left:" + getDebugDescription(object.borderWidth.left, {}) + "}"},
+      {"overflowInset",
+       "{top:" + getDebugDescription(object.overflowInset.top, {}) +
+           ",right:" + getDebugDescription(object.overflowInset.right, {}) +
+           ",bottom:" + getDebugDescription(object.overflowInset.bottom, {}) +
+           ",left:" + getDebugDescription(object.overflowInset.left, {}) + "}"},
+      {"displayType",
+       object.displayType == DisplayType::None
+           ? "None"
+           : (object.displayType == DisplayType::Flex ? "Flex" : "Inline")},
+      {"layoutDirection",
+       object.layoutDirection == LayoutDirection::Undefined
+           ? "Undefined"
+           : (object.layoutDirection == LayoutDirection::LeftToRight
+                  ? "LeftToRight"
+                  : "RightToLeft")},
+      {"pointScaleFactor",
+       getDebugDescription(object.pointScaleFactor, options)},
+  };
+}
+
+#endif
+
+} // namespace react
+} // namespace facebook

package/ReactCommon/react/renderer/core/LayoutMetrics.h

@@ -7,7 +7,10 @@
 
 #pragma once
 
+#include <folly/Hash.h>
 #include <react/renderer/core/LayoutPrimitives.h>
+#include <react/renderer/debug/DebugStringConvertible.h>
+#include <react/renderer/debug/flags.h>
 #include <react/renderer/graphics/Geometry.h>
 
 namespace facebook {
@@ -28,8 +31,9 @@ struct LayoutMetrics {
   Rect getContentFrame() const {
     return Rect{
         Point{contentInsets.left, contentInsets.top},
-        Size{frame.size.width - contentInsets.left - contentInsets.right,
-             frame.size.height - contentInsets.top - contentInsets.bottom}};
+        Size{
+            frame.size.width - contentInsets.left - contentInsets.right,
+            frame.size.height - contentInsets.top - contentInsets.bottom}};
   }
 
   bool operator==(const LayoutMetrics &rhs) const {
@@ -39,14 +43,16 @@ struct LayoutMetrics {
                this->borderWidth,
                this->displayType,
                this->layoutDirection,
-               this->pointScaleFactor) ==
+               this->pointScaleFactor,
+               this->overflowInset) ==
         std::tie(
                rhs.frame,
                rhs.contentInsets,
                rhs.borderWidth,
                rhs.displayType,
                rhs.layoutDirection,
-               rhs.pointScaleFactor);
+               rhs.pointScaleFactor,
+               rhs.overflowInset);
   }
 
   bool operator!=(const LayoutMetrics &rhs) const {
@@ -62,5 +68,33 @@ struct LayoutMetrics {
 static LayoutMetrics const EmptyLayoutMetrics = {
     /* .frame = */ {{0, 0}, {-1.0, -1.0}}};
 
+#ifdef RN_DEBUG_STRING_CONVERTIBLE
+
+std::string getDebugName(LayoutMetrics const &object);
+std::vector<DebugStringConvertibleObject> getDebugProps(
+    LayoutMetrics const &object,
+    DebugStringConvertibleOptions options);
+
+#endif
+
 } // namespace react
 } // namespace facebook
+
+namespace std {
+
+template <>
+struct hash<facebook::react::LayoutMetrics> {
+  size_t operator()(const facebook::react::LayoutMetrics &layoutMetrics) const {
+    return folly::hash::hash_combine(
+        0,
+        layoutMetrics.frame,
+        layoutMetrics.contentInsets,
+        layoutMetrics.borderWidth,
+        layoutMetrics.displayType,
+        layoutMetrics.layoutDirection,
+        layoutMetrics.pointScaleFactor,
+        layoutMetrics.overflowInset);
+  }
+};
+
+} // namespace std

package/ReactCommon/react/renderer/core/LayoutPrimitives.h

@@ -18,18 +18,18 @@ namespace react {
  * engine which should be used for laying out the node.
  */
 enum class DisplayType {
-  None,
-  Flex,
-  Inline,
+  None = 0,
+  Flex = 1,
+  Inline = 2,
 };
 
 /*
  * User interface layout direction.
  */
 enum class LayoutDirection {
-  Undefined,
-  LeftToRight,
-  RightToLeft,
+  Undefined = 0,
+  LeftToRight = 1,
+  RightToLeft = 2,
 };
 
 } // namespace react
@@ -42,4 +42,12 @@ struct hash<facebook::react::LayoutDirection> {
     return hash<int>()(static_cast<int>(v));
   }
 };
+
+template <>
+struct hash<facebook::react::DisplayType> {
+  size_t operator()(const facebook::react::DisplayType &v) const {
+    return hash<int>()(static_cast<int>(v));
+  }
+};
+
 } // namespace std

package/ReactCommon/react/renderer/core/LayoutableShadowNode.cpp

@@ -159,13 +159,6 @@ Point LayoutableShadowNode::getContentOriginOffset() const {
   return {0, 0};
 }
 
-LayoutMetrics LayoutableShadowNode::getRelativeLayoutMetrics(
-    LayoutableShadowNode const &ancestorLayoutableShadowNode,
-    LayoutInspectingPolicy policy) const {
-  return computeRelativeLayoutMetrics(
-      getFamily(), ancestorLayoutableShadowNode, policy);
-}
-
 LayoutableShadowNode::UnsharedList
 LayoutableShadowNode::getLayoutableChildNodes() const {
   LayoutableShadowNode::UnsharedList layoutableChildren;
@@ -223,7 +216,7 @@ ShadowNode::Shared LayoutableShadowNode::findNodeAtPoint(
     ShadowNode::Shared node,
     Point point) {
   auto layoutableShadowNode =
-      dynamic_cast<const LayoutableShadowNode *>(node.get());
+      traitCast<const LayoutableShadowNode *>(node.get());
 
   if (!layoutableShadowNode) {
     return nullptr;

package/ReactCommon/react/renderer/core/LayoutableShadowNode.h

@@ -13,6 +13,7 @@
 #include <vector>
 
 #include <better/small_vector.h>
+#include <react/debug/react_native_assert.h>
 #include <react/renderer/core/LayoutMetrics.h>
 #include <react/renderer/core/ShadowNode.h>
 #include <react/renderer/core/ShadowNodeFragment.h>
@@ -122,21 +123,6 @@ class LayoutableShadowNode : public ShadowNode {
    */
   virtual Point getContentOriginOffset() const;
 
-  /*
-   * Returns layout metrics relatively to the given ancestor node.
-   * Uses `computeRelativeLayoutMetrics()` under the hood.
-   */
-  LayoutMetrics getRelativeLayoutMetrics(
-      ShadowNodeFamily const &descendantNodeFamily,
-      LayoutInspectingPolicy policy) const;
-
-  /*
-   * Returns layout metrics relatively to the given ancestor node.
-   */
-  LayoutMetrics getRelativeLayoutMetrics(
-      LayoutableShadowNode const &ancestorLayoutableShadowNode,
-      LayoutInspectingPolicy policy) const;
-
   /*
    * Sets layout metrics for the shadow node.
    */
@@ -184,10 +170,7 @@ inline LayoutableShadowNode const &traitCast<LayoutableShadowNode const &>(
     ShadowNode const &shadowNode) {
   bool castable =
       shadowNode.getTraits().check(ShadowNodeTraits::Trait::LayoutableKind);
-  assert(
-      castable ==
-      (dynamic_cast<LayoutableShadowNode const *>(&shadowNode) != nullptr));
-  assert(castable);
+  react_native_assert(castable);
   (void)castable;
   return static_cast<LayoutableShadowNode const &>(shadowNode);
 }
@@ -200,9 +183,6 @@ inline LayoutableShadowNode const *traitCast<LayoutableShadowNode const *>(
   }
   bool castable =
       shadowNode->getTraits().check(ShadowNodeTraits::Trait::LayoutableKind);
-  assert(
-      castable ==
-      (dynamic_cast<LayoutableShadowNode const *>(shadowNode) != nullptr));
   if (!castable) {
     return nullptr;
   }

package/ReactCommon/react/renderer/core/Props.cpp

@@ -13,8 +13,16 @@
 namespace facebook {
 namespace react {
 
-Props::Props(const Props &sourceProps, const RawProps &rawProps)
-    : nativeId(convertRawProp(rawProps, "nativeID", sourceProps.nativeId, {})),
+Props::Props(
+    const PropsParserContext &context,
+    const Props &sourceProps,
+    const RawProps &rawProps)
+    : nativeId(convertRawProp(
+          context,
+          rawProps,
+          "nativeID",
+          sourceProps.nativeId,
+          {})),
       revision(sourceProps.revision + 1)
 #ifdef ANDROID
       ,

package/ReactCommon/react/renderer/core/Props.h

@@ -9,6 +9,7 @@
 
 #include <folly/dynamic.h>
 
+#include <react/renderer/core/PropsParserContext.h>
 #include <react/renderer/core/ReactPrimitives.h>
 #include <react/renderer/core/Sealable.h>
 #include <react/renderer/debug/DebugStringConvertible.h>
@@ -28,7 +29,10 @@ class Props : public virtual Sealable, public virtual DebugStringConvertible {
   using Shared = std::shared_ptr<Props const>;
 
   Props() = default;
-  Props(Props const &sourceProps, RawProps const &rawProps);
+  Props(
+      const PropsParserContext &context,
+      const Props &sourceProps,
+      RawProps const &rawProps);
   virtual ~Props() = default;
 
   std::string nativeId;

package/ReactCommon/react/renderer/core/PropsParserContext.h

@@ -0,0 +1,28 @@
+/*
+ * 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.
+ */
+
+#pragma once
+
+#include <react/utils/ContextContainer.h>
+
+namespace facebook {
+namespace react {
+
+// For props requiring some context to parse, this toolbox can be used.
+// It should be used as infrequently as possible - most props can and should
+// be parsed without any context.
+struct PropsParserContext {
+  // Non-copyable
+  PropsParserContext(const PropsParserContext &) = delete;
+  PropsParserContext &operator=(const PropsParserContext &) = delete;
+
+  int surfaceId; // TODO: use SurfaceId type
+  const ContextContainer &contextContainer;
+};
+
+} // namespace react
+} // namespace facebook