@react-native-ohos/react-native-reanimated 3.18.2 → 3.18.3

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

@@ -1,189 +1,189 @@
-#include <worklets/SharedItems/Shareables.h>
-#include <worklets/Tools/JSISerializer.h>
-#include <worklets/Tools/PlatformLogger.h>
-#include <worklets/Tools/ReanimatedJSIUtils.h>
-#include <worklets/WorkletRuntime/WorkletRuntime.h>
-#include <worklets/WorkletRuntime/WorkletRuntimeDecorator.h>
-
-#include <vector>
-
-namespace worklets {
-
-static inline double performanceNow() {
-  // copied from JSExecutor.cpp
-  auto time = std::chrono::steady_clock::now();
-  auto duration = std::chrono::duration_cast<std::chrono::nanoseconds>(
-                      time.time_since_epoch())
-                      .count();
-
-  constexpr double NANOSECONDS_IN_MILLISECOND = 1000000.0;
-  return duration / NANOSECONDS_IN_MILLISECOND;
-}
-
-static inline std::vector<jsi::Value> parseArgs(
-    jsi::Runtime &rt,
-    std::shared_ptr<ShareableArray> shareableArgs) {
-  if (shareableArgs == nullptr) {
-    return {};
-  }
-
-  auto argsArray = shareableArgs->toJSValue(rt).asObject(rt).asArray(rt);
-  auto argsSize = argsArray.size(rt);
-  std::vector<jsi::Value> result(argsSize);
-  for (size_t i = 0; i < argsSize; i++) {
-    result[i] = argsArray.getValueAtIndex(rt, i);
-  }
-  return result;
-}
-
-void WorkletRuntimeDecorator::decorate(
-    jsi::Runtime &rt,
-    const std::string &name,
-    const std::shared_ptr<JSScheduler> &jsScheduler) {
-  // resolves "ReferenceError: Property 'global' doesn't exist at ..."
-  rt.global().setProperty(rt, "global", rt.global());
-
-  rt.global().setProperty(rt, "_WORKLET", true);
-
-  rt.global().setProperty(rt, "_LABEL", jsi::String::createFromAscii(rt, name));
-
-#ifdef RCT_NEW_ARCH_ENABLED
-  constexpr auto isFabric = true;
-#else
-  constexpr auto isFabric = false;
-#endif // RCT_NEW_ARCH_ENABLED
-  rt.global().setProperty(rt, "_IS_FABRIC", isFabric);
-
-#ifndef NDEBUG
-  auto evalWithSourceUrl = [](jsi::Runtime &rt,
-                              const jsi::Value &thisValue,
-                              const jsi::Value *args,
-                              size_t count) -> jsi::Value {
-    auto code = std::make_shared<const jsi::StringBuffer>(
-        args[0].asString(rt).utf8(rt));
-    std::string url;
-    if (count > 1 && args[1].isString()) {
-      url = args[1].asString(rt).utf8(rt);
-    }
-    return rt.evaluateJavaScript(code, url);
-  };
-  rt.global().setProperty(
-      rt,
-      "evalWithSourceUrl",
-      jsi::Function::createFromHostFunction(
-          rt,
-          jsi::PropNameID::forAscii(rt, "evalWithSourceUrl"),
-          1,
-          evalWithSourceUrl));
-#endif // NDEBUG
-
-  jsi_utils::installJsiFunction(
-      rt, "_log", [](jsi::Runtime &rt, const jsi::Value &value) {
-        PlatformLogger::log(stringifyJSIValue(rt, value));
-      });
-
-  jsi_utils::installJsiFunction(
-      rt, "_toString", [](jsi::Runtime &rt, const jsi::Value &value) {
-        return jsi::String::createFromUtf8(rt, stringifyJSIValue(rt, value));
-      });
-
-  jsi_utils::installJsiFunction(
-      rt,
-      "_makeShareableClone",
-      [](jsi::Runtime &rt,
-         const jsi::Value &value,
-         const jsi::Value &nativeStateSource) {
-        auto shouldRetainRemote = jsi::Value::undefined();
-        return makeShareableClone(
-            rt, value, shouldRetainRemote, nativeStateSource);
-      });
-
-  jsi_utils::installJsiFunction(
-      rt,
-      "_scheduleRemoteFunctionOnJS",
-      [jsScheduler](
-          jsi::Runtime &rt,
-          const jsi::Value &funValue,
-          const jsi::Value &argsValue) {
-        auto shareableRemoteFun = extractShareableOrThrow<
-            ShareableRemoteFunction>(
-            rt,
-            funValue,
-            "[Reanimated] Incompatible object passed to scheduleOnJS. It is only allowed to schedule worklets or functions defined on the React Native JS runtime this way.");
-
-        auto shareableArgs = argsValue.isUndefined()
-            ? nullptr
-            : extractShareableOrThrow<ShareableArray>(
-                  rt, argsValue, "[Reanimated] Args must be an array.");
-
-        jsScheduler->scheduleOnJS([=](jsi::Runtime &rt) {
-          auto fun =
-              shareableRemoteFun->toJSValue(rt).asObject(rt).asFunction(rt);
-          if (shareableArgs == nullptr) {
-            // fast path for remote function w/o arguments
-            fun.call(rt);
-          } else {
-            auto args = parseArgs(rt, shareableArgs);
-            fun.call(
-                rt, const_cast<const jsi::Value *>(args.data()), args.size());
-          }
-        });
-      });
-
-  jsi_utils::installJsiFunction(
-      rt,
-      "_scheduleHostFunctionOnJS",
-      [jsScheduler](
-          jsi::Runtime &rt,
-          const jsi::Value &hostFunValue,
-          const jsi::Value &argsValue) {
-        if (hostFunValue.isUndefined() || !hostFunValue.isObject()) {
-            return;
-        }
-        auto hostFunObject = hostFunValue.asObject(rt);
-        if (!hostFunObject.isFunction(rt) || !hostFunObject.asFunction(rt).isHostFunction(rt)) {
-            return;
-        }
-        auto hostFun =
-            hostFunObject.asFunction(rt).getHostFunction(rt);
-
-        auto shareableArgs = argsValue.isUndefined()
-            ? nullptr
-            : extractShareableOrThrow<ShareableArray>(
-                  rt, argsValue, "[Reanimated] Args must be an array.");
-
-        jsScheduler->scheduleOnJS([=](jsi::Runtime &rt) {
-          auto args = parseArgs(rt, shareableArgs);
-          hostFun(
-              rt,
-              jsi::Value::undefined(),
-              const_cast<const jsi::Value *>(args.data()),
-              args.size());
-        });
-      });
-
-  jsi_utils::installJsiFunction(
-      rt,
-      "_scheduleOnRuntime",
-      [](jsi::Runtime &rt,
-         const jsi::Value &workletRuntimeValue,
-         const jsi::Value &shareableWorkletValue) {
-        scheduleOnRuntime(rt, workletRuntimeValue, shareableWorkletValue);
-      });
-
-  jsi::Object performance(rt);
-  performance.setProperty(
-      rt,
-      "now",
-      jsi::Function::createFromHostFunction(
-          rt,
-          jsi::PropNameID::forAscii(rt, "now"),
-          0,
-          [](jsi::Runtime &runtime,
-             const jsi::Value &,
-             const jsi::Value *args,
-             size_t count) { return jsi::Value(performanceNow()); }));
-  rt.global().setProperty(rt, "performance", performance);
-}
-
-} // namespace worklets
+#include <worklets/SharedItems/Shareables.h>
+#include <worklets/Tools/JSISerializer.h>
+#include <worklets/Tools/PlatformLogger.h>
+#include <worklets/Tools/ReanimatedJSIUtils.h>
+#include <worklets/WorkletRuntime/WorkletRuntime.h>
+#include <worklets/WorkletRuntime/WorkletRuntimeDecorator.h>
+
+#include <vector>
+
+namespace worklets {
+
+static inline double performanceNow() {
+  // copied from JSExecutor.cpp
+  auto time = std::chrono::steady_clock::now();
+  auto duration = std::chrono::duration_cast<std::chrono::nanoseconds>(
+                      time.time_since_epoch())
+                      .count();
+
+  constexpr double NANOSECONDS_IN_MILLISECOND = 1000000.0;
+  return duration / NANOSECONDS_IN_MILLISECOND;
+}
+
+static inline std::vector<jsi::Value> parseArgs(
+    jsi::Runtime &rt,
+    std::shared_ptr<ShareableArray> shareableArgs) {
+  if (shareableArgs == nullptr) {
+    return {};
+  }
+
+  auto argsArray = shareableArgs->toJSValue(rt).asObject(rt).asArray(rt);
+  auto argsSize = argsArray.size(rt);
+  std::vector<jsi::Value> result(argsSize);
+  for (size_t i = 0; i < argsSize; i++) {
+    result[i] = argsArray.getValueAtIndex(rt, i);
+  }
+  return result;
+}
+
+void WorkletRuntimeDecorator::decorate(
+    jsi::Runtime &rt,
+    const std::string &name,
+    const std::shared_ptr<JSScheduler> &jsScheduler) {
+  // resolves "ReferenceError: Property 'global' doesn't exist at ..."
+  rt.global().setProperty(rt, "global", rt.global());
+
+  rt.global().setProperty(rt, "_WORKLET", true);
+
+  rt.global().setProperty(rt, "_LABEL", jsi::String::createFromAscii(rt, name));
+
+#ifdef RCT_NEW_ARCH_ENABLED
+  constexpr auto isFabric = true;
+#else
+  constexpr auto isFabric = false;
+#endif // RCT_NEW_ARCH_ENABLED
+  rt.global().setProperty(rt, "_IS_FABRIC", isFabric);
+
+#ifndef NDEBUG
+  auto evalWithSourceUrl = [](jsi::Runtime &rt,
+                              const jsi::Value &thisValue,
+                              const jsi::Value *args,
+                              size_t count) -> jsi::Value {
+    auto code = std::make_shared<const jsi::StringBuffer>(
+        args[0].asString(rt).utf8(rt));
+    std::string url;
+    if (count > 1 && args[1].isString()) {
+      url = args[1].asString(rt).utf8(rt);
+    }
+    return rt.evaluateJavaScript(code, url);
+  };
+  rt.global().setProperty(
+      rt,
+      "evalWithSourceUrl",
+      jsi::Function::createFromHostFunction(
+          rt,
+          jsi::PropNameID::forAscii(rt, "evalWithSourceUrl"),
+          1,
+          evalWithSourceUrl));
+#endif // NDEBUG
+
+  jsi_utils::installJsiFunction(
+      rt, "_log", [](jsi::Runtime &rt, const jsi::Value &value) {
+        PlatformLogger::log(stringifyJSIValue(rt, value));
+      });
+
+  jsi_utils::installJsiFunction(
+      rt, "_toString", [](jsi::Runtime &rt, const jsi::Value &value) {
+        return jsi::String::createFromUtf8(rt, stringifyJSIValue(rt, value));
+      });
+
+  jsi_utils::installJsiFunction(
+      rt,
+      "_makeShareableClone",
+      [](jsi::Runtime &rt,
+         const jsi::Value &value,
+         const jsi::Value &nativeStateSource) {
+        auto shouldRetainRemote = jsi::Value::undefined();
+        return makeShareableClone(
+            rt, value, shouldRetainRemote, nativeStateSource);
+      });
+
+  jsi_utils::installJsiFunction(
+      rt,
+      "_scheduleRemoteFunctionOnJS",
+      [jsScheduler](
+          jsi::Runtime &rt,
+          const jsi::Value &funValue,
+          const jsi::Value &argsValue) {
+        auto shareableRemoteFun = extractShareableOrThrow<
+            ShareableRemoteFunction>(
+            rt,
+            funValue,
+            "[Reanimated] Incompatible object passed to scheduleOnJS. It is only allowed to schedule worklets or functions defined on the React Native JS runtime this way.");
+
+        auto shareableArgs = argsValue.isUndefined()
+            ? nullptr
+            : extractShareableOrThrow<ShareableArray>(
+                  rt, argsValue, "[Reanimated] Args must be an array.");
+
+        jsScheduler->scheduleOnJS([=](jsi::Runtime &rt) {
+          auto fun =
+              shareableRemoteFun->toJSValue(rt).asObject(rt).asFunction(rt);
+          if (shareableArgs == nullptr) {
+            // fast path for remote function w/o arguments
+            fun.call(rt);
+          } else {
+            auto args = parseArgs(rt, shareableArgs);
+            fun.call(
+                rt, const_cast<const jsi::Value *>(args.data()), args.size());
+          }
+        });
+      });
+
+  jsi_utils::installJsiFunction(
+      rt,
+      "_scheduleHostFunctionOnJS",
+      [jsScheduler](
+          jsi::Runtime &rt,
+          const jsi::Value &hostFunValue,
+          const jsi::Value &argsValue) {
+        if (hostFunValue.isUndefined() || !hostFunValue.isObject()) {
+            return;
+        }
+        auto hostFunObject = hostFunValue.asObject(rt);
+        if (!hostFunObject.isFunction(rt) || !hostFunObject.asFunction(rt).isHostFunction(rt)) {
+            return;
+        }
+        auto hostFun =
+            hostFunObject.asFunction(rt).getHostFunction(rt);
+
+        auto shareableArgs = argsValue.isUndefined()
+            ? nullptr
+            : extractShareableOrThrow<ShareableArray>(
+                  rt, argsValue, "[Reanimated] Args must be an array.");
+
+        jsScheduler->scheduleOnJS([=](jsi::Runtime &rt) {
+          auto args = parseArgs(rt, shareableArgs);
+          hostFun(
+              rt,
+              jsi::Value::undefined(),
+              const_cast<const jsi::Value *>(args.data()),
+              args.size());
+        });
+      });
+
+  jsi_utils::installJsiFunction(
+      rt,
+      "_scheduleOnRuntime",
+      [](jsi::Runtime &rt,
+         const jsi::Value &workletRuntimeValue,
+         const jsi::Value &shareableWorkletValue) {
+        scheduleOnRuntime(rt, workletRuntimeValue, shareableWorkletValue);
+      });
+
+  jsi::Object performance(rt);
+  performance.setProperty(
+      rt,
+      "now",
+      jsi::Function::createFromHostFunction(
+          rt,
+          jsi::PropNameID::forAscii(rt, "now"),
+          0,
+          [](jsi::Runtime &runtime,
+             const jsi::Value &,
+             const jsi::Value *args,
+             size_t count) { return jsi::Value(performanceNow()); }));
+  rt.global().setProperty(rt, "performance", performance);
+}
+
+} // namespace worklets

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

@@ -1,22 +1,22 @@
-#pragma once
-
-#include <worklets/Tools/JSScheduler.h>
-
-#include <jsi/jsi.h>
-
-#include <memory>
-#include <string>
-
-using namespace facebook;
-
-namespace worklets {
-
-class WorkletRuntimeDecorator {
- public:
-  static void decorate(
-      jsi::Runtime &rt,
-      const std::string &name,
-      const std::shared_ptr<JSScheduler> &jsScheduler);
-};
-
-} // namespace worklets
+#pragma once
+
+#include <worklets/Tools/JSScheduler.h>
+
+#include <jsi/jsi.h>
+
+#include <memory>
+#include <string>
+
+using namespace facebook;
+
+namespace worklets {
+
+class WorkletRuntimeDecorator {
+ public:
+  static void decorate(
+      jsi::Runtime &rt,
+      const std::string &name,
+      const std::shared_ptr<JSScheduler> &jsScheduler);
+};
+
+} // namespace worklets

package/harmony/reanimated/src/main/cpp/ReanimatedModule.cpp

@@ -5,6 +5,7 @@
 #include "RNOH/ArkTSTurboModule.h"
 #include "RNOH/RNInstance.h"
 #include "ReanimatedModule.h"
+#include "ReanimatedSensorContainer.h"
 #include "ReanimatedUIScheduler.h"
 #include "PlatformDepMethodsHolder.h"
 #include "WorkletRuntimeCollector.h"
@@ -50,19 +51,16 @@ ReanimatedModule::~ReanimatedModule()
     if (keyboardEventDataUpdater_) {
         keyboardEventDataUpdater_ = nullptr;
     }
-    if (auto nativeReanimatedModule = weakNativeReanimatedModule_.lock()) {
-        nativeReanimatedModule->invalidate();
-    }
 }
 
 void ReanimatedModule::installTurboModule(facebook::jsi::Runtime &rt)
 {
-    auto nodesManager = std::make_shared<ReanimatedNodesManager>(
-        [weakExecutor = std::weak_ptr(m_ctx.taskExecutor)](TaskExecutor::Task &&task) {
-            if (auto taskExecutor = weakExecutor.lock()) {
-                taskExecutor->runTask(TaskThread::MAIN, std::move(task));
-            }
-        });
+    auto runMainThreadFuc = [weakExecutor = std::weak_ptr(m_ctx.taskExecutor)](TaskExecutor::Task &&task) {
+        if (auto taskExecutor = weakExecutor.lock()) {
+            taskExecutor->runTask(TaskThread::MAIN, std::move(task));
+        }
+    };
+    auto nodesManager = std::make_shared<ReanimatedNodesManager>(runMainThreadFuc);
 
     auto maybeFlushUIUpdatesQueueFunction = [nodesManager]() { nodesManager->maybeFlushUIUpdatesQueue(); };
     auto requestRender = [weakSelf = weak_from_this(), nodesManager](std::function<void(double)> onRender) {
@@ -90,14 +88,13 @@ void ReanimatedModule::installTurboModule(facebook::jsi::Runtime &rt)
 
     auto getAnimationTimestamp = getMillisSinceEpoch;
 
-    auto registerSensorFunction = [](int sensorType, int interval, int iosReferenceFrame,
+    auto sensorContainer = std::make_shared<ReanimatedSensorContainer>();
+    auto registerSensorFunction = [sensorContainer,
+                                   runMainThreadFuc](int sensorType, int interval, int iosReferenceFrame,
         std::function<void(double[], int)> setter) -> int {
-        // TODO
-        return -1;
-    };
-    auto unregisterSensorFunction = [](int sensorId) {
-        // TODO
+        return sensorContainer->registerSensor(sensorType, interval, iosReferenceFrame, setter, runMainThreadFuc);
     };
+    auto unregisterSensorFunction = [sensorContainer](int sensorId) { sensorContainer->unregisterSensor(sensorId); };
     auto subscribeForKeyboardEventsFunction =
         [weakSelf = weak_from_this()](std::function<void(int keyboardState, int height)> keyboardEventDataUpdater,
         bool isStatusBarTranslucent, bool isNavigationBarTranslucent) {
@@ -108,11 +105,12 @@ void ReanimatedModule::installTurboModule(facebook::jsi::Runtime &rt)
             self->keyboardEventDataUpdater_ = std::move(keyboardEventDataUpdater);
             auto weakExecutor = std::weak_ptr(self->m_ctx.taskExecutor);
             if (auto taskExecutor = weakExecutor.lock()) {
-                taskExecutor->runTask(TaskThread::MAIN, [ctx = self->m_ctx, isStatusBarTranslucent]() {
+                taskExecutor->runTask(TaskThread::MAIN, [ctx = self->m_ctx, isStatusBarTranslucent, isNavigationBarTranslucent]() {
                     ArkJS arkJs(ctx.env);
-                    // arkJs.createBoolean(isStatusBarTranslucent);
+                    auto isStatusBarTranslucentValue = arkJs.createBoolean(isStatusBarTranslucent);
+                    auto isNavigationBarTranslucentValue = arkJs.createBoolean(isNavigationBarTranslucent);
                     auto napiTurboModuleObject = arkJs.getObject(ctx.arkTSTurboModuleInstanceRef);
-                    napiTurboModuleObject.call("subscribeKeyBordListeners", {});
+                    napiTurboModuleObject.call("subscribeKeyBordListeners", {isStatusBarTranslucentValue, isNavigationBarTranslucentValue});
                 });
             }
             return 0;
@@ -155,7 +153,19 @@ void ReanimatedModule::installTurboModule(facebook::jsi::Runtime &rt)
         unsubscribeFromKeyboardEventsFunction,
         maybeFlushUIUpdatesQueueFunction,
     };
-    auto isReducedMotion = false;
+    bool isReducedMotion = false;
+    m_ctx.taskExecutor->runSyncTask(TaskThread::MAIN,
+    [ctx = m_ctx, &isReducedMotion]() {
+        if (!ctx.arkTSTurboModuleInstanceRef) {
+            return;
+        }
+        ArkJS arkJs(ctx.env);
+        auto napiTurboModuleObject =
+            arkJs.getObject(ctx.arkTSTurboModuleInstanceRef);
+        auto napiResult =
+            napiTurboModuleObject.call("isReducedMotionEnabled", {});
+        isReducedMotion = arkJs.getBoolean(napiResult);
+    });
     auto isBridgeless = true;
     auto workletsModule = [weakSelf = weak_from_this()]() -> std::shared_ptr<WorkletsModule> {
         auto self = weakSelf.lock();