@react-native-ohos/react-native-reanimated 3.18.1-rc.6 → 4.0.0-rc.1

package/harmony/reanimated/src/main/cpp/Common/cpp/reanimated/Tools/ReanimatedSystraceSection.h

@@ -28,9 +28,7 @@ namespace reanimated {
 struct ReanimatedSystraceSection {
  public:
   template <typename... ConvertsToStringPiece>
-  explicit ReanimatedSystraceSection(
-      const char *name,
-      ConvertsToStringPiece &&...args) {
+  explicit ReanimatedSystraceSection(const char *name, ConvertsToStringPiece &&...args) {
     ATrace_beginSection(name);
   }
 
@@ -42,8 +40,7 @@ struct ReanimatedSystraceSection {
 // The apple part is copied from React Native
 // from
 // https://github.com/facebook/react-native/blob/5697d923a05119314b4cfcd556cb243986637764/packages/react-native/ReactCommon/cxxreact/SystraceSection.h
-#elif defined(__APPLE__) && OS_LOG_TARGET_HAS_10_15_FEATURES && \
-    defined(REANIMATED_PROFILING)
+#elif defined(__APPLE__) && OS_LOG_TARGET_HAS_10_15_FEATURES && defined(REANIMATED_PROFILING)
 
 template <typename T, typename = void>
 struct renderer {
@@ -55,8 +52,7 @@ struct renderer {
 };
 
 template <typename T>
-static auto render(const T &t)
-    -> decltype(renderer<T>::render(std::declval<const T &>())) {
+static auto render(const T &t) -> decltype(renderer<T>::render(std::declval<const T &>())) {
   return renderer<T>::render(t);
 }
 
@@ -64,8 +60,7 @@ inline os_log_t instrumentsLogHandle = nullptr;
 
 static inline os_log_t getOrCreateInstrumentsLogHandle() {
   if (!instrumentsLogHandle) {
-    instrumentsLogHandle = os_log_create(
-        "dev.reanimated.instruments", OS_LOG_CATEGORY_POINTS_OF_INTEREST);
+    instrumentsLogHandle = os_log_create("dev.reanimated.instruments", OS_LOG_CATEGORY_POINTS_OF_INTEREST);
   }
   return instrumentsLogHandle;
 }
@@ -73,11 +68,8 @@ static inline os_log_t getOrCreateInstrumentsLogHandle() {
 struct ReanimatedSystraceSection {
  public:
   template <typename... ConvertsToStringPiece>
-  explicit ReanimatedSystraceSection(
-      const char *name,
-      ConvertsToStringPiece &&...args) {
-    os_log_t instrumentsLogHandle =
-        reanimated::getOrCreateInstrumentsLogHandle();
+  explicit ReanimatedSystraceSection(const char *name, ConvertsToStringPiece &&...args) {
+    os_log_t instrumentsLogHandle = reanimated::getOrCreateInstrumentsLogHandle();
 
     // If the log isn't enabled, we don't want the performance overhead of the
     // rest of the code below.
@@ -87,8 +79,7 @@ struct ReanimatedSystraceSection {
 
     name_ = name;
 
-    const auto argsVector =
-        std::vector<std::string>{reanimated::render(args)...};
+    const auto argsVector = std::vector<std::string>{reanimated::render(args)...};
     std::string argsString = "";
     for (size_t i = 0; i < argsVector.size(); i += 2) {
       argsString += argsVector[i] + "=" + argsVector[i + 1] + ";";
@@ -97,21 +88,11 @@ struct ReanimatedSystraceSection {
     signpostID_ = os_signpost_id_make_with_pointer(instrumentsLogHandle, this);
 
     os_signpost_interval_begin(
-        instrumentsLogHandle,
-        signpostID_,
-        "Reanimated",
-        "%s begin: %s",
-        name,
-        argsString.c_str());
+        instrumentsLogHandle, signpostID_, "Reanimated", "%s begin: %s", name, argsString.c_str());
   }
 
   ~ReanimatedSystraceSection() {
-    os_signpost_interval_end(
-        reanimated::instrumentsLogHandle,
-        signpostID_,
-        "Reanimated",
-        "%s end",
-        name_.data());
+    os_signpost_interval_end(reanimated::instrumentsLogHandle, signpostID_, "Reanimated", "%s end", name_.data());
   }
 
  private:
@@ -124,12 +105,10 @@ struct ReanimatedSystraceSection {
 struct ReanimatedSystraceSection {
  public:
   template <typename... ConvertsToStringPiece>
-  explicit ReanimatedSystraceSection(
-      const char *name,
-      ConvertsToStringPiece &&...args) {}
+  explicit ReanimatedSystraceSection(const char *name, ConvertsToStringPiece &&...args) {}
 };
 
-#endif // defined(__APPLE__) && OS_LOG_TARGET_HAS_10_15_FEATURES &&
-       // defined(REANIMATED_PROFILING)
+#endif // defined(__APPLE__) && OS_LOG_TARGET_HAS_10_15_FEATURES && \
+    // defined(REANIMATED_PROFILING)
 
 } // namespace reanimated

package/harmony/reanimated/src/main/cpp/Common/cpp/reanimated/Tools/ReanimatedVersion.cpp

@@ -0,0 +1,46 @@
+#include <reanimated/Tools/ReanimatedVersion.h>
+#include <worklets/Tools/JSLogger.h>
+#include <worklets/Tools/VersionUtils.h>
+
+#include <memory>
+#include <string>
+
+#ifdef REANIMATED_VERSION
+#define STRINGIZE(x) #x
+#define STRINGIZE2(x) STRINGIZE(x)
+#define REANIMATED_VERSION_STRING STRINGIZE2(REANIMATED_VERSION)
+#endif // REANIMATED_VERSION
+
+using namespace facebook;
+
+namespace reanimated {
+
+std::string getReanimatedCppVersion() {
+  return std::string(REANIMATED_VERSION_STRING);
+}
+
+void injectReanimatedCppVersion(jsi::Runtime &rnRuntime) {
+  auto version = getReanimatedCppVersion();
+  rnRuntime.global().setProperty(rnRuntime, "_REANIMATED_VERSION_CPP", jsi::String::createFromUtf8(rnRuntime, version));
+}
+
+#ifndef NDEBUG
+void checkJSVersion(jsi::Runtime &rnRuntime, const std::shared_ptr<worklets::JSLogger> &jsLogger) {
+  auto cppVersion = getReanimatedCppVersion();
+  auto jsVersionValue = rnRuntime.global().getProperty(rnRuntime, "_REANIMATED_VERSION_JS");
+  worklets::checkJSVersion(
+      rnRuntime,
+      jsVersionValue,
+      jsLogger,
+      cppVersion,
+      "Reanimated",
+      "https://docs.swmansion.com/react-native-reanimated/");
+}
+#else
+void checkJSVersion(jsi::Runtime &rnRuntime, const std::shared_ptr<worklets::JSLogger> &jsLogger) {
+  // In release builds we don't check the version, hence
+  // this function is a NOOP.
+}
+#endif // NDEBUG
+
+}; // namespace reanimated

package/harmony/reanimated/src/main/cpp/Common/cpp/{worklets → reanimated}/Tools/ReanimatedVersion.h

@@ -9,11 +9,10 @@
 
 using namespace facebook;
 
-namespace worklets {
+namespace reanimated {
 
 std::string getReanimatedCppVersion();
 void injectReanimatedCppVersion(jsi::Runtime &);
-bool matchVersion(const std::string &, const std::string &);
-void checkJSVersion(jsi::Runtime &, const std::shared_ptr<JSLogger> &);
+void checkJSVersion(jsi::Runtime &, const std::shared_ptr<worklets::JSLogger> &);
 
-}; // namespace worklets
+}; // namespace reanimated

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"
@@ -17,32 +18,25 @@ using namespace facebook;
 using namespace reanimated;
 using namespace worklets;
 namespace rnoh {
-static double getMillisSinceEpoch()
-{
+static double getMillisSinceEpoch() {
     auto now = std::chrono::high_resolution_clock::now();
     auto frameTime = std::chrono::duration_cast<std::chrono::milliseconds>(now.time_since_epoch());
     return frameTime.count();
 }
 
 jsi::Value installTurboModule(facebook::jsi::Runtime &rt, react::TurboModule &turboModule,
-    const facebook::jsi::Value *args, size_t count)
-{
+                              const facebook::jsi::Value *args, size_t count) {
     auto self = static_cast<ReanimatedModule *>(&turboModule);
-    if (self == nullptr) {
-        return facebook::jsi::Value::undefined();
-    }
     self->installTurboModule(rt);
     return facebook::jsi::Value(true);
 }
 
 ReanimatedModule::ReanimatedModule(const ArkTSTurboModule::Context ctx, const std::string name)
-    : ArkTSTurboModule(ctx, name)
-{
-    methodMap_ = { { "installTurboModule", { 0, rnoh::installTurboModule } } };
+    : ArkTSTurboModule(ctx, name) {
+    methodMap_ = {{"installTurboModule", {0, rnoh::installTurboModule}}};
 }
 
-ReanimatedModule::~ReanimatedModule()
-{
+ReanimatedModule::~ReanimatedModule() {
     LOG(INFO) << "ReanimatedModule::~ReanimatedModule";
     if (eventListener) {
         m_ctx.scheduler->removeEventListener(eventListener);
@@ -52,14 +46,18 @@ ReanimatedModule::~ReanimatedModule()
     }
 }
 
-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));
-            }
-        });
+void ReanimatedModule::installTurboModule(facebook::jsi::Runtime &rt) {
+    if (!m_ctx.taskExecutor->isOnTaskThread(rnoh::TaskThread::JS)) {
+        DLOG(ERROR) << "react_worklets reanimated installTurboModule failed,because of current thread is not js;";
+        return;
+    }
+    
+    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) {
@@ -76,28 +74,37 @@ void ReanimatedModule::installTurboModule(facebook::jsi::Runtime &rt)
             });
     };
 
-    auto progressLayoutAnimation = [=](jsi::Runtime &rt, int tag, const jsi::Object &newStyle,
-        bool isSharedTransition) {
-        // noop
-    };
+    auto getAnimationTimestamp = getMillisSinceEpoch;
+
+    auto synchronouslyUpdateUIPropsFunction = [weakInstance = m_ctx.instance](Tag tag, const folly::dynamic &dynamic) {
+        auto instance = weakInstance.lock();
+        auto instanceCapi = std::dynamic_pointer_cast<RNInstanceCAPI>(instance);
+        if (!instanceCapi) {
+            return;
+        }
+        auto componentInstance = instanceCapi->findComponentInstanceByTag(tag);
+        if (!componentInstance) {
+            return;
+        }
 
-    auto endLayoutAnimation = [=](int tag, bool removeView) {
-        // noop
+        // We want to restore the ignored props after the update,
+        // because reanimated handles setting correct props on React renders on its own
+        auto ignoredProps = componentInstance->getIgnoredPropKeys();
+        instanceCapi->synchronouslyUpdateViewOnUIThread(tag, dynamic);
+        componentInstance->setIgnoredPropKeys(std::move(ignoredProps));
     };
+    auto sensorContainer = std::make_shared<ReanimatedSensorContainer>();
 
-    auto getAnimationTimestamp = getMillisSinceEpoch;
 
-    auto registerSensorFunction = [](int sensorType, int interval, int iosReferenceFrame,
-        std::function<void(double[], int)> setter) -> int {
-        // TODO
-        return -1;
-    };
-    auto unregisterSensorFunction = [](int sensorId) {
-        // TODO
+    auto registerSensorFunction = [sensorContainer,
+                                   runMainThreadFuc](int sensorType, int interval, int iosReferenceFrame,
+                                                     std::function<void(double[], int)> setter) -> int {
+        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) {
+                                      bool isStatusBarTranslucent, bool isNavigationBarTranslucent) {
             auto self = weakSelf.lock();
             if (!self) {
                 return 0;
@@ -138,13 +145,13 @@ void ReanimatedModule::installTurboModule(facebook::jsi::Runtime &rt)
         auto napiTag = arkJs.createInt(handlerTag);
         auto napiState = arkJs.createInt(newState);
         auto napiTurboModuleObject = arkJs.getObject(self->m_ctx.arkTSTurboModuleInstanceRef);
-        napiTurboModuleObject.call("setGestureHandlerState", { napiTag, napiState });
+        napiTurboModuleObject.call("setGestureHandlerState", {napiTag, napiState});
     };
+
     PlatformDepMethodsHolder platformDepMethodsHolder = {
         requestRender,
+        synchronouslyUpdateUIPropsFunction,
         getAnimationTimestamp,
-        progressLayoutAnimation,
-        endLayoutAnimation,
         registerSensorFunction,
         unregisterSensorFunction,
         setGestureStateFunction,
@@ -152,8 +159,7 @@ void ReanimatedModule::installTurboModule(facebook::jsi::Runtime &rt)
         unsubscribeFromKeyboardEventsFunction,
         maybeFlushUIUpdatesQueueFunction,
     };
-    auto isReducedMotion = false;
-    auto isBridgeless = true;
+    auto isReducedMotion = false; // ANIMATOR_DURATION_SCALE
     auto workletsModule = [weakSelf = weak_from_this()]() -> std::shared_ptr<WorkletsModule> {
         auto self = weakSelf.lock();
         if (!self) {
@@ -165,44 +171,28 @@ void ReanimatedModule::installTurboModule(facebook::jsi::Runtime &rt)
         }
         return instance->getTurboModule<WorkletsModule>("WorkletsModule");
     };
-    auto workletsModulePtr = workletsModule();
-    if (!workletsModulePtr) {
-        LOG(ERROR) << "ReanimatedModule: Failed to get WorkletsModule";
-        return;
-    }
-    auto workletsModuleProxy = workletsModulePtr->getWorkletsModuleProxy();
-    if (!workletsModuleProxy) {
-        LOG(ERROR) << "ReanimatedModule: WorkletsModuleProxy is null, WorkletsModule may not be initialized yet";
-        return;
-    }
-    if (!jsInvoker_) {
-        LOG(ERROR) << "ReanimatedModule: jsInvoker_ is null";
-        return;
-    }
-    if (!m_ctx.scheduler) {
-        LOG(ERROR) << "ReanimatedModule: m_ctx.scheduler is null";
-        return;
-    }
-    auto nativeReanimatedModule = std::make_shared<ReanimatedModuleProxy>(workletsModuleProxy,
-        rt, jsInvoker_, platformDepMethodsHolder, isBridgeless, isReducedMotion);
-    weakNativeReanimatedModule_ = nativeReanimatedModule;
-    nativeReanimatedModule->init(platformDepMethodsHolder);
+    auto reanimatedModuleProxy = std::make_shared<ReanimatedModuleProxy>(
+        workletsModule()->getWorkletsModuleProxy(), rt, jsInvoker_, platformDepMethodsHolder, isReducedMotion);
+    reanimatedModuleProxy->init(platformDepMethodsHolder);
+    weakNativeReanimatedModule_ = reanimatedModuleProxy;
+
     ReanimatedPerformOperations reanimatedPerformOperations = [weakNativeReanimatedModule =
                                                                    weakNativeReanimatedModule_]() {
         if (auto nativeReanimatedModule = weakNativeReanimatedModule.lock()) {
-            nativeReanimatedModule->performOperations();
+            nativeReanimatedModule->performOperations(false);
         }
     };
     nodesManager->registerPerformOperations(reanimatedPerformOperations);
 
     WorkletRuntimeCollector::install(rt);
+    auto &uiRuntime = workletsModule()->getWorkletsModuleProxy()->getUIWorkletRuntime()->getJSIRuntime();
 
-    RNRuntimeDecorator::decorate(rt, nativeReanimatedModule);
+    RNRuntimeDecorator::decorate(rt, uiRuntime, reanimatedModuleProxy);
     injectDependencies(rt);
 
-    eventListener =
-        std::make_shared<facebook::react::EventListener>([weakNativeReanimatedModule = weakNativeReanimatedModule_,
-        weakTaskExecutor = std::weak_ptr{ m_ctx.taskExecutor }](facebook::react::RawEvent const & rawEvent) {
+    eventListener = std::make_shared<facebook::react::EventListener>(
+        [weakNativeReanimatedModule = weakNativeReanimatedModule_,
+         weakTaskExecutor = std::weak_ptr{m_ctx.taskExecutor}](facebook::react::RawEvent const &rawEvent) {
             auto taskExecutor = weakTaskExecutor.lock();
             auto nativeReanimatedModule = weakNativeReanimatedModule.lock();
             if (!nativeReanimatedModule || !taskExecutor || !taskExecutor->isOnTaskThread(TaskThread::MAIN)) {
@@ -224,31 +214,16 @@ void ReanimatedModule::installTurboModule(facebook::jsi::Runtime &rt)
             }
             return nativeReanimatedModule->handleRawEvent(rawEvent, frameTime);
         });
-    if (m_ctx.scheduler) {
-        m_ctx.scheduler->addEventListener(eventListener);
-    } else {
-        LOG(ERROR) << "ReanimatedModule: Cannot add event listener, scheduler is null";
-    }
+    m_ctx.scheduler->addEventListener(eventListener);
 }
-
-void ReanimatedModule::injectDependencies(facebook::jsi::Runtime & /* rt */)
-{
-    if (!m_ctx.scheduler) {
-        LOG(ERROR) << "ReanimatedModule::injectDependencies: scheduler is null";
-        return;
-    }
+void ReanimatedModule::injectDependencies(facebook::jsi::Runtime & /* rt */) {
     const auto uiManager = m_ctx.scheduler->getUIManager();
-    if (!uiManager) {
-        LOG(WARNING) << "ReanimatedModule::injectDependencies: uiManager is null";
-        return;
-    }
     if (auto nativeReanimatedModule = weakNativeReanimatedModule_.lock()) {
         nativeReanimatedModule->initializeFabric(uiManager);
     }
 }
 
-void ReanimatedModule::callKeyBord(double height, int status)
-{
+void ReanimatedModule::callKeyBord(double height, int status) {
     if (keyboardEventDataUpdater_) {
         keyboardEventDataUpdater_(status, height);
     }

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

@@ -28,6 +28,7 @@ void ReanimatedNodesManager::registerPerformOperations(ReanimatedPerformOperatio
 
 void ReanimatedNodesManager::postOnAnimation(ReanimatedOnAnimationCallback callback)
 {
+    LOG(INFO)<<"react_work reanimated------>postOnAnimation";
     onAnimationCallbacks.push_back(std::move(callback));
     m_vsyncHandle.requestFrame(vsyncHandleCallback, this);
 }

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

@@ -4,7 +4,6 @@
 
 #include "ReanimatedPackage.h"
 #include "ReanimatedModule.h"
-#include "WorkletsModule.h"
 
 using namespace rnoh;
 using namespace facebook;
@@ -15,8 +14,6 @@ public:
     {
         if (name == "ReanimatedModule") {
             return std::make_shared<ReanimatedModule>(ctx, name);
-        } else if (name == "WorkletsModule") {
-            return std::make_shared<worklets::WorkletsModule>(ctx, name);
         }
         return nullptr;
     };