@react-native-ohos/react-native-reanimated 3.18.1-rc.6 → 3.18.2-rc.2

package/harmony/reanimated/src/main/cpp/Common/cpp/worklets/WorkletRuntime/WorkletRuntime.cpp

@@ -1,155 +1,173 @@
-#include <worklets/Tools/JSISerializer.h>
-#include <worklets/WorkletRuntime/ReanimatedRuntime.h>
-#include <worklets/WorkletRuntime/WorkletRuntime.h>
-#include <worklets/WorkletRuntime/WorkletRuntimeCollector.h>
-#include <worklets/WorkletRuntime/WorkletRuntimeDecorator.h>
-
-#include <jsi/decorator.h>
-
-namespace worklets {
-
-class AroundLock {
-  const std::shared_ptr<std::recursive_mutex> mutex_;
-
- public:
-  explicit AroundLock(const std::shared_ptr<std::recursive_mutex> &mutex)
-      : mutex_(mutex) {}
-
-  void before() const {
-    mutex_->lock();
-  }
-
-  void after() const {
-    mutex_->unlock();
-  }
-};
-
-class LockableRuntime : public jsi::WithRuntimeDecorator<AroundLock> {
-  AroundLock aroundLock_;
-  std::shared_ptr<jsi::Runtime> runtime_;
-
- public:
-  explicit LockableRuntime(
-      std::shared_ptr<jsi::Runtime> &runtime,
-      const std::shared_ptr<std::recursive_mutex> &runtimeMutex)
-      : jsi::WithRuntimeDecorator<AroundLock>(*runtime, aroundLock_),
-        aroundLock_(runtimeMutex),
-        runtime_(std::move(runtime)) {}
-};
-
-static std::shared_ptr<jsi::Runtime> makeRuntime(
-    jsi::Runtime &runtime,
-    const std::shared_ptr<MessageQueueThread> &jsQueue,
-    const std::string &name,
-    const bool supportsLocking,
-    const std::shared_ptr<std::recursive_mutex> &runtimeMutex) {
-  auto reanimatedRuntime = ReanimatedRuntime::make(runtime, jsQueue, name);
-  if (supportsLocking) {
-    return std::make_shared<LockableRuntime>(reanimatedRuntime, runtimeMutex);
-  } else {
-    return reanimatedRuntime;
-  }
-}
-
-WorkletRuntime::WorkletRuntime(
-    jsi::Runtime &rnRuntime,
-    const std::shared_ptr<MessageQueueThread> &jsQueue,
-    const std::shared_ptr<JSScheduler> &jsScheduler,
-    const std::string &name,
-    const bool supportsLocking,
-    const std::string &valueUnpackerCode)
-    : runtimeMutex_(std::make_shared<std::recursive_mutex>()),
-      runtime_(makeRuntime(
-          rnRuntime,
-          jsQueue,
-          name,
-          supportsLocking,
-          runtimeMutex_)),
-#ifndef NDEBUG
-      supportsLocking_(supportsLocking),
-#endif
-      name_(name) {
-  jsi::Runtime &rt = *runtime_;
-  WorkletRuntimeCollector::install(rt);
-  WorkletRuntimeDecorator::decorate(rt, name, jsScheduler);
-
-  auto codeBuffer = std::make_shared<const jsi::StringBuffer>(
-      "(" + valueUnpackerCode + "\n)");
-  auto valueUnpacker = rt.evaluateJavaScript(codeBuffer, "valueUnpacker")
-                           .asObject(rt)
-                           .asFunction(rt);
-  rt.global().setProperty(rt, "__valueUnpacker", valueUnpacker);
-}
-
-jsi::Value WorkletRuntime::executeSync(
-    jsi::Runtime &rt,
-    const jsi::Value &worklet) const {
-  assert(
-      supportsLocking_ &&
-      ("[Reanimated] Runtime \"" + name_ + "\" doesn't support locking.")
-          .c_str());
-  auto shareableWorklet = extractShareableOrThrow<ShareableWorklet>(
-      rt,
-      worklet,
-      "[Reanimated] Only worklets can be executed synchronously on UI runtime.");
-  auto lock = std::unique_lock<std::recursive_mutex>(*runtimeMutex_);
-  jsi::Runtime &uiRuntime = getJSIRuntime();
-  auto result = runGuarded(shareableWorklet);
-  auto shareableResult = extractShareableOrThrow(uiRuntime, result);
-  lock.unlock();
-  return shareableResult->toJSValue(rt);
-}
-
-jsi::Value WorkletRuntime::get(
-    jsi::Runtime &rt,
-    const jsi::PropNameID &propName) {
-  auto name = propName.utf8(rt);
-  if (name == "toString") {
-    return jsi::Function::createFromHostFunction(
-        rt,
-        propName,
-        0,
-        [weakThis = weak_from_this()](
-            jsi::Runtime &rt, const jsi::Value &, const jsi::Value *, size_t)
-            -> jsi::Value {
-          auto strongThis = weakThis.lock();
-          if (!strongThis) {
-            return jsi::String::createFromUtf8(rt, "");
-          }
-
-          return jsi::String::createFromUtf8(rt, strongThis->toString());
-        });
-  }
-  if (name == "name") {
-    return jsi::String::createFromUtf8(rt, name_);
-  }
-  return jsi::Value::undefined();
-}
-
-std::vector<jsi::PropNameID> WorkletRuntime::getPropertyNames(
-    jsi::Runtime &rt) {
-  std::vector<jsi::PropNameID> result;
-  result.push_back(jsi::PropNameID::forUtf8(rt, "toString"));
-  result.push_back(jsi::PropNameID::forUtf8(rt, "name"));
-  return result;
-}
-
-std::shared_ptr<WorkletRuntime> extractWorkletRuntime(
-    jsi::Runtime &rt,
-    const jsi::Value &value) {
-  return value.getObject(rt).getHostObject<WorkletRuntime>(rt);
-}
-
-void scheduleOnRuntime(
-    jsi::Runtime &rt,
-    const jsi::Value &workletRuntimeValue,
-    const jsi::Value &shareableWorkletValue) {
-  auto workletRuntime = extractWorkletRuntime(rt, workletRuntimeValue);
-  auto shareableWorklet = extractShareableOrThrow<ShareableWorklet>(
-      rt,
-      shareableWorkletValue,
-      "[Reanimated] Function passed to `_scheduleOnRuntime` is not a shareable worklet. Please make sure that `processNestedWorklets` option in Reanimated Babel plugin is enabled.");
-  workletRuntime->runAsyncGuarded(shareableWorklet);
-}
-
-} // namespace worklets
+#include <worklets/Tools/JSISerializer.h>
+#include <worklets/Tools/PlatformLogger.h>
+#include <worklets/WorkletRuntime/ReanimatedRuntime.h>
+#include <worklets/WorkletRuntime/WorkletRuntime.h>
+#include <worklets/WorkletRuntime/WorkletRuntimeCollector.h>
+#include <worklets/WorkletRuntime/WorkletRuntimeDecorator.h>
+
+#include <jsi/decorator.h>
+
+namespace worklets {
+
+class AroundLock {
+  const std::shared_ptr<std::recursive_mutex> mutex_;
+
+ public:
+  explicit AroundLock(const std::shared_ptr<std::recursive_mutex> &mutex)
+      : mutex_(mutex) {}
+
+  void before() const {
+    mutex_->lock();
+  }
+
+  void after() const {
+    mutex_->unlock();
+  }
+};
+
+class LockableRuntime : public jsi::WithRuntimeDecorator<AroundLock> {
+  AroundLock aroundLock_;
+  std::shared_ptr<jsi::Runtime> runtime_;
+
+ public:
+  explicit LockableRuntime(
+      std::shared_ptr<jsi::Runtime> &runtime,
+      const std::shared_ptr<std::recursive_mutex> &runtimeMutex)
+      : jsi::WithRuntimeDecorator<AroundLock>(*runtime, aroundLock_),
+        aroundLock_(runtimeMutex),
+        runtime_(std::move(runtime)) {}
+};
+
+static std::shared_ptr<jsi::Runtime> makeRuntime(
+    jsi::Runtime &runtime,
+    const std::shared_ptr<MessageQueueThread> &jsQueue,
+    const std::string &name,
+    const bool supportsLocking,
+    const std::shared_ptr<std::recursive_mutex> &runtimeMutex) {
+  auto reanimatedRuntime = ReanimatedRuntime::make(runtime, jsQueue, name);
+  if (supportsLocking) {
+    return std::make_shared<LockableRuntime>(reanimatedRuntime, runtimeMutex);
+  } else {
+    return reanimatedRuntime;
+  }
+}
+
+WorkletRuntime::WorkletRuntime(
+    jsi::Runtime &rnRuntime,
+    const std::shared_ptr<MessageQueueThread> &jsQueue,
+    const std::shared_ptr<JSScheduler> &jsScheduler,
+    const std::string &name,
+    const bool supportsLocking,
+    const std::string &valueUnpackerCode)
+    : runtimeMutex_(std::make_shared<std::recursive_mutex>()),
+      runtime_(makeRuntime(
+          rnRuntime,
+          jsQueue,
+          name,
+          supportsLocking,
+          runtimeMutex_)),
+#ifndef NDEBUG
+      supportsLocking_(supportsLocking),
+#endif
+      name_(name) {
+  jsi::Runtime &rt = *runtime_;
+  WorkletRuntimeCollector::install(rt);
+  WorkletRuntimeDecorator::decorate(rt, name, jsScheduler);
+
+  auto codeBuffer = std::make_shared<const jsi::StringBuffer>(
+      "(" + valueUnpackerCode + "\n)");
+  auto valueUnpacker = rt.evaluateJavaScript(codeBuffer, "valueUnpacker")
+                           .asObject(rt)
+                           .asFunction(rt);
+  rt.global().setProperty(rt, "__valueUnpacker", valueUnpacker);
+}
+
+jsi::Value WorkletRuntime::executeSync(
+    jsi::Runtime &rt,
+    const jsi::Value &worklet) const {
+  if (worklet.isNull() || worklet.isUndefined()) {
+    PlatformLogger::log('worklet isNull or isUndefined');
+    return jsi::Value::undefined();
+  }
+
+  assert(
+      supportsLocking_ &&
+      ("[Reanimated] Runtime \"" + name_ + "\" doesn't support locking.")
+          .c_str());
+
+  auto shareableWorklet = extractShareableOrThrow<ShareableWorklet>(
+      rt,
+      worklet,
+      "[Reanimated] Only worklets can be executed synchronously on UI runtime.");
+
+  if (!shareableWorklet) {
+    PlatformLogger::log('shareableWorklet is undefined');
+    return jsi::Value::undefined();
+  }
+
+  auto lock = std::unique_lock<std::recursive_mutex>(*runtimeMutex_);
+  jsi::Runtime &uiRuntime = getJSIRuntime();
+  auto result = runGuarded(shareableWorklet);
+  auto shareableResult = extractShareableOrThrow(uiRuntime, result);
+  lock.unlock();
+
+  if (shareableResult && !shareableResult->toJSValue(rt).isNull()) {
+    return shareableResult->toJSValue(rt);
+  }
+  PlatformLogger::log('shareableResult is undefined');
+  return jsi::Value::undefined();
+}
+
+jsi::Value WorkletRuntime::get(
+    jsi::Runtime &rt,
+    const jsi::PropNameID &propName) {
+  auto name = propName.utf8(rt);
+  if (name == "toString") {
+    return jsi::Function::createFromHostFunction(
+        rt,
+        propName,
+        0,
+        [weakThis = weak_from_this()](
+            jsi::Runtime &rt, const jsi::Value &, const jsi::Value *, size_t)
+            -> jsi::Value {
+          auto strongThis = weakThis.lock();
+          if (!strongThis) {
+            return jsi::String::createFromUtf8(rt, "");
+          }
+
+          return jsi::String::createFromUtf8(rt, strongThis->toString());
+        });
+  }
+  if (name == "name") {
+    return jsi::String::createFromUtf8(rt, name_);
+  }
+  return jsi::Value::undefined();
+}
+
+std::vector<jsi::PropNameID> WorkletRuntime::getPropertyNames(
+    jsi::Runtime &rt) {
+  std::vector<jsi::PropNameID> result;
+  result.push_back(jsi::PropNameID::forUtf8(rt, "toString"));
+  result.push_back(jsi::PropNameID::forUtf8(rt, "name"));
+  return result;
+}
+
+std::shared_ptr<WorkletRuntime> extractWorkletRuntime(
+    jsi::Runtime &rt,
+    const jsi::Value &value) {
+  return value.getObject(rt).getHostObject<WorkletRuntime>(rt);
+}
+
+void scheduleOnRuntime(
+    jsi::Runtime &rt,
+    const jsi::Value &workletRuntimeValue,
+    const jsi::Value &shareableWorkletValue) {
+  auto workletRuntime = extractWorkletRuntime(rt, workletRuntimeValue);
+  auto shareableWorklet = extractShareableOrThrow<ShareableWorklet>(
+      rt,
+      shareableWorkletValue,
+      "[Reanimated] Function passed to `_scheduleOnRuntime` is not a shareable worklet. Please make sure that `processNestedWorklets` option in Reanimated Babel plugin is enabled.");
+  workletRuntime->runAsyncGuarded(shareableWorklet);
+}
+
+} // namespace worklets

package/harmony/reanimated/src/main/cpp/Common/cpp/worklets/WorkletRuntime/WorkletRuntime.h

@@ -1,90 +1,90 @@
-#pragma once
-
-#include <cxxreact/MessageQueueThread.h>
-#include <jsi/jsi.h>
-
-#include <worklets/SharedItems/Shareables.h>
-#include <worklets/Tools/AsyncQueue.h>
-#include <worklets/Tools/JSScheduler.h>
-
-#include <memory>
-#include <string>
-#include <utility>
-#include <vector>
-
-using namespace facebook;
-using namespace react;
-
-namespace worklets {
-
-class WorkletRuntime : public jsi::HostObject,
-                       public std::enable_shared_from_this<WorkletRuntime> {
- public:
-  explicit WorkletRuntime(
-      jsi::Runtime &rnRuntime,
-      const std::shared_ptr<MessageQueueThread> &jsQueue,
-      const std::shared_ptr<JSScheduler> &jsScheduler,
-      const std::string &name,
-      const bool supportsLocking,
-      const std::string &valueUnpackerCode);
-
-  jsi::Runtime &getJSIRuntime() const {
-    return *runtime_;
-  }
-
-  template <typename... Args>
-  inline jsi::Value runGuarded(
-      const std::shared_ptr<ShareableWorklet> &shareableWorklet,
-      Args &&...args) const {
-    jsi::Runtime &rt = *runtime_;
-    return runOnRuntimeGuarded(
-        rt, shareableWorklet->toJSValue(rt), std::forward<Args>(args)...);
-  }
-
-  void runAsyncGuarded(
-      const std::shared_ptr<ShareableWorklet> &shareableWorklet) {
-    if (queue_ == nullptr) {
-      queue_ = std::make_shared<AsyncQueue>(name_);
-    }
-    queue_->push([=, weakThis = weak_from_this()] {
-      auto strongThis = weakThis.lock();
-      if (!strongThis) {
-        return;
-      }
-
-      strongThis->runGuarded(shareableWorklet);
-    });
-  }
-
-  jsi::Value executeSync(jsi::Runtime &rt, const jsi::Value &worklet) const;
-
-  std::string toString() const {
-    return "[WorkletRuntime \"" + name_ + "\"]";
-  }
-
-  jsi::Value get(jsi::Runtime &rt, const jsi::PropNameID &propName) override;
-
-  std::vector<jsi::PropNameID> getPropertyNames(jsi::Runtime &rt) override;
-
- private:
-  const std::shared_ptr<std::recursive_mutex> runtimeMutex_;
-  const std::shared_ptr<jsi::Runtime> runtime_;
-#ifndef NDEBUG
-  const bool supportsLocking_;
-#endif
-  const std::string name_;
-  std::shared_ptr<AsyncQueue> queue_;
-};
-
-// This function needs to be non-inline to avoid problems with dynamic_cast on
-// Android
-std::shared_ptr<WorkletRuntime> extractWorkletRuntime(
-    jsi::Runtime &rt,
-    const jsi::Value &value);
-
-void scheduleOnRuntime(
-    jsi::Runtime &rt,
-    const jsi::Value &workletRuntimeValue,
-    const jsi::Value &shareableWorkletValue);
-
-} // namespace worklets
+#pragma once
+
+#include <cxxreact/MessageQueueThread.h>
+#include <jsi/jsi.h>
+
+#include <worklets/SharedItems/Shareables.h>
+#include <worklets/Tools/AsyncQueue.h>
+#include <worklets/Tools/JSScheduler.h>
+
+#include <memory>
+#include <string>
+#include <utility>
+#include <vector>
+
+using namespace facebook;
+using namespace react;
+
+namespace worklets {
+
+class WorkletRuntime : public jsi::HostObject,
+                       public std::enable_shared_from_this<WorkletRuntime> {
+ public:
+  explicit WorkletRuntime(
+      jsi::Runtime &rnRuntime,
+      const std::shared_ptr<MessageQueueThread> &jsQueue,
+      const std::shared_ptr<JSScheduler> &jsScheduler,
+      const std::string &name,
+      const bool supportsLocking,
+      const std::string &valueUnpackerCode);
+
+  jsi::Runtime &getJSIRuntime() const {
+    return *runtime_;
+  }
+
+  template <typename... Args>
+  inline jsi::Value runGuarded(
+      const std::shared_ptr<ShareableWorklet> &shareableWorklet,
+      Args &&...args) const {
+    jsi::Runtime &rt = *runtime_;
+    return runOnRuntimeGuarded(
+        rt, shareableWorklet->toJSValue(rt), std::forward<Args>(args)...);
+  }
+
+  void runAsyncGuarded(
+      const std::shared_ptr<ShareableWorklet> &shareableWorklet) {
+    if (queue_ == nullptr) {
+      queue_ = std::make_shared<AsyncQueue>(name_);
+    }
+    queue_->push([=, weakThis = weak_from_this()] {
+      auto strongThis = weakThis.lock();
+      if (!strongThis) {
+        return;
+      }
+
+      strongThis->runGuarded(shareableWorklet);
+    });
+  }
+
+  jsi::Value executeSync(jsi::Runtime &rt, const jsi::Value &worklet) const;
+
+  std::string toString() const {
+    return "[WorkletRuntime \"" + name_ + "\"]";
+  }
+
+  jsi::Value get(jsi::Runtime &rt, const jsi::PropNameID &propName) override;
+
+  std::vector<jsi::PropNameID> getPropertyNames(jsi::Runtime &rt) override;
+
+ private:
+  const std::shared_ptr<std::recursive_mutex> runtimeMutex_;
+  const std::shared_ptr<jsi::Runtime> runtime_;
+#ifndef NDEBUG
+  const bool supportsLocking_;
+#endif
+  const std::string name_;
+  std::shared_ptr<AsyncQueue> queue_;
+};
+
+// This function needs to be non-inline to avoid problems with dynamic_cast on
+// Android
+std::shared_ptr<WorkletRuntime> extractWorkletRuntime(
+    jsi::Runtime &rt,
+    const jsi::Value &value);
+
+void scheduleOnRuntime(
+    jsi::Runtime &rt,
+    const jsi::Value &workletRuntimeValue,
+    const jsi::Value &shareableWorkletValue);
+
+} // namespace worklets

package/harmony/reanimated/src/main/cpp/Common/cpp/worklets/WorkletRuntime/WorkletRuntimeCollector.h

@@ -1,36 +1,36 @@
-#pragma once
-
-#include <worklets/Registries/WorkletRuntimeRegistry.h>
-
-#include <jsi/jsi.h>
-
-#include <memory>
-
-namespace worklets {
-
-class WorkletRuntimeCollector : public jsi::HostObject {
-  // When worklet runtime is created, we inject an instance of this class as a
-  // `jsi::HostObject` into the global object. When worklet runtime is
-  // terminated, the object is garbage-collected, which runs the C++ destructor.
-  // In the destructor, we unregister the worklet runtime from the registry.
-
- public:
-  explicit WorkletRuntimeCollector(jsi::Runtime &runtime) : runtime_(runtime) {
-    WorkletRuntimeRegistry::registerRuntime(runtime_);
-  }
-
-  ~WorkletRuntimeCollector() {
-    WorkletRuntimeRegistry::unregisterRuntime(runtime_);
-  }
-
-  static void install(jsi::Runtime &rt) {
-    auto collector = std::make_shared<WorkletRuntimeCollector>(rt);
-    auto object = jsi::Object::createFromHostObject(rt, collector);
-    rt.global().setProperty(rt, "__workletRuntimeCollector", object);
-  }
-
- private:
-  jsi::Runtime &runtime_;
-};
-
-} // namespace worklets
+#pragma once
+
+#include <worklets/Registries/WorkletRuntimeRegistry.h>
+
+#include <jsi/jsi.h>
+
+#include <memory>
+
+namespace worklets {
+
+class WorkletRuntimeCollector : public jsi::HostObject {
+  // When worklet runtime is created, we inject an instance of this class as a
+  // `jsi::HostObject` into the global object. When worklet runtime is
+  // terminated, the object is garbage-collected, which runs the C++ destructor.
+  // In the destructor, we unregister the worklet runtime from the registry.
+
+ public:
+  explicit WorkletRuntimeCollector(jsi::Runtime &runtime) : runtime_(runtime) {
+    WorkletRuntimeRegistry::registerRuntime(runtime_);
+  }
+
+  ~WorkletRuntimeCollector() {
+    WorkletRuntimeRegistry::unregisterRuntime(runtime_);
+  }
+
+  static void install(jsi::Runtime &rt) {
+    auto collector = std::make_shared<WorkletRuntimeCollector>(rt);
+    auto object = jsi::Object::createFromHostObject(rt, collector);
+    rt.global().setProperty(rt, "__workletRuntimeCollector", object);
+  }
+
+ private:
+  jsi::Runtime &runtime_;
+};
+
+} // namespace worklets