@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/NativeModules/WorkletsModuleProxy.h

@@ -1,59 +1,59 @@
-#pragma once
-
-#include <cxxreact/MessageQueueThread.h>
-#include <worklets/NativeModules/WorkletsModuleProxySpec.h>
-#include <worklets/Tools/JSScheduler.h>
-#include <worklets/Tools/SingleInstanceChecker.h>
-#include <worklets/Tools/UIScheduler.h>
-#include <worklets/WorkletRuntime/WorkletRuntime.h>
-#include <memory>
-#include <string>
-
-namespace worklets {
-
-class WorkletsModuleProxy
-    : public WorkletsModuleProxySpec,
-      public std::enable_shared_from_this<WorkletsModuleProxy> {
- public:
-  explicit WorkletsModuleProxy(
-      const std::string &valueUnpackerCode,
-      const std::shared_ptr<MessageQueueThread> &jsQueue,
-      const std::shared_ptr<CallInvoker> &jsCallInvoker,
-      const std::shared_ptr<JSScheduler> &jsScheduler,
-      const std::shared_ptr<UIScheduler> &uiScheduler);
-
-  ~WorkletsModuleProxy();
-
-  jsi::Value makeShareableClone(
-      jsi::Runtime &rt,
-      const jsi::Value &value,
-      const jsi::Value &shouldRetainRemote,
-      const jsi::Value &nativeStateSource) override;
-
-  [[nodiscard]] inline std::string getValueUnpackerCode() const {
-    return valueUnpackerCode_;
-  }
-
-  [[nodiscard]] inline std::shared_ptr<MessageQueueThread> getJSQueue() const {
-    return jsQueue_;
-  }
-
-  [[nodiscard]] inline std::shared_ptr<JSScheduler> getJSScheduler() const {
-    return jsScheduler_;
-  }
-
-  [[nodiscard]] inline std::shared_ptr<UIScheduler> getUIScheduler() const {
-    return uiScheduler_;
-  }
-
- private:
-  const std::string valueUnpackerCode_;
-  const std::shared_ptr<MessageQueueThread> jsQueue_;
-  const std::shared_ptr<JSScheduler> jsScheduler_;
-  const std::shared_ptr<UIScheduler> uiScheduler_;
-#ifndef NDEBUG
-  SingleInstanceChecker<WorkletsModuleProxy> singleInstanceChecker_;
-#endif // NDEBUG
-};
-
-} // namespace worklets
+#pragma once
+
+#include <cxxreact/MessageQueueThread.h>
+#include <worklets/NativeModules/WorkletsModuleProxySpec.h>
+#include <worklets/Tools/JSScheduler.h>
+#include <worklets/Tools/SingleInstanceChecker.h>
+#include <worklets/Tools/UIScheduler.h>
+#include <worklets/WorkletRuntime/WorkletRuntime.h>
+#include <memory>
+#include <string>
+
+namespace worklets {
+
+class WorkletsModuleProxy
+    : public WorkletsModuleProxySpec,
+      public std::enable_shared_from_this<WorkletsModuleProxy> {
+ public:
+  explicit WorkletsModuleProxy(
+      const std::string &valueUnpackerCode,
+      const std::shared_ptr<MessageQueueThread> &jsQueue,
+      const std::shared_ptr<CallInvoker> &jsCallInvoker,
+      const std::shared_ptr<JSScheduler> &jsScheduler,
+      const std::shared_ptr<UIScheduler> &uiScheduler);
+
+  ~WorkletsModuleProxy();
+
+  jsi::Value makeShareableClone(
+      jsi::Runtime &rt,
+      const jsi::Value &value,
+      const jsi::Value &shouldRetainRemote,
+      const jsi::Value &nativeStateSource) override;
+
+  [[nodiscard]] inline std::string getValueUnpackerCode() const {
+    return valueUnpackerCode_;
+  }
+
+  [[nodiscard]] inline std::shared_ptr<MessageQueueThread> getJSQueue() const {
+    return jsQueue_;
+  }
+
+  [[nodiscard]] inline std::shared_ptr<JSScheduler> getJSScheduler() const {
+    return jsScheduler_;
+  }
+
+  [[nodiscard]] inline std::shared_ptr<UIScheduler> getUIScheduler() const {
+    return uiScheduler_;
+  }
+
+ private:
+  const std::string valueUnpackerCode_;
+  const std::shared_ptr<MessageQueueThread> jsQueue_;
+  const std::shared_ptr<JSScheduler> jsScheduler_;
+  const std::shared_ptr<UIScheduler> uiScheduler_;
+#ifndef NDEBUG
+  SingleInstanceChecker<WorkletsModuleProxy> singleInstanceChecker_;
+#endif // NDEBUG
+};
+
+} // namespace worklets

package/harmony/reanimated/src/main/cpp/Common/cpp/worklets/NativeModules/WorkletsModuleProxySpec.cpp

@@ -1,27 +1,27 @@
-#include <worklets/NativeModules/WorkletsModuleProxySpec.h>
-
-#include <utility>
-
-#define WORKLETS_SPEC_PREFIX(FN_NAME) \
-  __hostFunction_WorkletsModuleProxySpec_##FN_NAME
-
-namespace worklets {
-
-static jsi::Value WORKLETS_SPEC_PREFIX(makeShareableClone)(
-    jsi::Runtime &rt,
-    TurboModule &turboModule,
-    const jsi::Value *args,
-    size_t) {
-  return static_cast<WorkletsModuleProxySpec *>(&turboModule)
-      ->makeShareableClone(
-          rt, std::move(args[0]), std::move(args[1]), std::move(args[2]));
-}
-
-WorkletsModuleProxySpec::WorkletsModuleProxySpec(
-    const std::shared_ptr<CallInvoker> jsInvoker)
-    : TurboModule("NativeWorklets", jsInvoker) {
-  methodMap_["makeShareableClone"] =
-      MethodMetadata{2, WORKLETS_SPEC_PREFIX(makeShareableClone)};
-}
-
-} // namespace worklets
+#include <worklets/NativeModules/WorkletsModuleProxySpec.h>
+
+#include <utility>
+
+#define WORKLETS_SPEC_PREFIX(FN_NAME) \
+  __hostFunction_WorkletsModuleProxySpec_##FN_NAME
+
+namespace worklets {
+
+static jsi::Value WORKLETS_SPEC_PREFIX(makeShareableClone)(
+    jsi::Runtime &rt,
+    TurboModule &turboModule,
+    const jsi::Value *args,
+    size_t) {
+  return static_cast<WorkletsModuleProxySpec *>(&turboModule)
+      ->makeShareableClone(
+          rt, std::move(args[0]), std::move(args[1]), std::move(args[2]));
+}
+
+WorkletsModuleProxySpec::WorkletsModuleProxySpec(
+    const std::shared_ptr<CallInvoker> jsInvoker)
+    : TurboModule("NativeWorklets", jsInvoker) {
+  methodMap_["makeShareableClone"] =
+      MethodMetadata{2, WORKLETS_SPEC_PREFIX(makeShareableClone)};
+}
+
+} // namespace worklets

package/harmony/reanimated/src/main/cpp/Common/cpp/worklets/NativeModules/WorkletsModuleProxySpec.h

@@ -1,25 +1,25 @@
-#pragma once
-
-#include <ReactCommon/CallInvoker.h>
-#include <ReactCommon/TurboModule.h>
-#include <memory>
-
-using namespace facebook;
-using namespace react;
-
-namespace worklets {
-
-class JSI_EXPORT WorkletsModuleProxySpec : public TurboModule {
- protected:
-  explicit WorkletsModuleProxySpec(
-      const std::shared_ptr<CallInvoker> jsInvoker);
-
- public:
-  virtual jsi::Value makeShareableClone(
-      jsi::Runtime &rt,
-      const jsi::Value &value,
-      const jsi::Value &shouldRetainRemote,
-      const jsi::Value &nativeStateSource) = 0;
-};
-
-} // namespace worklets
+#pragma once
+
+#include <ReactCommon/CallInvoker.h>
+#include <ReactCommon/TurboModule.h>
+#include <memory>
+
+using namespace facebook;
+using namespace react;
+
+namespace worklets {
+
+class JSI_EXPORT WorkletsModuleProxySpec : public TurboModule {
+ protected:
+  explicit WorkletsModuleProxySpec(
+      const std::shared_ptr<CallInvoker> jsInvoker);
+
+ public:
+  virtual jsi::Value makeShareableClone(
+      jsi::Runtime &rt,
+      const jsi::Value &value,
+      const jsi::Value &shouldRetainRemote,
+      const jsi::Value &nativeStateSource) = 0;
+};
+
+} // namespace worklets

package/harmony/reanimated/src/main/cpp/Common/cpp/worklets/Registries/EventHandlerRegistry.cpp

@@ -1,94 +1,94 @@
-#include <worklets/Registries/EventHandlerRegistry.h>
-#include <worklets/Tools/WorkletEventHandler.h>
-
-#include <utility>
-#include <vector>
-
-namespace worklets {
-
-void EventHandlerRegistry::registerEventHandler(
-    const std::shared_ptr<WorkletEventHandler> &eventHandler) {
-  const std::lock_guard<std::mutex> lock(instanceMutex);
-  const auto &eventName = eventHandler->getEventName();
-  auto handlerId = eventHandler->getHandlerId();
-
-  if (eventHandler->shouldIgnoreEmitterReactTag()) {
-    eventMappingsWithoutTag[eventName][handlerId] = eventHandler;
-  } else {
-    const auto emitterReactTag = eventHandler->getEmitterReactTag();
-    const auto eventHash = std::make_pair(emitterReactTag, eventName);
-    eventMappingsWithTag[eventHash][handlerId] = eventHandler;
-  }
-  eventHandlers[handlerId] = eventHandler;
-}
-
-void EventHandlerRegistry::unregisterEventHandler(const uint64_t id) {
-  const std::lock_guard<std::mutex> lock(instanceMutex);
-  auto handlerIt = eventHandlers.find(id);
-  if (handlerIt != eventHandlers.end()) {
-    const auto &eventHandler = handlerIt->second;
-    const auto &eventName = eventHandler->getEventName();
-
-    if (eventHandler->shouldIgnoreEmitterReactTag()) {
-      const auto eventMappingIt = eventMappingsWithoutTag.find(eventName);
-      auto &handlersMap = eventMappingIt->second;
-      handlersMap.erase(id);
-      if (handlersMap.empty()) {
-        eventMappingsWithoutTag.erase(eventMappingIt);
-      }
-    } else {
-      const auto emitterReactTag = eventHandler->getEmitterReactTag();
-      const auto eventHash = std::make_pair(emitterReactTag, eventName);
-      const auto eventMappingIt = eventMappingsWithTag.find(eventHash);
-      auto &handlersMap = eventMappingIt->second;
-      handlersMap.erase(id);
-      if (handlersMap.empty()) {
-        eventMappingsWithTag.erase(eventMappingIt);
-      }
-    }
-    eventHandlers.erase(handlerIt);
-  }
-}
-
-void EventHandlerRegistry::processEvent(
-    const std::shared_ptr<WorkletRuntime> &uiWorkletRuntime,
-    const double eventTimestamp,
-    const std::string &eventName,
-    const int emitterReactTag,
-    const jsi::Value &eventPayload) {
-  std::vector<std::shared_ptr<WorkletEventHandler>> handlersForEvent;
-  {
-    const std::lock_guard<std::mutex> lock(instanceMutex);
-    auto handlersIt = eventMappingsWithoutTag.find(eventName);
-    if (handlersIt != eventMappingsWithoutTag.end()) {
-      for (auto handler : handlersIt->second) {
-        handlersForEvent.push_back(handler.second);
-      }
-    }
-    const auto eventHash = std::make_pair(emitterReactTag, eventName);
-    auto handlersWithTagIt = eventMappingsWithTag.find(eventHash);
-    if (handlersWithTagIt != eventMappingsWithTag.end()) {
-      for (auto handler : handlersWithTagIt->second) {
-        handlersForEvent.push_back(handler.second);
-      }
-    }
-  }
-
-  jsi::Runtime &rt = uiWorkletRuntime->getJSIRuntime();
-  eventPayload.asObject(rt).setProperty(
-      rt, "eventName", jsi::String::createFromUtf8(rt, eventName));
-  for (auto handler : handlersForEvent) {
-    handler->process(uiWorkletRuntime, eventTimestamp, eventPayload);
-  }
-}
-
-bool EventHandlerRegistry::isAnyHandlerWaitingForEvent(
-    const std::string &eventName,
-    const int emitterReactTag) {
-  const std::lock_guard<std::mutex> lock(instanceMutex);
-  const auto eventHash = std::make_pair(emitterReactTag, eventName);
-  auto it = eventMappingsWithTag.find(eventHash);
-  return it != eventMappingsWithTag.end() && !it->second.empty();
-}
-
-} // namespace worklets
+#include <worklets/Registries/EventHandlerRegistry.h>
+#include <worklets/Tools/WorkletEventHandler.h>
+
+#include <utility>
+#include <vector>
+
+namespace worklets {
+
+void EventHandlerRegistry::registerEventHandler(
+    const std::shared_ptr<WorkletEventHandler> &eventHandler) {
+  const std::lock_guard<std::mutex> lock(instanceMutex);
+  const auto &eventName = eventHandler->getEventName();
+  auto handlerId = eventHandler->getHandlerId();
+
+  if (eventHandler->shouldIgnoreEmitterReactTag()) {
+    eventMappingsWithoutTag[eventName][handlerId] = eventHandler;
+  } else {
+    const auto emitterReactTag = eventHandler->getEmitterReactTag();
+    const auto eventHash = std::make_pair(emitterReactTag, eventName);
+    eventMappingsWithTag[eventHash][handlerId] = eventHandler;
+  }
+  eventHandlers[handlerId] = eventHandler;
+}
+
+void EventHandlerRegistry::unregisterEventHandler(const uint64_t id) {
+  const std::lock_guard<std::mutex> lock(instanceMutex);
+  auto handlerIt = eventHandlers.find(id);
+  if (handlerIt != eventHandlers.end()) {
+    const auto &eventHandler = handlerIt->second;
+    const auto &eventName = eventHandler->getEventName();
+
+    if (eventHandler->shouldIgnoreEmitterReactTag()) {
+      const auto eventMappingIt = eventMappingsWithoutTag.find(eventName);
+      auto &handlersMap = eventMappingIt->second;
+      handlersMap.erase(id);
+      if (handlersMap.empty()) {
+        eventMappingsWithoutTag.erase(eventMappingIt);
+      }
+    } else {
+      const auto emitterReactTag = eventHandler->getEmitterReactTag();
+      const auto eventHash = std::make_pair(emitterReactTag, eventName);
+      const auto eventMappingIt = eventMappingsWithTag.find(eventHash);
+      auto &handlersMap = eventMappingIt->second;
+      handlersMap.erase(id);
+      if (handlersMap.empty()) {
+        eventMappingsWithTag.erase(eventMappingIt);
+      }
+    }
+    eventHandlers.erase(handlerIt);
+  }
+}
+
+void EventHandlerRegistry::processEvent(
+    const std::shared_ptr<WorkletRuntime> &uiWorkletRuntime,
+    const double eventTimestamp,
+    const std::string &eventName,
+    const int emitterReactTag,
+    const jsi::Value &eventPayload) {
+  std::vector<std::shared_ptr<WorkletEventHandler>> handlersForEvent;
+  {
+    const std::lock_guard<std::mutex> lock(instanceMutex);
+    auto handlersIt = eventMappingsWithoutTag.find(eventName);
+    if (handlersIt != eventMappingsWithoutTag.end()) {
+      for (auto handler : handlersIt->second) {
+        handlersForEvent.push_back(handler.second);
+      }
+    }
+    const auto eventHash = std::make_pair(emitterReactTag, eventName);
+    auto handlersWithTagIt = eventMappingsWithTag.find(eventHash);
+    if (handlersWithTagIt != eventMappingsWithTag.end()) {
+      for (auto handler : handlersWithTagIt->second) {
+        handlersForEvent.push_back(handler.second);
+      }
+    }
+  }
+
+  jsi::Runtime &rt = uiWorkletRuntime->getJSIRuntime();
+  eventPayload.asObject(rt).setProperty(
+      rt, "eventName", jsi::String::createFromUtf8(rt, eventName));
+  for (auto handler : handlersForEvent) {
+    handler->process(uiWorkletRuntime, eventTimestamp, eventPayload);
+  }
+}
+
+bool EventHandlerRegistry::isAnyHandlerWaitingForEvent(
+    const std::string &eventName,
+    const int emitterReactTag) {
+  const std::lock_guard<std::mutex> lock(instanceMutex);
+  const auto eventHash = std::make_pair(emitterReactTag, eventName);
+  auto it = eventMappingsWithTag.find(eventHash);
+  return it != eventMappingsWithTag.end() && !it->second.empty();
+}
+
+} // namespace worklets

package/harmony/reanimated/src/main/cpp/Common/cpp/worklets/Registries/EventHandlerRegistry.h

@@ -1,49 +1,49 @@
-#pragma once
-
-#include <worklets/WorkletRuntime/WorkletRuntime.h>
-
-#include <jsi/jsi.h>
-
-#include <map>
-#include <memory>
-#include <mutex>
-#include <string>
-#include <unordered_map>
-#include <utility>
-
-using namespace facebook;
-
-namespace worklets {
-
-class WorkletEventHandler;
-
-class EventHandlerRegistry {
-  std::map<
-      std::pair<int, std::string>,
-      std::unordered_map<uint64_t, std::shared_ptr<WorkletEventHandler>>>
-      eventMappingsWithTag;
-  std::map<
-      std::string,
-      std::unordered_map<uint64_t, std::shared_ptr<WorkletEventHandler>>>
-      eventMappingsWithoutTag;
-  std::map<uint64_t, std::shared_ptr<WorkletEventHandler>> eventHandlers;
-  std::mutex instanceMutex;
-
- public:
-  void registerEventHandler(
-      const std::shared_ptr<WorkletEventHandler> &eventHandler);
-  void unregisterEventHandler(const uint64_t id);
-
-  void processEvent(
-      const std::shared_ptr<WorkletRuntime> &uiWorkletRuntime,
-      const double eventTimestamp,
-      const std::string &eventName,
-      const int emitterReactTag,
-      const jsi::Value &eventPayload);
-
-  bool isAnyHandlerWaitingForEvent(
-      const std::string &eventName,
-      const int emitterReactTag);
-};
-
-} // namespace worklets
+#pragma once
+
+#include <worklets/WorkletRuntime/WorkletRuntime.h>
+
+#include <jsi/jsi.h>
+
+#include <map>
+#include <memory>
+#include <mutex>
+#include <string>
+#include <unordered_map>
+#include <utility>
+
+using namespace facebook;
+
+namespace worklets {
+
+class WorkletEventHandler;
+
+class EventHandlerRegistry {
+  std::map<
+      std::pair<int, std::string>,
+      std::unordered_map<uint64_t, std::shared_ptr<WorkletEventHandler>>>
+      eventMappingsWithTag;
+  std::map<
+      std::string,
+      std::unordered_map<uint64_t, std::shared_ptr<WorkletEventHandler>>>
+      eventMappingsWithoutTag;
+  std::map<uint64_t, std::shared_ptr<WorkletEventHandler>> eventHandlers;
+  std::mutex instanceMutex;
+
+ public:
+  void registerEventHandler(
+      const std::shared_ptr<WorkletEventHandler> &eventHandler);
+  void unregisterEventHandler(const uint64_t id);
+
+  void processEvent(
+      const std::shared_ptr<WorkletRuntime> &uiWorkletRuntime,
+      const double eventTimestamp,
+      const std::string &eventName,
+      const int emitterReactTag,
+      const jsi::Value &eventPayload);
+
+  bool isAnyHandlerWaitingForEvent(
+      const std::string &eventName,
+      const int emitterReactTag);
+};
+
+} // namespace worklets

package/harmony/reanimated/src/main/cpp/Common/cpp/worklets/Registries/WorkletRuntimeRegistry.cpp

@@ -1,8 +1,8 @@
-#include <worklets/Registries/WorkletRuntimeRegistry.h>
-
-namespace worklets {
-
-std::set<jsi::Runtime *> WorkletRuntimeRegistry::registry_{};
-std::mutex WorkletRuntimeRegistry::mutex_{};
-
-} // namespace worklets
+#include <worklets/Registries/WorkletRuntimeRegistry.h>
+
+namespace worklets {
+
+std::set<jsi::Runtime *> WorkletRuntimeRegistry::registry_{};
+std::mutex WorkletRuntimeRegistry::mutex_{};
+
+} // namespace worklets

package/harmony/reanimated/src/main/cpp/Common/cpp/worklets/Registries/WorkletRuntimeRegistry.h

@@ -1,39 +1,39 @@
-#pragma once
-
-#include <jsi/jsi.h>
-
-#include <mutex>
-#include <set>
-
-using namespace facebook;
-
-namespace worklets {
-
-class WorkletRuntimeRegistry {
- private:
-  static std::set<jsi::Runtime *> registry_;
-  static std::mutex mutex_; // Protects `registry_`.
-
-  WorkletRuntimeRegistry() {} // private ctor
-
-  static void registerRuntime(jsi::Runtime &runtime) {
-    std::lock_guard<std::mutex> lock(mutex_);
-    registry_.insert(&runtime);
-  }
-
-  static void unregisterRuntime(jsi::Runtime &runtime) {
-    std::lock_guard<std::mutex> lock(mutex_);
-    registry_.erase(&runtime);
-  }
-
-  friend class WorkletRuntimeCollector;
-
- public:
-  static bool isRuntimeAlive(jsi::Runtime *runtime) {
-    assert(runtime != nullptr);
-    std::lock_guard<std::mutex> lock(mutex_);
-    return registry_.find(runtime) != registry_.end();
-  }
-};
-
-} // namespace worklets
+#pragma once
+
+#include <jsi/jsi.h>
+
+#include <mutex>
+#include <set>
+
+using namespace facebook;
+
+namespace worklets {
+
+class WorkletRuntimeRegistry {
+ private:
+  static std::set<jsi::Runtime *> registry_;
+  static std::mutex mutex_; // Protects `registry_`.
+
+  WorkletRuntimeRegistry() {} // private ctor
+
+  static void registerRuntime(jsi::Runtime &runtime) {
+    std::lock_guard<std::mutex> lock(mutex_);
+    registry_.insert(&runtime);
+  }
+
+  static void unregisterRuntime(jsi::Runtime &runtime) {
+    std::lock_guard<std::mutex> lock(mutex_);
+    registry_.erase(&runtime);
+  }
+
+  friend class WorkletRuntimeCollector;
+
+ public:
+  static bool isRuntimeAlive(jsi::Runtime *runtime) {
+    assert(runtime != nullptr);
+    std::lock_guard<std::mutex> lock(mutex_);
+    return registry_.find(runtime) != registry_.end();
+  }
+};
+
+} // namespace worklets