Pass event priority to React

sammy-SC · facebook-github-bot · commit 2016460528ef · 2021-05-25T01:16:04.000-07:00
Summary:
Changelog: [internal]

This is a mechanism that will guess event's React priority based on other events ongoing on the platform.

If an event happens within span of ContinuousStart -&gt; ContinuousEnd and its category is unspecified, we deduce it's React priority to be default. All other events are discrete.

Special case: `onScroll`, which is always treated as "Default".

Reviewed By: JoshuaGross

Differential Revision: D28485060

fbshipit-source-id: d2eae63dbcf03271dfed97128a1590dd165a3ce2
diff --git a/ReactCommon/react/renderer/components/view/TouchEventEmitter.cpp b/ReactCommon/react/renderer/components/view/TouchEventEmitter.cpp
@@ -62,17 +62,23 @@ static jsi::Value touchEventPayload(
 void TouchEventEmitter::dispatchTouchEvent(
     std::string const &type,
     TouchEvent const &event,
-    EventPriority const &priority) const {
+    EventPriority priority,
+    RawEvent::Category category) const {
   dispatchEvent(
       type,
       [event](jsi::Runtime &runtime) {
         return touchEventPayload(runtime, event);
       },
-      priority);
+      priority,
+      category);
 }
 
 void TouchEventEmitter::onTouchStart(TouchEvent const &event) const {
-  dispatchTouchEvent("touchStart", event, EventPriority::AsynchronousBatched);
+  dispatchTouchEvent(
+      "touchStart",
+      event,
+      EventPriority::AsynchronousBatched,
+      RawEvent::Category::ContinuousStart);
 }
 
 void TouchEventEmitter::onTouchMove(TouchEvent const &event) const {
@@ -82,11 +88,19 @@ void TouchEventEmitter::onTouchMove(TouchEvent const &event) const {
 }
 
 void TouchEventEmitter::onTouchEnd(TouchEvent const &event) const {
-  dispatchTouchEvent("touchEnd", event, EventPriority::AsynchronousBatched);
+  dispatchTouchEvent(
+      "touchEnd",
+      event,
+      EventPriority::AsynchronousBatched,
+      RawEvent::Category::ContinuousEnd);
 }
 
 void TouchEventEmitter::onTouchCancel(TouchEvent const &event) const {
-  dispatchTouchEvent("touchCancel", event, EventPriority::AsynchronousBatched);
+  dispatchTouchEvent(
+      "touchCancel",
+      event,
+      EventPriority::AsynchronousBatched,
+      RawEvent::Category::ContinuousEnd);
 }
 
 } // namespace react
diff --git a/ReactCommon/react/renderer/components/view/TouchEventEmitter.h b/ReactCommon/react/renderer/components/view/TouchEventEmitter.h
@@ -33,7 +33,8 @@ class TouchEventEmitter : public EventEmitter {
   void dispatchTouchEvent(
       std::string const &type,
       TouchEvent const &event,
-      EventPriority const &priority) const;
+      EventPriority priority,
+      RawEvent::Category category) const;
 };
 
 } // namespace react
diff --git a/ReactCommon/react/renderer/core/BUCK b/ReactCommon/react/renderer/core/BUCK
@@ -87,6 +87,7 @@ fb_xplat_cxx_test(
         "//xplat/third-party/gmock:gtest",
         react_native_xplat_target("react/renderer/components/view:view"),
         ":core",
+        "//xplat/hermes/API:HermesAPI",
     ],
 )
 
diff --git a/ReactCommon/react/renderer/core/EventDispatcher.h b/ReactCommon/react/renderer/core/EventDispatcher.h
@@ -17,7 +17,7 @@
 namespace facebook {
 namespace react {
 
-class RawEvent;
+struct RawEvent;
 
 /*
  * Represents event-delivery infrastructure.
diff --git a/ReactCommon/react/renderer/core/EventEmitter.cpp b/ReactCommon/react/renderer/core/EventEmitter.cpp
@@ -53,12 +53,9 @@ void EventEmitter::dispatchEvent(
     const std::string &type,
     const folly::dynamic &payload,
     EventPriority priority) const {
-  dispatchEvent(
-      type,
-      [payload](jsi::Runtime &runtime) {
-        return valueFromDynamic(runtime, payload);
-      },
-      priority);
+  dispatchEvent(type, [payload](jsi::Runtime &runtime) {
+    return valueFromDynamic(runtime, payload);
+  });
 }
 
 void EventEmitter::dispatchUniqueEvent(
@@ -72,7 +69,8 @@ void EventEmitter::dispatchUniqueEvent(
 void EventEmitter::dispatchEvent(
     const std::string &type,
     const ValueFactory &payloadFactory,
-    EventPriority priority) const {
+    EventPriority priority,
+    RawEvent::Category category) const {
   SystraceSection s("EventEmitter::dispatchEvent");
 
   auto eventDispatcher = eventDispatcher_.lock();
@@ -81,7 +79,8 @@ void EventEmitter::dispatchEvent(
   }
 
   eventDispatcher->dispatchEvent(
-      RawEvent(normalizeEventType(type), payloadFactory, eventTarget_),
+      RawEvent(
+          normalizeEventType(type), payloadFactory, eventTarget_, category),
       priority);
 }
 
@@ -95,8 +94,11 @@ void EventEmitter::dispatchUniqueEvent(
     return;
   }
 
-  eventDispatcher->dispatchUniqueEvent(
-      RawEvent(normalizeEventType(type), payloadFactory, eventTarget_));
+  eventDispatcher->dispatchUniqueEvent(RawEvent(
+      normalizeEventType(type),
+      payloadFactory,
+      eventTarget_,
+      RawEvent::Category::Continuous));
 }
 
 void EventEmitter::setEnabled(bool enabled) const {
diff --git a/ReactCommon/react/renderer/core/EventEmitter.h b/ReactCommon/react/renderer/core/EventEmitter.h
@@ -71,7 +71,8 @@ class EventEmitter {
       const std::string &type,
       const ValueFactory &payloadFactory =
           EventEmitter::defaultPayloadFactory(),
-      EventPriority priority = EventPriority::AsynchronousBatched) const;
+      EventPriority priority = EventPriority::AsynchronousBatched,
+      RawEvent::Category category = RawEvent::Category::Unspecified) const;
 
   void dispatchEvent(
       const std::string &type,
diff --git a/ReactCommon/react/renderer/core/EventQueue.h b/ReactCommon/react/renderer/core/EventQueue.h
@@ -69,6 +69,7 @@ class EventQueue {
   mutable std::vector<RawEvent> eventQueue_;
   mutable std::vector<StateUpdate> stateUpdateQueue_;
   mutable std::mutex queueMutex_;
+  mutable bool hasContinuousEventStarted_{false};
 };
 
 } // namespace react
diff --git a/ReactCommon/react/renderer/core/EventQueueProcessor.cpp b/ReactCommon/react/renderer/core/EventQueueProcessor.cpp
@@ -31,13 +31,33 @@ void EventQueueProcessor::flushEvents(
     }
   }
 
-  for (const auto &event : events) {
+  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,
-        ReactEventPriority::Default,
+        reactPriority,
         event.payloadFactory);
+
+    if (event.category == RawEvent::Category::ContinuousStart) {
+      hasContinuousEventStarted_ = true;
+    }
   }
 
   // No need to lock `EventEmitter::DispatchMutex()` here.
diff --git a/ReactCommon/react/renderer/core/EventQueueProcessor.h b/ReactCommon/react/renderer/core/EventQueueProcessor.h
@@ -28,6 +28,8 @@ class EventQueueProcessor {
  private:
   EventPipe const eventPipe_;
   StatePipe const statePipe_;
+
+  mutable bool hasContinuousEventStarted_{false};
 };
 
 } // namespace react
diff --git a/ReactCommon/react/renderer/core/RawEvent.cpp b/ReactCommon/react/renderer/core/RawEvent.cpp
@@ -13,10 +13,12 @@ namespace react {
 RawEvent::RawEvent(
     std::string type,
     ValueFactory payloadFactory,
-    SharedEventTarget eventTarget)
+    SharedEventTarget eventTarget,
+    Category category)
     : type(std::move(type)),
       payloadFactory(std::move(payloadFactory)),
-      eventTarget(std::move(eventTarget)) {}
+      eventTarget(std::move(eventTarget)),
+      category(category) {}
 
 } // namespace react
 } // namespace facebook
diff --git a/ReactCommon/react/renderer/core/RawEvent.h b/ReactCommon/react/renderer/core/RawEvent.h
@@ -19,16 +19,53 @@ namespace react {
 /*
  * Represents ready-to-dispatch event object.
  */
-class RawEvent {
- public:
+struct RawEvent {
+  /*
+   * Defines category of a native platform event. This is used to deduce types
+   * of events for Concurrent Mode.
+   */
+  enum class Category {
+    /*
+     * Start of a continuous event. To be used with touchStart.
+     */
+    ContinuousStart,
+
+    /*
+     * End of a continuous event. To be used with touchEnd.
+     */
+    ContinuousEnd,
+
+    /*
+     * Priority for this event will be determined from other events in the
+     * queue. If it is triggered by continuous event, its priority will be
+     * default. If it is not triggered by continuous event, its priority will be
+     * discrete.
+     */
+    Unspecified,
+
+    /*
+     * Forces discrete type for the event. Regardless if continuous event is
+     * ongoing.
+     */
+    Discrete,
+
+    /*
+     * Forces continuous type for the event. Regardless if continuous event
+     * isn't ongoing.
+     */
+    Continuous
+  };
+
   RawEvent(
       std::string type,
       ValueFactory payloadFactory,
-      SharedEventTarget eventTarget);
+      SharedEventTarget eventTarget,
+      Category category = Category::Unspecified);
 
   std::string type;
   ValueFactory payloadFactory;
   SharedEventTarget eventTarget;
+  Category category;
 };
 
 } // namespace react
diff --git a/ReactCommon/react/renderer/core/tests/EventQueueProcessorTest.cpp b/ReactCommon/react/renderer/core/tests/EventQueueProcessorTest.cpp
@@ -0,0 +1,134 @@
+/*
+ * 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 <gtest/gtest.h>
+#include <hermes/API/hermes/hermes.h>
+#include <jsi/jsi.h>
+#include <react/renderer/core/EventPipe.h>
+#include <react/renderer/core/EventQueueProcessor.h>
+#include <react/renderer/core/StatePipe.h>
+
+#include <memory>
+
+namespace facebook::react {
+
+class EventQueueProcessorTest : public testing::Test {
+ protected:
+  void SetUp() override {
+    runtime_ = facebook::hermes::makeHermesRuntime();
+
+    auto eventPipe = [this](
+                         jsi::Runtime &runtime,
+                         const EventTarget *eventTarget,
+                         const std::string &type,
+                         ReactEventPriority priority,
+                         const ValueFactory &payloadFactory) {
+      eventTypes_.push_back(type);
+      eventPriorities_.push_back(priority);
+    };
+
+    auto dummyStatePipe = [](StateUpdate const &stateUpdate) {};
+
+    eventProcessor_ =
+        std::make_unique<EventQueueProcessor>(eventPipe, dummyStatePipe);
+  }
+
+  std::unique_ptr<facebook::hermes::HermesRuntime> runtime_;
+  std::unique_ptr<EventQueueProcessor> eventProcessor_;
+  std::vector<std::string> eventTypes_;
+  std::vector<ReactEventPriority> eventPriorities_;
+  ValueFactory dummyValueFactory_;
+};
+
+TEST_F(EventQueueProcessorTest, singleUnspecifiedEvent) {
+  eventProcessor_->flushEvents(
+      *runtime_,
+      {RawEvent(
+          "my type",
+          dummyValueFactory_,
+          nullptr,
+          RawEvent::Category::Unspecified)});
+
+  EXPECT_EQ(eventPriorities_.size(), 1);
+  EXPECT_EQ(eventTypes_[0], "my type");
+  EXPECT_EQ(eventPriorities_[0], ReactEventPriority::Discrete);
+}
+
+TEST_F(EventQueueProcessorTest, continiousEvent) {
+  eventProcessor_->flushEvents(
+      *runtime_,
+      {RawEvent(
+           "touchStart",
+           dummyValueFactory_,
+           nullptr,
+           RawEvent::Category::ContinuousStart),
+       RawEvent(
+           "touchMove",
+           dummyValueFactory_,
+           nullptr,
+           RawEvent::Category::Unspecified),
+       RawEvent(
+           "touchEnd",
+           dummyValueFactory_,
+           nullptr,
+           RawEvent::Category::ContinuousEnd),
+       RawEvent(
+           "custom event",
+           dummyValueFactory_,
+           nullptr,
+           RawEvent::Category::Unspecified)});
+
+  EXPECT_EQ(eventPriorities_.size(), 4);
+
+  EXPECT_EQ(eventTypes_[0], "touchStart");
+  EXPECT_EQ(eventPriorities_[0], ReactEventPriority::Discrete);
+
+  EXPECT_EQ(eventTypes_[1], "touchMove");
+  EXPECT_EQ(eventPriorities_[1], ReactEventPriority::Default);
+
+  EXPECT_EQ(eventTypes_[2], "touchEnd");
+  EXPECT_EQ(eventPriorities_[2], ReactEventPriority::Discrete);
+
+  EXPECT_EQ(eventTypes_[3], "custom event");
+  EXPECT_EQ(eventPriorities_[3], ReactEventPriority::Discrete);
+}
+
+TEST_F(EventQueueProcessorTest, alwaysContinuousEvent) {
+  eventProcessor_->flushEvents(
+      *runtime_,
+      {
+          RawEvent(
+              "onScroll",
+              dummyValueFactory_,
+              nullptr,
+              RawEvent::Category::Continuous),
+      });
+
+  EXPECT_EQ(eventPriorities_.size(), 1);
+
+  EXPECT_EQ(eventTypes_[0], "onScroll");
+  EXPECT_EQ(eventPriorities_[0], ReactEventPriority::Default);
+}
+
+TEST_F(EventQueueProcessorTest, alwaysDiscreteEvent) {
+  eventProcessor_->flushEvents(
+      *runtime_,
+      {
+          RawEvent(
+              "onChange",
+              dummyValueFactory_,
+              nullptr,
+              RawEvent::Category::Discrete),
+      });
+
+  EXPECT_EQ(eventPriorities_.size(), 1);
+
+  EXPECT_EQ(eventTypes_[0], "onChange");
+  EXPECT_EQ(eventPriorities_[0], ReactEventPriority::Discrete);
+}
+
+} // namespace facebook::react

Original file line number	Diff line number	Diff line change
`@@ -87,6 +87,7 @@ fb_xplat_cxx_test(`
`87`	`87`	`"//xplat/third-party/gmock:gtest",`
`88`	`88`	`react_native_xplat_target("react/renderer/components/view:view"),`
`89`	`89`	`":core",`
	`90`	`+ "//xplat/hermes/API:HermesAPI",`
`90`	`91`	`],`
`91`	`92`	`)`
`92`	`93`