@react-native-ohos/react-native-reanimated 3.18.1-rc.1

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

@@ -0,0 +1,31 @@
+// Copyright (c) 2025 Huawei Device Co., Ltd. All rights reserved
+// Use of this source code is governed by a MIT license that can be
+// found in the LICENSE file.
+
+#pragma once
+#include <vector>
+#include <functional>
+#include <native_vsync/native_vsync.h>
+#include "RNOH/NativeVsyncHandle.h"
+#include "RNOH/TaskExecutor/TaskExecutor.h"
+
+using ReanimatedPerformOperations = std::function<void()>;
+using ReanimatedOnAnimationCallback = std::function<void(double)>;
+using ReanimatedEventHandler = std::function<void()>;
+namespace rnoh {
+class ReanimatedNodesManager : public std::enable_shared_from_this<ReanimatedNodesManager> {
+    ReanimatedPerformOperations performOperations;
+    std::vector<ReanimatedOnAnimationCallback> onAnimationCallbacks;
+    NativeVsyncHandle m_vsyncHandle;
+    std::function<void(TaskExecutor::Task &&)> runOnTheMainThread;
+
+public:
+    ReanimatedNodesManager(std::function<void(TaskExecutor::Task &&)> runOnTheMainThread);
+    ~ReanimatedNodesManager() noexcept = default;
+    void maybeFlushUIUpdatesQueue();
+    void registerPerformOperations(ReanimatedPerformOperations reanimatedPerformOperations);
+    void postOnAnimation(ReanimatedOnAnimationCallback callback);
+    void operationBatchDidComplete();
+    void onAnimationFrame(int64_t timestamp);
+};
+} // namespace rnoh

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

@@ -0,0 +1,47 @@
+// Copyright (c) 2025 Huawei Device Co., Ltd. All rights reserved
+// Use of this source code is governed by a MIT license that can be
+// found in the LICENSE file.
+
+#include "ReanimatedPackage.h"
+#include "ReanimatedModule.h"
+#include "WorkletsModule.h"
+
+using namespace rnoh;
+using namespace facebook;
+
+class ReanimatedTurboModuleFactoryDelegate : public TurboModuleFactoryDelegate {
+public:
+    SharedTurboModule createTurboModule(Context ctx, const std::string &name) const override
+    {
+        if (name == "ReanimatedModule") {
+            return std::make_shared<ReanimatedModule>(ctx, name);
+        } else if (name == "WorkletsModule") {
+            return std::make_shared<worklets::WorkletsModule>(ctx, name);
+        }
+        return nullptr;
+    };
+};
+
+std::unique_ptr<TurboModuleFactoryDelegate> ReanimatedPackage::createTurboModuleFactoryDelegate()
+{
+    return std::make_unique<ReanimatedTurboModuleFactoryDelegate>();
+}
+
+class ReanimatedArkTsMessage : public ArkTSMessageHandler {
+    void handleArkTSMessage(const Context &ctx) override
+    {
+        auto rnInstance = ctx.rnInstance.lock();
+        if (rnInstance) {
+            if (ctx.messageName == "REANIMATED_KEY_BOARD_CHANGE") {
+                auto keyboardHeight = ctx.messagePayload["keyboardHeight"].asDouble();
+                auto status = ctx.messagePayload["status"].asInt();
+                rnInstance->getTurboModule<ReanimatedModule>("ReanimatedModule")->callKeyBord(keyboardHeight, status);
+            }
+        }
+    }
+};
+
+std::vector<ArkTSMessageHandler::Shared> ReanimatedPackage::createArkTSMessageHandlers()
+{
+    return { std::make_shared<ReanimatedArkTsMessage>() };
+}

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

@@ -0,0 +1,16 @@
+// Copyright (c) 2025 Huawei Device Co., Ltd. All rights reserved
+// Use of this source code is governed by a MIT license that can be
+// found in the LICENSE file.
+
+#include "RNOH/Package.h"
+
+namespace rnoh {
+class ReanimatedPackage : public Package {
+public:
+    ReanimatedPackage(Package::Context ctx) : Package(ctx) {}
+
+    std::unique_ptr<TurboModuleFactoryDelegate> createTurboModuleFactoryDelegate() override;
+
+    std::vector<ArkTSMessageHandler::Shared> createArkTSMessageHandlers() override;
+};
+} // namespace rnoh

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

@@ -0,0 +1,23 @@
+// Copyright (c) 2025 Huawei Device Co., Ltd. All rights reserved
+// Use of this source code is governed by a MIT license that can be
+// found in the LICENSE file.
+
+#include "ReanimatedUIScheduler.h"
+
+namespace rnoh {
+ReanimatedUIScheduler::ReanimatedUIScheduler(std::shared_ptr<TaskExecutor> taskExecutor) : m_taskExecutor(taskExecutor)
+{}
+void ReanimatedUIScheduler::scheduleOnUI(std::function<void()> job)
+{
+    if (m_taskExecutor->isOnTaskThread(TaskThread::MAIN)) {
+        job();
+        return;
+    }
+
+    m_taskExecutor->runTask(TaskThread::MAIN, [weakSelf = weak_from_this(), job = std::move(job)]() {
+        if (auto self = weakSelf.lock()) {
+            job();
+        }
+    });
+}
+} // namespace rnoh

package/harmony/reanimated/src/main/cpp/ReanimatedUIScheduler.h

@@ -0,0 +1,20 @@
+// Copyright (c) 2025 Huawei Device Co., Ltd. All rights reserved
+// Use of this source code is governed by a MIT license that can be
+// found in the LICENSE file.
+
+#pragma once
+#include <functional>
+#include <UIScheduler.h>
+#include <memory>
+#include "RNOH/TaskExecutor/TaskExecutor.h"
+
+namespace rnoh {
+class ReanimatedUIScheduler : public std::enable_shared_from_this<ReanimatedUIScheduler>, public worklets::UIScheduler {
+private:
+    std::shared_ptr<TaskExecutor> m_taskExecutor;
+
+public:
+    ReanimatedUIScheduler(std::shared_ptr<TaskExecutor> taskExecutor);
+    void scheduleOnUI(std::function<void()> job) override;
+};
+} // namespace rnoh

package/harmony/reanimated/src/main/cpp/TransformParser.h

@@ -0,0 +1,94 @@
+// Copyright (c) 2025 Huawei Device Co., Ltd. All rights reserved
+// Use of this source code is governed by a MIT license that can be
+// found in the LICENSE file.
+
+#include <folly/dynamic.h>
+#include <react/renderer/graphics/Transform.h>
+#define _USE_MATH_DEFINES
+#include <cmath>
+
+namespace rnoh {
+facebook::react::Transform applyTransformOperation(facebook::react::Transform const & transform,
+    std::string const & property, double value)
+{
+    facebook::react::Transform operation;
+    if (property == "translateX") {
+        operation = facebook::react::Transform::Translate(value, 0, 0);
+    } else if (property == "translateY") {
+        operation = facebook::react::Transform::Translate(0, value, 0);
+    } else if (property == "scale") {
+        operation = facebook::react::Transform::Scale(value, value, 1);
+    } else if (property == "scaleX") {
+        operation = facebook::react::Transform::Scale(value, 1, 1);
+    } else if (property == "scaleY") {
+        operation = facebook::react::Transform::Scale(1, value, 1);
+    } else if (property == "rotate") {
+        operation = facebook::react::Transform::Rotate(0, 0, value);
+    } else if (property == "rotateX") {
+        operation = facebook::react::Transform::Rotate(value, 0, 0);
+    } else if (property == "rotateY") {
+        operation = facebook::react::Transform::Rotate(0, value, 0);
+    } else if (property == "rotateZ") {
+        operation = facebook::react::Transform::Rotate(0, 0, value);
+    } else if (property == "perspective") {
+        operation = facebook::react::Transform::Perspective(value);
+    } else if (property == "skewX") {
+        operation = facebook::react::Transform::Skew(value, 0);
+    } else if (property == "skewY") {
+        operation = facebook::react::Transform::Skew(0, value);
+    } else {
+        throw std::runtime_error("Unsupported transform property " + property);
+    }
+    return transform * operation;
+}
+
+double convertStringAngleValueToRadians(std::string angle)
+{
+    auto unit = angle.substr(angle.length() - 3);
+    auto value = std::stod(angle.substr(0, angle.length() - 3));
+    if (unit == "rad") {
+        return value;
+    } else if (unit == "deg") {
+        return (value * M_PI) / 180;
+    }
+
+    throw std::invalid_argument("Angle must be a value in radians or degrees");
+}
+
+folly::dynamic parseTransform(folly::dynamic &dynamicTransform)
+{
+    facebook::react::Transform resultTransform = facebook::react::Transform::Identity();
+    for (auto &singleTransform : dynamicTransform) {
+        for (auto &item : singleTransform.items()) {
+            auto transformType = item.first.getString();
+            if (transformType == "matrix") {
+                auto matrixTransform = facebook::react::Transform::Identity();
+                if (item.second.size() == 16) {
+                    for (size_t i = 0; i < 16; ++i) {
+                        matrixTransform.matrix[i] = item.second[i].getDouble();
+                    }
+                }
+                resultTransform = resultTransform * matrixTransform;
+            } else {
+                double transformValue;
+                if (item.second.isString()) {
+                    try {
+                        transformValue = convertStringAngleValueToRadians(item.second.getString());
+                    } catch (std::invalid_argument &e) {
+                        // ignore incorrect values
+                        continue;
+                    }
+                } else if (item.second.isDouble()) {
+                    transformValue = item.second.getDouble();
+                } else {
+                    // ignore incorrect values
+                    continue;
+                }
+                resultTransform = applyTransformOperation(resultTransform, transformType, transformValue);
+            }
+        }
+    }
+    auto const & matrix = resultTransform.matrix;
+    return folly::dynamic::array(matrix.begin(), matrix.end());
+}
+}

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

@@ -0,0 +1,58 @@
+// Copyright (c) 2025 Huawei Device Co., Ltd. All rights reserved
+// Use of this source code is governed by a MIT license that can be
+// found in the LICENSE file.
+
+#include "RNOH/ArkTSTurboModule.h"
+#include "ReanimatedUIScheduler.h"
+#include "WorkletsModule.h"
+#include "RNRuntimeWorkletDecorator.h"
+#include "PlatformLogger.h"
+
+using namespace facebook;
+namespace worklets {
+jsi::Value installTurboModule(facebook::jsi::Runtime &rt, react::TurboModule &turboModule,
+    const facebook::jsi::Value *args, size_t count)
+{
+    auto self = static_cast<WorkletsModule *>(&turboModule);
+    if (count < 1) {
+        LOG(ERROR) << "WorkletsModule: Missing required argument";
+        return facebook::jsi::Value(false);
+    }
+    if (!args[0].isString()) {
+        LOG(ERROR) << "WorkletsModule: First argument must be a string";
+        return facebook::jsi::Value(false);
+    }
+
+    std::string valueUnpackerCode = args[0].getString(rt).utf8(rt);
+    self->installTurboModule(rt, valueUnpackerCode);
+    return facebook::jsi::Value(true);
+}
+
+WorkletsModule::WorkletsModule(const ArkTSTurboModule::Context ctx, const std::string name)
+    : ArkTSTurboModule(ctx, name)
+{
+    methodMap_ = { { "installTurboModule", { 0, worklets::installTurboModule } } };
+}
+
+WorkletsModule::~WorkletsModule()
+{
+    LOG(INFO) << "WorkletsModule::~WorkletsModule";
+}
+
+void WorkletsModule::installTurboModule(facebook::jsi::Runtime &runtime, std::string valueUnpackerCode)
+{
+    if (workletsModuleProxy_) {
+        LOG(WARNING) << "WorkletsModuleProxy already initialized";
+        return;
+    }
+
+    workletsModuleProxy_ = std::make_shared<WorkletsModuleProxy>(valueUnpackerCode, m_ctx.jsQueue, jsInvoker_,
+        std::make_shared<worklets::JSScheduler>(runtime, jsInvoker_),
+        std::make_shared<rnoh::ReanimatedUIScheduler>(m_ctx.taskExecutor));
+    RNRuntimeWorkletDecorator::decorate(runtime, workletsModuleProxy_);
+}
+std::shared_ptr<worklets::WorkletsModuleProxy> WorkletsModule::getWorkletsModuleProxy()
+{
+    return workletsModuleProxy_;
+}
+} // namespace worklets

package/harmony/reanimated/src/main/cpp/WorkletsModule.h

@@ -0,0 +1,22 @@
+// Copyright (c) 2025 Huawei Device Co., Ltd. All rights reserved
+// Use of this source code is governed by a MIT license that can be
+// found in the LICENSE file.
+
+#pragma once
+
+#include "RNOH/ArkTSTurboModule.h"
+#include "worklets/NativeModules/WorkletsModuleProxy.h"
+
+namespace worklets {
+
+class JSI_EXPORT WorkletsModule : public std::enable_shared_from_this<WorkletsModule>, public rnoh::ArkTSTurboModule {
+public:
+    WorkletsModule(const ArkTSTurboModule::Context ctx, const std::string name);
+    ~WorkletsModule() override;
+    void installTurboModule(facebook::jsi::Runtime &rt, const std::string valueUnpackerCode);
+    std::shared_ptr<worklets::WorkletsModuleProxy> getWorkletsModuleProxy();
+private:
+    std::shared_ptr<worklets::WorkletsModuleProxy> workletsModuleProxy_ = nullptr;
+};
+
+} // namespace worklets

package/harmony/reanimated/src/main/cpp/patches/AnimatedSensor/AnimatedSensorModule.cpp

@@ -0,0 +1,89 @@
+#include <reanimated/AnimatedSensor/AnimatedSensorModule.h>
+
+#include <utility>
+
+namespace reanimated {
+
+AnimatedSensorModule::AnimatedSensorModule(
+    const PlatformDepMethodsHolder &platformDepMethodsHolder)
+    : platformRegisterSensorFunction_(platformDepMethodsHolder.registerSensor),
+      platformUnregisterSensorFunction_(
+          platformDepMethodsHolder.unregisterSensor) {}
+
+AnimatedSensorModule::~AnimatedSensorModule() {
+  assert(sensorsIds_.empty());
+}
+
+jsi::Value AnimatedSensorModule::registerSensor(
+    jsi::Runtime &rt,
+    const std::shared_ptr<WorkletRuntime> &uiWorkletRuntime,
+    const jsi::Value &sensorTypeValue,
+    const jsi::Value &interval,
+    const jsi::Value &iosReferenceFrame,
+    const jsi::Value &sensorDataHandler) {
+  SensorType sensorType = static_cast<SensorType>(sensorTypeValue.asNumber());
+
+  auto shareableHandler = extractShareableOrThrow<ShareableWorklet>(
+      rt,
+      sensorDataHandler,
+      "[Reanimated] Sensor event handler must be a worklet.");
+
+  int sensorId = platformRegisterSensorFunction_(
+      sensorType,
+      interval.asNumber(),
+      iosReferenceFrame.asNumber(),
+      [sensorType,
+       shareableHandler,
+       weakUiWorkletRuntime = std::weak_ptr<WorkletRuntime>(uiWorkletRuntime)](
+          double newValues[], int orientationDegrees) {
+        auto uiWorkletRuntime = weakUiWorkletRuntime.lock();
+        if (uiWorkletRuntime == nullptr) {
+          return;
+        }
+
+        jsi::Runtime &uiRuntime = uiWorkletRuntime->getJSIRuntime();
+        jsi::Object value(uiRuntime);
+        if (sensorType == SensorType::ROTATION_VECTOR) {
+          // TODO: timestamp should be provided by the platform implementation
+          // such that the native side has a chance of providing a true event
+          // timestamp
+          value.setProperty(uiRuntime, "qx", newValues[0]);
+          value.setProperty(uiRuntime, "qy", newValues[1]);
+          value.setProperty(uiRuntime, "qz", newValues[2]);
+          value.setProperty(uiRuntime, "qw", newValues[3]);
+          value.setProperty(uiRuntime, "yaw", newValues[4]);
+          value.setProperty(uiRuntime, "pitch", newValues[5]);
+          value.setProperty(uiRuntime, "roll", newValues[6]);
+        } else {
+          value.setProperty(uiRuntime, "x", newValues[0]);
+          value.setProperty(uiRuntime, "y", newValues[1]);
+          value.setProperty(uiRuntime, "z", newValues[2]);
+        }
+        value.setProperty(
+            uiRuntime, "interfaceOrientation", orientationDegrees);
+
+        uiWorkletRuntime->runGuarded(shareableHandler, value);
+      });
+  if (sensorId != -1) {
+    sensorsIds_.insert(sensorId);
+  }
+  return jsi::Value(sensorId);
+}
+
+void AnimatedSensorModule::unregisterSensor(const jsi::Value &sensorId) {
+  // It is called during sensor hook unmounting
+  if (!sensorId.isNumber()) {
+    return;
+  }
+  sensorsIds_.erase(sensorId.getNumber());
+  platformUnregisterSensorFunction_(sensorId.asNumber());
+}
+
+void AnimatedSensorModule::unregisterAllSensors() {
+  for (auto sensorId : sensorsIds_) {
+    platformUnregisterSensorFunction_(sensorId);
+  }
+  sensorsIds_.clear();
+}
+
+} // namespace reanimated

package/harmony/reanimated/src/main/cpp/patches/Fabric/ShadowTreeCloner.cpp

@@ -0,0 +1,95 @@
+#ifdef RCT_NEW_ARCH_ENABLED
+
+#include <reanimated/Fabric/ShadowTreeCloner.h>
+
+#include <ranges>
+#include <utility>
+
+namespace reanimated {
+
+Props::Shared mergeProps(
+    const ShadowNode &shadowNode,
+    const PropsMap &propsMap,
+    const ShadowNodeFamily &family) {
+  const auto it = propsMap.find(&family);
+
+  if (it == propsMap.end()) {
+    return ShadowNodeFragment::propsPlaceholder();
+  }
+
+  PropsParserContext propsParserContext{
+      shadowNode.getSurfaceId(), *shadowNode.getContextContainer()};
+  const auto &propsVector = it->second;
+  auto newProps = shadowNode.getProps();
+
+#ifdef ANDROID
+  if (propsVector.size() > 1) {
+    folly::dynamic newPropsDynamic = folly::dynamic::object;
+    for (const auto &props : propsVector) {
+      newPropsDynamic = folly::dynamic::merge(
+          props.operator folly::dynamic(), newPropsDynamic);
+    }
+    return shadowNode.getComponentDescriptor().cloneProps(
+        propsParserContext, newProps, RawProps(newPropsDynamic));
+  }
+#endif
+
+  for (const auto &props : propsVector) {
+    newProps = shadowNode.getComponentDescriptor().cloneProps(
+        propsParserContext, newProps, RawProps(props));
+  }
+
+  return newProps;
+}
+
+ShadowNode::Unshared cloneShadowTreeWithNewPropsRecursive(
+    const ShadowNode &shadowNode,
+    const ChildrenMap &childrenMap,
+    const PropsMap &propsMap) {
+  const auto family = &shadowNode.getFamily();
+  const auto affectedChildrenIt = childrenMap.find(family);
+  auto children = shadowNode.getChildren();
+
+  if (affectedChildrenIt != childrenMap.end()) {
+    for (const auto index : affectedChildrenIt->second) {
+      children[index] = cloneShadowTreeWithNewPropsRecursive(
+          *children[index], childrenMap, propsMap);
+    }
+  }
+
+  return shadowNode.clone(
+      {mergeProps(shadowNode, propsMap, *family),
+       std::make_shared<ShadowNode::ListOfShared>(children),
+       shadowNode.getState()});
+}
+
+RootShadowNode::Unshared cloneShadowTreeWithNewProps(
+    const RootShadowNode &oldRootNode,
+    const PropsMap &propsMap) {
+  ChildrenMap childrenMap;
+
+  for (auto &[family, _] : propsMap) {
+    const auto ancestors = family->getAncestors(oldRootNode);
+        
+    for (auto it = ancestors.rbegin(); it != ancestors.rend(); ++it) {
+      const auto &[parentNode, index] = *it;
+      const auto parentFamily = &parentNode.get().getFamily();
+      auto &affectedChildren = childrenMap[parentFamily];
+
+      if (affectedChildren.contains(index)) {
+        continue;
+      }
+
+      affectedChildren.insert(index);
+    }
+  }
+
+  // This cast is safe, because this function returns a clone
+  // of the oldRootNode, which is an instance of RootShadowNode
+  return std::static_pointer_cast<RootShadowNode>(
+      cloneShadowTreeWithNewPropsRecursive(oldRootNode, childrenMap, propsMap));
+}
+
+} // namespace reanimated
+
+#endif // RCT_NEW_ARCH_ENABLED