@react-native-ohos/react-native-reanimated 3.18.2 → 3.18.3-beta.2

package/harmony/reanimated/src/main/cpp/Common/cpp/worklets/Tools/SingleInstanceChecker.h

@@ -1,72 +1,72 @@
-#pragma once
-
-#ifndef NDEBUG
-
-#include <cxxabi.h>
-
-#include <atomic>
-#include <cassert>
-#include <iostream>
-#include <string>
-
-#ifdef ANDROID
-#include <android/log.h>
-#endif // ANDROID
-
-namespace worklets {
-
-// This is a class that counts how many instances of a different class there
-// are. It is meant only to be used with classes that should only have one
-// instance.
-
-template <class T>
-class SingleInstanceChecker {
- public:
-  SingleInstanceChecker();
-  ~SingleInstanceChecker();
-
- private:
-  void assertWithMessage(bool condition, std::string message) {
-    if (!condition) {
-#ifdef ANDROID
-      __android_log_print(
-          ANDROID_LOG_WARN, "Reanimated", "%s", message.c_str());
-#else
-      std::cerr << "[Reanimated] " << message << std::endl;
-#endif
-
-#ifdef IS_REANIMATED_EXAMPLE_APP
-      assert(false);
-#endif
-    }
-  }
-
-  // A static field will exist separately for every class template.
-  // This has to be inline for automatic initialization.
-  inline static std::atomic<int> instanceCount_;
-};
-
-template <class T>
-SingleInstanceChecker<T>::SingleInstanceChecker() {
-  int status = 0;
-  std::string className =
-      __cxxabiv1::__cxa_demangle(typeid(T).name(), nullptr, nullptr, &status);
-
-  // React Native can spawn up to two instances of a Native Module at the same
-  // time. This happens during a reload when a new instance of React Native is
-  // created while simultaneously the old one is torn down.
-  instanceCount_++;
-  assertWithMessage(
-      instanceCount_ <= 2,
-      "[Reanimated] More than two instances of " + className +
-          " present. This may indicate a memory leak due to a retain cycle.");
-}
-
-template <class T>
-SingleInstanceChecker<T>::~SingleInstanceChecker() {
-  instanceCount_--;
-}
-
-} // namespace worklets
-
-#endif // NDEBUG
+#pragma once
+
+#ifndef NDEBUG
+
+#include <cxxabi.h>
+
+#include <atomic>
+#include <cassert>
+#include <iostream>
+#include <string>
+
+#ifdef ANDROID
+#include <android/log.h>
+#endif // ANDROID
+
+namespace worklets {
+
+// This is a class that counts how many instances of a different class there
+// are. It is meant only to be used with classes that should only have one
+// instance.
+
+template <class T>
+class SingleInstanceChecker {
+ public:
+  SingleInstanceChecker();
+  ~SingleInstanceChecker();
+
+ private:
+  void assertWithMessage(bool condition, std::string message) {
+    if (!condition) {
+#ifdef ANDROID
+      __android_log_print(
+          ANDROID_LOG_WARN, "Reanimated", "%s", message.c_str());
+#else
+      std::cerr << "[Reanimated] " << message << std::endl;
+#endif
+
+#ifdef IS_REANIMATED_EXAMPLE_APP
+      assert(false);
+#endif
+    }
+  }
+
+  // A static field will exist separately for every class template.
+  // This has to be inline for automatic initialization.
+  inline static std::atomic<int> instanceCount_;
+};
+
+template <class T>
+SingleInstanceChecker<T>::SingleInstanceChecker() {
+  int status = 0;
+  std::string className =
+      __cxxabiv1::__cxa_demangle(typeid(T).name(), nullptr, nullptr, &status);
+
+  // React Native can spawn up to two instances of a Native Module at the same
+  // time. This happens during a reload when a new instance of React Native is
+  // created while simultaneously the old one is torn down.
+  instanceCount_++;
+  assertWithMessage(
+      instanceCount_ <= 2,
+      "[Reanimated] More than two instances of " + className +
+          " present. This may indicate a memory leak due to a retain cycle.");
+}
+
+template <class T>
+SingleInstanceChecker<T>::~SingleInstanceChecker() {
+  instanceCount_--;
+}
+
+} // namespace worklets
+
+#endif // NDEBUG

package/harmony/reanimated/src/main/cpp/Common/cpp/worklets/Tools/ThreadSafeQueue.h

@@ -1,49 +1,49 @@
-#pragma once
-
-#include <condition_variable>
-#include <mutex>
-#include <queue>
-#include <utility>
-
-namespace worklets {
-
-//
-// Copyright (c) 2013 Juan Palacios juan.palacios.puyana@gmail.com
-// Subject to the BSD 2-Clause License
-// - see < https://opensource.org/license/bsd-2-clause/ >
-//
-template <typename T>
-class ThreadSafeQueue {
- public:
-  T pop() {
-    std::unique_lock<std::mutex> mlock(mutex_);
-    while (queue_.empty()) {
-      cond_.wait(mlock);
-    }
-    const auto item = queue_.front();
-    queue_.pop();
-    return item;
-  }
-
-  void push(T &&item) {
-    std::unique_lock<std::mutex> mlock(mutex_);
-    queue_.push(std::move(item));
-    mlock.unlock();
-    cond_.notify_one();
-  }
-
-  bool empty() const {
-    std::unique_lock<std::mutex> mlock(mutex_);
-    const auto res = queue_.empty();
-    mlock.unlock();
-    cond_.notify_one();
-    return res;
-  }
-
- private:
-  std::queue<T> queue_;
-  mutable std::mutex mutex_;
-  mutable std::condition_variable cond_;
-};
-
-} // namespace worklets
+#pragma once
+
+#include <condition_variable>
+#include <mutex>
+#include <queue>
+#include <utility>
+
+namespace worklets {
+
+//
+// Copyright (c) 2013 Juan Palacios juan.palacios.puyana@gmail.com
+// Subject to the BSD 2-Clause License
+// - see < https://opensource.org/license/bsd-2-clause/ >
+//
+template <typename T>
+class ThreadSafeQueue {
+ public:
+  T pop() {
+    std::unique_lock<std::mutex> mlock(mutex_);
+    while (queue_.empty()) {
+      cond_.wait(mlock);
+    }
+    const auto item = queue_.front();
+    queue_.pop();
+    return item;
+  }
+
+  void push(T &&item) {
+    std::unique_lock<std::mutex> mlock(mutex_);
+    queue_.push(std::move(item));
+    mlock.unlock();
+    cond_.notify_one();
+  }
+
+  bool empty() const {
+    std::unique_lock<std::mutex> mlock(mutex_);
+    const auto res = queue_.empty();
+    mlock.unlock();
+    cond_.notify_one();
+    return res;
+  }
+
+ private:
+  std::queue<T> queue_;
+  mutable std::mutex mutex_;
+  mutable std::condition_variable cond_;
+};
+
+} // namespace worklets

package/harmony/reanimated/src/main/cpp/Common/cpp/worklets/Tools/UIScheduler.cpp

@@ -1,20 +1,20 @@
-#include <worklets/Tools/UIScheduler.h>
-#include <worklets/WorkletRuntime/ReanimatedRuntime.h>
-
-#include <utility>
-
-namespace worklets {
-
-void UIScheduler::scheduleOnUI(std::function<void()> job) {
-  uiJobs_.push(std::move(job));
-}
-
-void UIScheduler::triggerUI() {
-  scheduledOnUI_ = false;
-  while (!uiJobs_.empty()) {
-    const auto job = uiJobs_.pop();
-    job();
-  }
-}
-
-} // namespace worklets
+#include <worklets/Tools/UIScheduler.h>
+#include <worklets/WorkletRuntime/ReanimatedRuntime.h>
+
+#include <utility>
+
+namespace worklets {
+
+void UIScheduler::scheduleOnUI(std::function<void()> job) {
+  uiJobs_.push(std::move(job));
+}
+
+void UIScheduler::triggerUI() {
+  scheduledOnUI_ = false;
+  while (!uiJobs_.empty()) {
+    const auto job = uiJobs_.pop();
+    job();
+  }
+}
+
+} // namespace worklets

package/harmony/reanimated/src/main/cpp/Common/cpp/worklets/Tools/UIScheduler.h

@@ -1,22 +1,22 @@
-#pragma once
-
-#include <worklets/Tools/ThreadSafeQueue.h>
-
-#include <ReactCommon/CallInvoker.h>
-
-#include <atomic>
-
-namespace worklets {
-
-class UIScheduler {
- public:
-  virtual void scheduleOnUI(std::function<void()> job);
-  virtual void triggerUI();
-  virtual ~UIScheduler() = default;
-
- protected:
-  std::atomic<bool> scheduledOnUI_{false};
-  ThreadSafeQueue<std::function<void()>> uiJobs_;
-};
-
-} // namespace worklets
+#pragma once
+
+#include <worklets/Tools/ThreadSafeQueue.h>
+
+#include <ReactCommon/CallInvoker.h>
+
+#include <atomic>
+
+namespace worklets {
+
+class UIScheduler {
+ public:
+  virtual void scheduleOnUI(std::function<void()> job);
+  virtual void triggerUI();
+  virtual ~UIScheduler() = default;
+
+ protected:
+  std::atomic<bool> scheduledOnUI_{false};
+  ThreadSafeQueue<std::function<void()>> uiJobs_;
+};
+
+} // namespace worklets

package/harmony/reanimated/src/main/cpp/Common/cpp/worklets/Tools/WorkletEventHandler.cpp

@@ -1,29 +1,29 @@
-#include <worklets/Tools/WorkletEventHandler.h>
-
-namespace worklets {
-
-void WorkletEventHandler::process(
-    const std::shared_ptr<WorkletRuntime> &workletRuntime,
-    const double eventTimestamp,
-    const jsi::Value &eventValue) const {
-  workletRuntime->runGuarded(
-      handlerFunction_, jsi::Value(eventTimestamp), eventValue);
-}
-
-uint64_t WorkletEventHandler::getHandlerId() const {
-  return handlerId_;
-}
-
-const std::string &WorkletEventHandler::getEventName() const {
-  return eventName_;
-}
-
-uint64_t WorkletEventHandler::getEmitterReactTag() const {
-  return emitterReactTag_;
-}
-
-bool WorkletEventHandler::shouldIgnoreEmitterReactTag() const {
-  return emitterReactTag_ == -1;
-}
-
-} // namespace worklets
+#include <worklets/Tools/WorkletEventHandler.h>
+
+namespace worklets {
+
+void WorkletEventHandler::process(
+    const std::shared_ptr<WorkletRuntime> &workletRuntime,
+    const double eventTimestamp,
+    const jsi::Value &eventValue) const {
+  workletRuntime->runGuarded(
+      handlerFunction_, jsi::Value(eventTimestamp), eventValue);
+}
+
+uint64_t WorkletEventHandler::getHandlerId() const {
+  return handlerId_;
+}
+
+const std::string &WorkletEventHandler::getEventName() const {
+  return eventName_;
+}
+
+uint64_t WorkletEventHandler::getEmitterReactTag() const {
+  return emitterReactTag_;
+}
+
+bool WorkletEventHandler::shouldIgnoreEmitterReactTag() const {
+  return emitterReactTag_ == -1;
+}
+
+} // namespace worklets

package/harmony/reanimated/src/main/cpp/Common/cpp/worklets/Tools/WorkletEventHandler.h

@@ -1,41 +1,41 @@
-#pragma once
-
-#include <worklets/SharedItems/Shareables.h>
-#include <worklets/WorkletRuntime/WorkletRuntime.h>
-
-#include <jsi/jsi.h>
-
-#include <memory>
-#include <string>
-
-using namespace facebook;
-
-namespace worklets {
-
-class WorkletEventHandler {
-  const uint64_t handlerId_;
-  const uint64_t emitterReactTag_;
-  const std::string eventName_;
-  const std::shared_ptr<ShareableWorklet> handlerFunction_;
-
- public:
-  WorkletEventHandler(
-      const uint64_t handlerId,
-      const std::string &eventName,
-      const uint64_t emitterReactTag,
-      const std::shared_ptr<ShareableWorklet> &handlerFunction)
-      : handlerId_(handlerId),
-        emitterReactTag_(emitterReactTag),
-        eventName_(eventName),
-        handlerFunction_(handlerFunction) {}
-  void process(
-      const std::shared_ptr<WorkletRuntime> &workletRuntime,
-      double eventTimestamp,
-      const jsi::Value &eventValue) const;
-  uint64_t getHandlerId() const;
-  const std::string &getEventName() const;
-  uint64_t getEmitterReactTag() const;
-  bool shouldIgnoreEmitterReactTag() const;
-};
-
-} // namespace worklets
+#pragma once
+
+#include <worklets/SharedItems/Shareables.h>
+#include <worklets/WorkletRuntime/WorkletRuntime.h>
+
+#include <jsi/jsi.h>
+
+#include <memory>
+#include <string>
+
+using namespace facebook;
+
+namespace worklets {
+
+class WorkletEventHandler {
+  const uint64_t handlerId_;
+  const uint64_t emitterReactTag_;
+  const std::string eventName_;
+  const std::shared_ptr<ShareableWorklet> handlerFunction_;
+
+ public:
+  WorkletEventHandler(
+      const uint64_t handlerId,
+      const std::string &eventName,
+      const uint64_t emitterReactTag,
+      const std::shared_ptr<ShareableWorklet> &handlerFunction)
+      : handlerId_(handlerId),
+        emitterReactTag_(emitterReactTag),
+        eventName_(eventName),
+        handlerFunction_(handlerFunction) {}
+  void process(
+      const std::shared_ptr<WorkletRuntime> &workletRuntime,
+      double eventTimestamp,
+      const jsi::Value &eventValue) const;
+  uint64_t getHandlerId() const;
+  const std::string &getEventName() const;
+  uint64_t getEmitterReactTag() const;
+  bool shouldIgnoreEmitterReactTag() const;
+};
+
+} // namespace worklets

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

@@ -1,16 +1,16 @@
-#include <worklets/WorkletRuntime/RNRuntimeWorkletDecorator.h>
-
-namespace worklets {
-
-void RNRuntimeWorkletDecorator::decorate(
-    jsi::Runtime &rnRuntime,
-    const std::shared_ptr<WorkletsModuleProxy> &workletsModuleProxy) {
-  rnRuntime.global().setProperty(rnRuntime, "_WORKLET", false);
-
-  rnRuntime.global().setProperty(
-      rnRuntime,
-      "__workletsModuleProxy",
-      jsi::Object::createFromHostObject(rnRuntime, workletsModuleProxy));
-}
-
-} // namespace worklets
+#include <worklets/WorkletRuntime/RNRuntimeWorkletDecorator.h>
+
+namespace worklets {
+
+void RNRuntimeWorkletDecorator::decorate(
+    jsi::Runtime &rnRuntime,
+    const std::shared_ptr<WorkletsModuleProxy> &workletsModuleProxy) {
+  rnRuntime.global().setProperty(rnRuntime, "_WORKLET", false);
+
+  rnRuntime.global().setProperty(
+      rnRuntime,
+      "__workletsModuleProxy",
+      jsi::Object::createFromHostObject(rnRuntime, workletsModuleProxy));
+}
+
+} // namespace worklets

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

@@ -1,19 +1,19 @@
-#pragma once
-
-#include <jsi/jsi.h>
-#include <worklets/NativeModules/WorkletsModuleProxy.h>
-#include <memory>
-
-using namespace facebook;
-
-namespace worklets {
-
-class RNRuntimeWorkletDecorator {
-  // TODO: Rename to `RNRuntimeWorkletsDecorator` or something more suitable.
- public:
-  static void decorate(
-      jsi::Runtime &rnRuntime,
-      const std::shared_ptr<WorkletsModuleProxy> &workletsModuleProxy);
-};
-
-} // namespace worklets
+#pragma once
+
+#include <jsi/jsi.h>
+#include <worklets/NativeModules/WorkletsModuleProxy.h>
+#include <memory>
+
+using namespace facebook;
+
+namespace worklets {
+
+class RNRuntimeWorkletDecorator {
+  // TODO: Rename to `RNRuntimeWorkletsDecorator` or something more suitable.
+ public:
+  static void decorate(
+      jsi::Runtime &rnRuntime,
+      const std::shared_ptr<WorkletsModuleProxy> &workletsModuleProxy);
+};
+
+} // namespace worklets