react-native 0.0.0-e81029179 → 0.0.0-e9440508e-20211011-2008

package/ReactCommon/react/renderer/runtimescheduler/RuntimeScheduler.h

@@ -0,0 +1,105 @@
+/*
+ * 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 <ReactCommon/RuntimeExecutor.h>
+#include <react/renderer/runtimescheduler/RuntimeSchedulerClock.h>
+#include <react/renderer/runtimescheduler/Task.h>
+#include <atomic>
+#include <memory>
+#include <queue>
+
+namespace facebook {
+namespace react {
+
+class RuntimeScheduler final {
+ public:
+  RuntimeScheduler(
+      RuntimeExecutor const &runtimeExecutor,
+      std::function<RuntimeSchedulerTimePoint()> now =
+          RuntimeSchedulerClock::now);
+  /*
+   * Not copyable.
+   */
+  RuntimeScheduler(RuntimeScheduler const &) = delete;
+  RuntimeScheduler &operator=(RuntimeScheduler const &) = delete;
+
+  /*
+   * Not movable.
+   */
+  RuntimeScheduler(RuntimeScheduler &&) = delete;
+  RuntimeScheduler &operator=(RuntimeScheduler &&) = delete;
+
+  void scheduleWork(std::function<void(jsi::Runtime &)> callback) const;
+
+  /*
+   * Grants access to the runtime synchronously on the caller's thread.
+   *
+   * Shouldn't be called directly. it is expected to be used
+   * by dispatching a synchronous event via event emitter in your native
+   * component.
+   */
+  void executeNowOnTheSameThread(
+      std::function<void(jsi::Runtime &runtime)> callback) const;
+
+  std::shared_ptr<Task> scheduleTask(
+      SchedulerPriority priority,
+      jsi::Function callback);
+
+  void cancelTask(std::shared_ptr<Task> const &task) noexcept;
+
+  bool getShouldYield() const noexcept;
+
+  SchedulerPriority getCurrentPriorityLevel() const noexcept;
+
+  RuntimeSchedulerTimePoint now() const noexcept;
+
+  void setEnableYielding(bool enableYielding);
+
+ private:
+  mutable std::priority_queue<
+      std::shared_ptr<Task>,
+      std::vector<std::shared_ptr<Task>>,
+      TaskPriorityComparer>
+      taskQueue_;
+
+  RuntimeExecutor const runtimeExecutor_;
+  mutable SchedulerPriority currentPriority_{SchedulerPriority::NormalPriority};
+  mutable std::atomic_bool shouldYield_{false};
+
+  void startWorkLoop(jsi::Runtime &runtime) const;
+
+  /*
+   * Returns a time point representing the current point in time. May be called
+   * from multiple threads.
+   */
+  std::function<RuntimeSchedulerTimePoint()> now_;
+
+  /*
+   * Flag indicating if callback on JavaScript queue has been
+   * scheduled.
+   */
+  std::atomic_bool isCallbackScheduled_{false};
+
+  /*
+   * Flag indicating if yielding is enabled.
+   *
+   * If set to true and Concurrent Mode is enabled on the surface,
+   * React Native will ask React to yield in case any work has been scheduled.
+   * Default value is false
+   */
+  bool enableYielding_{false};
+
+  /*
+   * This flag is set while performing work, to prevent re-entrancy.
+   */
+  mutable bool isPerformingWork_{false};
+};
+
+} // namespace react
+} // namespace facebook

package/ReactCommon/react/renderer/runtimescheduler/RuntimeSchedulerBinding.cpp

@@ -0,0 +1,171 @@
+/*
+ * 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 "RuntimeSchedulerBinding.h"
+#include "SchedulerPriority.h"
+#include "primitives.h"
+
+#include <react/debug/react_native_assert.h>
+#include <chrono>
+#include <memory>
+
+namespace facebook {
+namespace react {
+
+std::shared_ptr<RuntimeSchedulerBinding>
+RuntimeSchedulerBinding::createAndInstallIfNeeded(
+    jsi::Runtime &runtime,
+    std::shared_ptr<RuntimeScheduler> const &runtimeScheduler) {
+  auto runtimeSchedulerModuleName = "nativeRuntimeScheduler";
+
+  auto runtimeSchedulerValue =
+      runtime.global().getProperty(runtime, runtimeSchedulerModuleName);
+  if (runtimeSchedulerValue.isUndefined()) {
+    // The global namespace does not have an instance of the binding;
+    // we need to create, install and return it.
+    auto runtimeSchedulerBinding =
+        std::make_shared<RuntimeSchedulerBinding>(runtimeScheduler);
+    auto object =
+        jsi::Object::createFromHostObject(runtime, runtimeSchedulerBinding);
+    runtime.global().setProperty(
+        runtime, runtimeSchedulerModuleName, std::move(object));
+    return runtimeSchedulerBinding;
+  }
+
+  // The global namespace already has an instance of the binding;
+  // we need to return that.
+  auto runtimeSchedulerObject = runtimeSchedulerValue.asObject(runtime);
+  return runtimeSchedulerObject.getHostObject<RuntimeSchedulerBinding>(runtime);
+}
+
+RuntimeSchedulerBinding::RuntimeSchedulerBinding(
+    std::shared_ptr<RuntimeScheduler> const &runtimeScheduler)
+    : runtimeScheduler_(runtimeScheduler) {}
+
+jsi::Value RuntimeSchedulerBinding::get(
+    jsi::Runtime &runtime,
+    jsi::PropNameID const &name) {
+  auto propertyName = name.utf8(runtime);
+
+  if (propertyName == "unstable_scheduleCallback") {
+    return jsi::Function::createFromHostFunction(
+        runtime,
+        name,
+        3,
+        [this](
+            jsi::Runtime &runtime,
+            jsi::Value const &,
+            jsi::Value const *arguments,
+            size_t) noexcept -> jsi::Value {
+          SchedulerPriority priority = fromRawValue(arguments[0].getNumber());
+          auto callback = arguments[1].getObject(runtime).getFunction(runtime);
+
+          auto task =
+              runtimeScheduler_->scheduleTask(priority, std::move(callback));
+
+          return valueFromTask(runtime, task);
+        });
+  }
+
+  if (propertyName == "unstable_cancelCallback") {
+    return jsi::Function::createFromHostFunction(
+        runtime,
+        name,
+        1,
+        [this](
+            jsi::Runtime &runtime,
+            jsi::Value const &,
+            jsi::Value const *arguments,
+            size_t) noexcept -> jsi::Value {
+          runtimeScheduler_->cancelTask(taskFromValue(runtime, arguments[0]));
+          return jsi::Value::undefined();
+        });
+  }
+
+  if (propertyName == "unstable_shouldYield") {
+    return jsi::Function::createFromHostFunction(
+        runtime,
+        name,
+        0,
+        [this](
+            jsi::Runtime &,
+            jsi::Value const &,
+            jsi::Value const *,
+            size_t) noexcept -> jsi::Value {
+          auto shouldYield = runtimeScheduler_->getShouldYield();
+          return jsi::Value(shouldYield);
+        });
+  }
+
+  if (propertyName == "unstable_requestPaint") {
+    return jsi::Function::createFromHostFunction(
+        runtime,
+        name,
+        0,
+        [](jsi::Runtime &,
+           jsi::Value const &,
+           jsi::Value const *,
+           size_t) noexcept -> jsi::Value {
+          // RequestPaint is left empty by design.
+          return jsi::Value::undefined();
+        });
+  }
+
+  if (propertyName == "unstable_now") {
+    return jsi::Function::createFromHostFunction(
+        runtime,
+        name,
+        0,
+        [this](
+            jsi::Runtime &,
+            jsi::Value const &,
+            jsi::Value const *,
+            size_t) noexcept -> jsi::Value {
+          auto now = runtimeScheduler_->now();
+          auto asDouble =
+              std::chrono::duration<double, std::milli>(now.time_since_epoch())
+                  .count();
+          return jsi::Value(asDouble);
+        });
+  }
+
+  if (propertyName == "unstable_getCurrentPriorityLevel") {
+    auto currentPriorityLevel = runtimeScheduler_->getCurrentPriorityLevel();
+    return jsi::Value(runtime, serialize(currentPriorityLevel));
+  }
+
+  if (propertyName == "unstable_ImmediatePriority") {
+    return jsi::Value(runtime, serialize(SchedulerPriority::ImmediatePriority));
+  }
+
+  if (propertyName == "unstable_UserBlockingPriority") {
+    return jsi::Value(
+        runtime, serialize(SchedulerPriority::UserBlockingPriority));
+  }
+
+  if (propertyName == "unstable_NormalPriority") {
+    return jsi::Value(runtime, serialize(SchedulerPriority::NormalPriority));
+  }
+
+  if (propertyName == "unstable_LowPriority") {
+    return jsi::Value(runtime, serialize(SchedulerPriority::LowPriority));
+  }
+
+  if (propertyName == "unstable_IdlePriority") {
+    return jsi::Value(runtime, serialize(SchedulerPriority::IdlePriority));
+  }
+
+  if (propertyName == "$$typeof") {
+    return jsi::Value::undefined();
+  }
+
+  react_native_assert(false && "undefined property");
+  return jsi::Value::undefined();
+}
+
+} // namespace react
+} // namespace facebook

package/ReactCommon/react/renderer/runtimescheduler/RuntimeSchedulerBinding.h

@@ -0,0 +1,44 @@
+/*
+ * 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 <jsi/jsi.h>
+#include <react/renderer/runtimescheduler/RuntimeScheduler.h>
+
+namespace facebook {
+namespace react {
+
+/*
+ * Exposes RuntimeScheduler to JavaScript realm.
+ */
+class RuntimeSchedulerBinding : public jsi::HostObject {
+ public:
+  RuntimeSchedulerBinding(
+      std::shared_ptr<RuntimeScheduler> const &runtimeScheduler);
+
+  /*
+   * Installs RuntimeSchedulerBinding into JavaScript runtime if needed.
+   * Creates and sets `RuntimeSchedulerBinding` into the global namespace.
+   * In case if the global namespace already has a `RuntimeSchedulerBinding`
+   * installed, returns that.
+   */
+  static std::shared_ptr<RuntimeSchedulerBinding> createAndInstallIfNeeded(
+      jsi::Runtime &runtime,
+      std::shared_ptr<RuntimeScheduler> const &runtimeScheduler);
+
+  /*
+   * `jsi::HostObject` specific overloads.
+   */
+  jsi::Value get(jsi::Runtime &runtime, jsi::PropNameID const &name) override;
+
+ private:
+  std::shared_ptr<RuntimeScheduler> runtimeScheduler_;
+};
+
+} // namespace react
+} // namespace facebook

package/ReactCommon/react/renderer/runtimescheduler/RuntimeSchedulerCallInvoker.cpp

@@ -0,0 +1,32 @@
+/*
+ * 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 "RuntimeSchedulerCallInvoker.h"
+
+namespace facebook {
+namespace react {
+
+RuntimeSchedulerCallInvoker::RuntimeSchedulerCallInvoker(
+    std::weak_ptr<RuntimeScheduler> runtimeScheduler)
+    : runtimeScheduler_(runtimeScheduler) {}
+
+void RuntimeSchedulerCallInvoker::invokeAsync(std::function<void()> &&func) {
+  if (auto runtimeScheduler = runtimeScheduler_.lock()) {
+    runtimeScheduler->scheduleWork(
+        [func = std::move(func)](jsi::Runtime &) { func(); });
+  }
+}
+
+void RuntimeSchedulerCallInvoker::invokeSync(std::function<void()> &&func) {
+  if (auto runtimeScheduler = runtimeScheduler_.lock()) {
+    runtimeScheduler->executeNowOnTheSameThread(
+        [func = std::move(func)](jsi::Runtime &) { func(); });
+  }
+}
+
+} // namespace react
+} // namespace facebook

package/ReactCommon/react/renderer/runtimescheduler/RuntimeSchedulerCallInvoker.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 <ReactCommon/CallInvoker.h>
+#include <react/renderer/runtimescheduler/RuntimeScheduler.h>
+
+namespace facebook {
+namespace react {
+
+/*
+ * Exposes RuntimeScheduler to native modules. All calls invonked on JavaScript
+ * queue from native modules will be funneled through RuntimeScheduler.
+ */
+class RuntimeSchedulerCallInvoker : public CallInvoker {
+ public:
+  RuntimeSchedulerCallInvoker(std::weak_ptr<RuntimeScheduler> runtimeScheduler);
+
+  void invokeAsync(std::function<void()> &&func) override;
+  void invokeSync(std::function<void()> &&func) override;
+
+ private:
+  /*
+   * RuntimeScheduler is retained by the runtime. It must not be
+   * retained by anything beyond the runtime.
+   */
+  std::weak_ptr<RuntimeScheduler> runtimeScheduler_;
+};
+
+} // namespace react
+} // namespace facebook

package/ReactCommon/react/renderer/{components/picker/androidpicker/react/renderer/components/androidpicker/AndroidDialogPickerComponentDescriptor.h → runtimescheduler/RuntimeSchedulerClock.h}

@@ -7,15 +7,18 @@
 
 #pragma once
 
-#include "AndroidDialogPickerShadowNode.h"
-
-#include <react/renderer/core/ConcreteComponentDescriptor.h>
+#include <chrono>
 
 namespace facebook {
 namespace react {
 
-using AndroidDialogPickerComponentDescriptor =
-    ConcreteComponentDescriptor<AndroidDialogPickerShadowNode>;
+/*
+ * Represents a monotonic clock suitable for measuring intervals.
+ */
+using RuntimeSchedulerClock = std::chrono::steady_clock;
+
+using RuntimeSchedulerTimePoint = RuntimeSchedulerClock::time_point;
+using RuntimeSchedulerDuration = RuntimeSchedulerClock::duration;
 
 } // namespace react
 } // namespace facebook

package/ReactCommon/react/renderer/runtimescheduler/SchedulerPriority.h

@@ -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.
+ */
+
+#pragma once
+
+#include <react/debug/react_native_assert.h>
+#include <chrono>
+
+namespace facebook {
+namespace react {
+
+enum class SchedulerPriority : int {
+  ImmediatePriority = 1,
+  UserBlockingPriority = 2,
+  NormalPriority = 3,
+  LowPriority = 4,
+  IdlePriority = 5,
+};
+
+static constexpr std::underlying_type<SchedulerPriority>::type serialize(
+    SchedulerPriority schedulerPriority) {
+  return static_cast<std::underlying_type<SchedulerPriority>::type>(
+      schedulerPriority);
+}
+
+static inline SchedulerPriority fromRawValue(double value) {
+  switch ((int)value) {
+    case 1:
+      return SchedulerPriority::ImmediatePriority;
+    case 2:
+      return SchedulerPriority::UserBlockingPriority;
+    case 3:
+      return SchedulerPriority::NormalPriority;
+    case 4:
+      return SchedulerPriority::LowPriority;
+    case 5:
+      return SchedulerPriority::IdlePriority;
+    default:
+      react_native_assert(false && "Unsupported SchedulerPriority value");
+      return SchedulerPriority::NormalPriority;
+  }
+}
+
+static inline std::chrono::milliseconds timeoutForSchedulerPriority(
+    SchedulerPriority schedulerPriority) {
+  switch (schedulerPriority) {
+    case SchedulerPriority::ImmediatePriority:
+      return std::chrono::milliseconds(-1);
+    case SchedulerPriority::UserBlockingPriority:
+      return std::chrono::milliseconds(250);
+    case SchedulerPriority::NormalPriority:
+      return std::chrono::milliseconds(5000);
+    case SchedulerPriority::LowPriority:
+      return std::chrono::milliseconds(10'000);
+    case SchedulerPriority::IdlePriority:
+      return std::chrono::milliseconds::max();
+  }
+}
+
+} // namespace react
+} // namespace facebook

package/ReactCommon/react/renderer/runtimescheduler/Task.cpp

@@ -0,0 +1,37 @@
+/*
+ * 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 "RuntimeScheduler.h"
+
+namespace facebook {
+namespace react {
+
+Task::Task(
+    SchedulerPriority priority,
+    jsi::Function callback,
+    std::chrono::steady_clock::time_point expirationTime)
+    : priority(priority),
+      callback(std::move(callback)),
+      expirationTime(expirationTime) {}
+
+jsi::Value Task::execute(jsi::Runtime &runtime) {
+  auto result = jsi::Value::undefined();
+  // Cancelled task doesn't have a callback.
+  if (callback) {
+    // Callback in JavaScript is expecting a single bool parameter.
+    // React team plans to remove it and it is safe to pass in
+    // hardcoded false value.
+    result = callback.value().call(runtime, {false});
+
+    // Destroying callback to prevent calling it twice.
+    callback.reset();
+  }
+  return result;
+}
+
+} // namespace react
+} // namespace facebook

package/ReactCommon/react/renderer/runtimescheduler/Task.h

@@ -0,0 +1,48 @@
+/*
+ * 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 <better/optional.h>
+#include <jsi/jsi.h>
+#include <react/renderer/runtimescheduler/RuntimeSchedulerClock.h>
+#include <react/renderer/runtimescheduler/SchedulerPriority.h>
+
+namespace facebook {
+namespace react {
+
+class RuntimeScheduler;
+class TaskPriorityComparer;
+
+struct Task final {
+  Task(
+      SchedulerPriority priority,
+      jsi::Function callback,
+      std::chrono::steady_clock::time_point expirationTime);
+
+ private:
+  friend RuntimeScheduler;
+  friend TaskPriorityComparer;
+
+  SchedulerPriority priority;
+  better::optional<jsi::Function> callback;
+  RuntimeSchedulerClock::time_point expirationTime;
+
+  jsi::Value execute(jsi::Runtime &runtime);
+};
+
+class TaskPriorityComparer {
+ public:
+  inline bool operator()(
+      std::shared_ptr<Task> const &lhs,
+      std::shared_ptr<Task> const &rhs) {
+    return lhs->expirationTime > rhs->expirationTime;
+  }
+};
+
+} // namespace react
+} // namespace facebook

package/ReactCommon/react/renderer/runtimescheduler/primitives.h

@@ -0,0 +1,41 @@
+/*
+ * 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 <folly/dynamic.h>
+#include <jsi/jsi.h>
+#include <react/renderer/runtimescheduler/Task.h>
+
+namespace facebook {
+namespace react {
+
+struct TaskWrapper : public jsi::HostObject {
+  TaskWrapper(std::shared_ptr<Task> const &task) : task(task) {}
+
+  std::shared_ptr<Task> task;
+};
+
+inline static jsi::Value valueFromTask(
+    jsi::Runtime &runtime,
+    std::shared_ptr<Task> const &task) {
+  return jsi::Object::createFromHostObject(
+      runtime, std::make_shared<TaskWrapper>(task));
+}
+
+inline static std::shared_ptr<Task> taskFromValue(
+    jsi::Runtime &runtime,
+    jsi::Value const &value) {
+  if (value.isNull()) {
+    return nullptr;
+  }
+
+  return value.getObject(runtime).getHostObject<TaskWrapper>(runtime)->task;
+}
+
+} // namespace react
+} // namespace facebook