@depup/react-native-worklets 0.12.1-depup.0 → 0.13.0-depup.0

package/Common/cpp/worklets/SharedItems/SynchronizableAccess.cpp

@@ -1,12 +1,14 @@
 #include <worklets/SharedItems/SynchronizableAccess.h>
 
 #include <mutex>
+#include <thread>
 
 namespace worklets {
 void SynchronizableAccess::getBlockingBefore() {
   std::unique_lock<std::mutex> lock(accessLock_);
   queue_.wait(lock, [this]() {
-    return !blockingWriter_ /* && dirtyWriters_ == 0 */ && (!imperativelyLocked_ || imperativeOwner_ == pthread_self());
+    return !blockingWriter_ && dirtyWriters_ == 0 &&
+        (!imperativelyLocked_ || imperativeOwner_ == std::this_thread::get_id());
   });
   blockingReaders_++;
 }
@@ -19,32 +21,28 @@ void SynchronizableAccess::getBlockingAfter() {
   }
 }
 
-// TODO: Shared pointer members (unless they're atomic) can't be assigned
-// in a non thread-safe manner, therefore `setDirty` has little sense now.
-// void SynchronizableAccess::setDirtyBefore() {
-//   std::unique_lock<std::mutex> lock(accessLock_);
-//   queue_.wait(lock, [this]() {
-//     return !blockingWriter_ && blockingReaders_ == 0 &&
-//         (!imperativelyLocked_ || imperativeOwner_ == pthread_self());
-//   });
-//   dirtyWriters_++;
-// }
+void SynchronizableAccess::setDirtyBefore() {
+  std::unique_lock<std::mutex> lock(accessLock_);
+  queue_.wait(lock, [this]() {
+    return !blockingWriter_ && blockingReaders_ == 0 &&
+        (!imperativelyLocked_ || imperativeOwner_ == std::this_thread::get_id());
+  });
+  dirtyWriters_++;
+}
 
-// TODO: Shared pointer members (unless they're atomic) can't be assigned
-// in a non thread-safe manner, therefore `setDirty` has little sense now.
-// void SynchronizableAccess::setDirtyAfter() {
-//   std::unique_lock<std::mutex> lock(accessLock_);
-//   dirtyWriters_--;
-//   if (dirtyWriters_ == 0) {
-//     queue_.notify_all();
-//   }
-// }
+void SynchronizableAccess::setDirtyAfter() {
+  std::unique_lock<std::mutex> lock(accessLock_);
+  dirtyWriters_--;
+  if (dirtyWriters_ == 0) {
+    queue_.notify_all();
+  }
+}
 
 void SynchronizableAccess::setBlockingBefore() {
   std::unique_lock<std::mutex> lock(accessLock_);
   queue_.wait(lock, [this]() {
-    return !blockingWriter_ && blockingReaders_ == 0 /* && dirtyWriters_ == 0 */ &&
-        (!imperativelyLocked_ || imperativeOwner_ == pthread_self());
+    return !blockingWriter_ && blockingReaders_ == 0 && dirtyWriters_ == 0 &&
+        (!imperativelyLocked_ || imperativeOwner_ == std::this_thread::get_id());
   });
   blockingWriter_ = true;
 }
@@ -58,16 +56,16 @@ void SynchronizableAccess::setBlockingAfter() {
 void SynchronizableAccess::lock() {
   std::unique_lock<std::mutex> lock(accessLock_);
   queue_.wait(lock, [this]() {
-    return !blockingWriter_ && blockingReaders_ == 0 /* && dirtyWriters_ == 0 */ &&
-        (!imperativelyLocked_ || imperativeOwner_ == pthread_self());
+    return !blockingWriter_ && blockingReaders_ == 0 && dirtyWriters_ == 0 &&
+        (!imperativelyLocked_ || imperativeOwner_ == std::this_thread::get_id());
   });
   imperativelyLocked_ = true;
-  imperativeOwner_ = pthread_self();
+  imperativeOwner_ = std::this_thread::get_id();
 }
 
 void SynchronizableAccess::unlock() {
   std::unique_lock<std::mutex> lock(accessLock_);
-  if (imperativeOwner_ != pthread_self()) {
+  if (imperativeOwner_ != std::this_thread::get_id()) {
     return;
   }
   imperativelyLocked_ = false;

package/Common/cpp/worklets/SharedItems/SynchronizableAccess.h

@@ -2,6 +2,7 @@
 
 #include <condition_variable>
 #include <mutex>
+#include <thread>
 
 namespace worklets {
 
@@ -23,22 +24,19 @@ class SynchronizableAccess {
   void getBlockingBefore();
   void getBlockingAfter();
 
-  // TODO: Shared pointer members (unless they're atomic) can't be assigned
-  // in a non thread-safe manner, therefore `setDirty` has little sense now.
-  // void setDirtyBefore();
-  // void setDirtyAfter();
+  void setDirtyBefore();
+  void setDirtyAfter();
 
   void setBlockingBefore();
   void setBlockingAfter();
 
  private:
   int blockingReaders_{0};
-  // int dirtyWriters_{0};
+  int dirtyWriters_{0};
   bool blockingWriter_{false};
   bool imperativelyLocked_{false};
-  pthread_t imperativeOwner_{};
+  std::thread::id imperativeOwner_{};
   std::mutex accessLock_;
-  std::recursive_mutex imperativeLock_;
   std::condition_variable queue_;
 };
 

package/Common/cpp/worklets/SharedItems/SynchronizableDynamic.cpp

@@ -0,0 +1,36 @@
+#include <worklets/SharedItems/SynchronizableDynamic.h>
+
+#include <atomic>
+#include <memory>
+#include <stdexcept>
+
+namespace worklets {
+
+SynchronizableValue SynchronizableDynamic::getDirty() {
+  return std::atomic_load(&value_);
+}
+
+SynchronizableValue SynchronizableDynamic::getBlocking() {
+  getBlockingBefore();
+  auto value = std::atomic_load(&value_);
+  getBlockingAfter();
+  return value;
+}
+
+void SynchronizableDynamic::setDirty(const SynchronizableFixedValue &) {
+  throw std::runtime_error(
+      "[Worklets] Cannot invoke setDirty on a dynamic-type Synchronizable. "
+      "Use setBlocking with a Serializable value instead.");
+}
+
+void SynchronizableDynamic::setBlocking(const std::shared_ptr<Serializable> &value) {
+  setBlockingBefore();
+  std::atomic_store(&value_, value);
+  setBlockingAfter();
+}
+
+void SynchronizableDynamic::setBlocking(const SynchronizableFixedValue &) {
+  throw std::runtime_error("[Worklets] Dynamic-type Synchronizable operates on Serializables, not plain values.");
+}
+
+} // namespace worklets

package/Common/cpp/worklets/SharedItems/SynchronizableDynamic.h

@@ -0,0 +1,27 @@
+#pragma once
+
+#include <worklets/SharedItems/Synchronizable.h>
+
+#include <memory>
+
+namespace worklets {
+
+class SynchronizableDynamic final : public Synchronizable {
+ public:
+  explicit SynchronizableDynamic(const std::shared_ptr<Serializable> &value) : Synchronizable(false), value_(value) {}
+
+  SynchronizableValue getDirty() override;
+
+  SynchronizableValue getBlocking() override;
+
+  void setDirty(const SynchronizableFixedValue &value) override;
+
+  void setBlocking(const std::shared_ptr<Serializable> &value) override;
+
+  void setBlocking(const SynchronizableFixedValue &value) override;
+
+ private:
+  std::shared_ptr<Serializable> value_;
+};
+
+} // namespace worklets

package/Common/cpp/worklets/SharedItems/SynchronizableFixed.cpp

@@ -0,0 +1,76 @@
+#include <worklets/SharedItems/SynchronizableFixed.h>
+
+#include <memory>
+#include <stdexcept>
+#include <type_traits>
+#include <variant>
+
+namespace worklets {
+
+std::shared_ptr<SynchronizableFixed> SynchronizableFixed::make(const SynchronizableFixedValue &initialValue) {
+  return std::visit(
+      [](const auto &alternative) { return std::make_shared<SynchronizableFixed>(alternative); }, initialValue);
+}
+
+SynchronizableValue SynchronizableFixed::getDirty() {
+  return load();
+}
+
+SynchronizableValue SynchronizableFixed::getBlocking() {
+  getBlockingBefore();
+  auto value = load();
+  getBlockingAfter();
+  return value;
+}
+
+void SynchronizableFixed::setDirty(const SynchronizableFixedValue &value) {
+  setDirtyBefore();
+  const auto stored = store(value);
+  setDirtyAfter();
+  if (!stored) {
+    throwTypeMismatch();
+  }
+}
+
+void SynchronizableFixed::setBlocking(const std::shared_ptr<Serializable> &) {
+  throw std::runtime_error("[Worklets] Fixed-type Synchronizable operates on plain values, not Serializables.");
+}
+
+void SynchronizableFixed::setBlocking(const SynchronizableFixedValue &value) {
+  setBlockingBefore();
+  const auto stored = store(value);
+  setBlockingAfter();
+  if (!stored) {
+    throwTypeMismatch();
+  }
+}
+
+bool SynchronizableFixed::store(const SynchronizableFixedValue &value) {
+  return std::visit(
+      [](auto &atomic, const auto &alternative) {
+        using TAtomic = std::decay_t<decltype(atomic)>;
+        using TAlternative = std::decay_t<decltype(alternative)>;
+        if constexpr (std::is_same_v<TAtomic, std::atomic<TAlternative>>) {
+          atomic.store(alternative, std::memory_order_relaxed);
+          return true;
+        } else {
+          return false;
+        }
+      },
+      value_,
+      value);
+}
+
+SynchronizableValue SynchronizableFixed::load() const {
+  return std::visit(
+      [](const auto &atomic) { return SynchronizableValue(atomic.load(std::memory_order_relaxed)); }, value_);
+}
+
+void SynchronizableFixed::throwTypeMismatch() const {
+  throw std::runtime_error(
+      std::holds_alternative<std::atomic<double>>(value_)
+          ? "[Worklets] Expected a number for a fixed-type Synchronizable."
+          : "[Worklets] Expected a boolean for a fixed-type Synchronizable.");
+}
+
+} // namespace worklets

package/Common/cpp/worklets/SharedItems/SynchronizableFixed.h

@@ -0,0 +1,48 @@
+#pragma once
+
+#include <worklets/SharedItems/Synchronizable.h>
+
+#include <atomic>
+#include <memory>
+#include <type_traits>
+#include <variant>
+
+namespace worklets {
+
+class SynchronizableFixed final : public Synchronizable {
+ public:
+  explicit SynchronizableFixed(double value)
+      : Synchronizable(true), value_(std::in_place_type<std::atomic<double>>, value) {}
+
+  explicit SynchronizableFixed(bool value)
+      : Synchronizable(true), value_(std::in_place_type<std::atomic<bool>>, value) {}
+
+  template <
+      typename TInteger,
+      typename = std::enable_if_t<std::is_integral_v<TInteger> && !std::is_same_v<TInteger, bool>>>
+  explicit SynchronizableFixed(TInteger value) = delete;
+
+  static std::shared_ptr<SynchronizableFixed> make(const SynchronizableFixedValue &initialValue);
+
+  SynchronizableValue getDirty() override;
+
+  SynchronizableValue getBlocking() override;
+
+  void setDirty(const SynchronizableFixedValue &value) override;
+
+  void setBlocking(const std::shared_ptr<Serializable> &value) override;
+
+  void setBlocking(const SynchronizableFixedValue &value) override;
+
+ private:
+  bool store(const SynchronizableFixedValue &value);
+  SynchronizableValue load() const;
+  [[noreturn]] void throwTypeMismatch() const;
+
+  std::variant<std::atomic<double>, std::atomic<bool>> value_;
+};
+
+static_assert(std::atomic<double>::is_always_lock_free);
+static_assert(std::atomic<bool>::is_always_lock_free);
+
+} // namespace worklets

package/Common/cpp/worklets/Tools/ScriptBuffer.h

@@ -1,13 +1,8 @@
 #pragma once
 
-#include <cxxreact/ReactNativeVersion.h>
 #include <jsi/jsi.h>
 
-#if REACT_NATIVE_VERSION_MINOR >= 84
 #include <cxxreact/JSBigString.h>
-#else
-#include <jsireact/JSIExecutor.h>
-#endif
 
 #include <memory>
 #include <utility>

package/Common/cpp/worklets/Tools/WorkletsJSIUtils.h

@@ -11,29 +11,6 @@ using namespace facebook;
 
 namespace worklets::jsi_utils {
 
-/**
- * Drains Hermes microtasks - we don't use these, but Hermes WeakRefs are
- * cleaned during Hermes microtask checkpoint.
- */
-inline void triggerWeakRefCleanup(jsi::Runtime &rt) {
-  rt.drainMicrotasks();
-}
-
-/**
- * Drains both Worklets and Hermes microtasks.
- */
-inline void drainMicrotasks(jsi::Runtime &rt) {
-  auto callMicrotasks = rt.global().getProperty(rt, "__callMicrotasks");
-  if (callMicrotasks.isObject()) {
-    auto callMicrotasksObject = callMicrotasks.getObject(rt);
-    if (callMicrotasksObject.isFunction(rt)) {
-      callMicrotasksObject.getFunction(rt).call(rt);
-    }
-  }
-
-  triggerWeakRefCleanup(rt);
-}
-
 // `get` functions take a pointer to `jsi::Value` and
 // call an appropriate method to cast to the native type
 template <typename T>
@@ -207,16 +184,25 @@ void addMethod(jsi::Runtime &rt, jsi::Object &obj, const char *name, TFun &&func
           jsi::PropNameID::forAscii(rt, name),
           TLength,
           [func = std::forward<TFun>(func)](
-              jsi::Runtime &rt, const jsi::Value &thisVal, const jsi::Value *args, size_t) mutable -> jsi::Value {
+              jsi::Runtime &rt, const jsi::Value &thisVal, const jsi::Value *args, size_t count) mutable -> jsi::Value {
             using TReturn =
                 std::invoke_result_t<TFun &, jsi::Runtime &, const jsi::Value &, const jsi::Value(&)[TLength]>;
-            auto &typed = *reinterpret_cast<const jsi::Value(*)[TLength]>(args);
-            if constexpr (std::is_void_v<TReturn>) {
-              func(rt, thisVal, typed);
-              return jsi::Value::undefined();
-            } else {
-              return func(rt, thisVal, typed);
+            auto invoke = [&](const jsi::Value(&typed)[TLength]) -> jsi::Value {
+              if constexpr (std::is_void_v<TReturn>) {
+                func(rt, thisVal, typed);
+                return jsi::Value::undefined();
+              } else {
+                return func(rt, thisVal, typed);
+              }
+            };
+            if (count < TLength) {
+              jsi::Value padded[TLength];
+              for (size_t i = 0; i < count; ++i) {
+                padded[i] = jsi::Value(rt, args[i]);
+              }
+              return invoke(padded);
             }
+            return invoke(*reinterpret_cast<const jsi::Value(*)[TLength]>(args));
           }));
 }
 

package/Common/cpp/worklets/WorkletRuntime/RuntimeBindings.h

@@ -1,9 +1,18 @@
 #pragma once
 
 #include <jsi/jsi.h>
+#include <worklets/Networking/NetworkingBackend.h>
 
 #include <functional>
+#include <memory>
 #include <stdexcept>
+#include <string>
+
+#if defined(__APPLE__) && defined(__OBJC__)
+#import <React/RCTLog.h>
+#elif defined(ANDROID)
+#include <android/log.h>
+#endif
 
 using namespace facebook;
 
@@ -22,38 +31,26 @@ struct RuntimeBindings {
 
   const RequestAnimationFrame requestAnimationFrame;
   const NativeLoggingHook nativeLoggingHook;
-
-#ifdef WORKLETS_FETCH_PREVIEW_ENABLED
-  using AbortRequest = std::function<void(jsi::Runtime &rt, double requestId)>;
-  using ClearCookies = std::function<void(jsi::Runtime &rt, jsi::Function &&responseSender)>;
-#ifdef ANDROID
-  using SendRequest = std::function<void(
-      jsi::Runtime &rt,
-      jsi::String &method,
-      jsi::String &url,
-      double requestId,
-      jsi::Array &headers,
-      jsi::Object &data,
-      jsi::String &responseType,
-      bool incrementalUpdates,
-      double timeout,
-      bool withCredentials)>;
-#else
-  using SendRequest = std::function<void(jsi::Runtime &rt, const jsi::Value &query, jsi::Function &&responseSender)>;
-#endif // ANDROID
-
-  const AbortRequest abortRequest;
-  const ClearCookies clearCookies;
-  const SendRequest sendRequest;
-#endif // WORKLETS_FETCH_PREVIEW_ENABLED
+  const std::shared_ptr<NetworkingBackend> networkingBackend;
 };
 
-inline RuntimeBindings::NativeLoggingHook extractNativeLoggingHookFromRNRuntime(jsi::Runtime &rnRuntime) {
-  auto nativeLoggingHookValue = rnRuntime.global().getProperty(rnRuntime, "nativeLoggingHook");
-  if (!nativeLoggingHookValue.isObject() || !nativeLoggingHookValue.asObject(rnRuntime).isFunction(rnRuntime)) {
-    throw std::runtime_error("[Worklets] nativeLoggingHook is missing.");
-  }
-  return nativeLoggingHookValue.asObject(rnRuntime).asFunction(rnRuntime).getHostFunction(rnRuntime);
+#if defined(ANDROID) || (defined(__APPLE__) && defined(__OBJC__))
+inline RuntimeBindings::NativeLoggingHook makeNativeLoggingHook() {
+  return [](jsi::Runtime &rt, const jsi::Value &, const jsi::Value *args, size_t count) -> jsi::Value {
+    if (count != 2) {
+      throw std::invalid_argument("nativeLoggingHook takes 2 arguments");
+    }
+    const auto message = args[0].asString(rt).utf8(rt);
+    const auto logLevel = static_cast<unsigned int>(args[1].asNumber());
+#if defined(__APPLE__)
+    _RCTLogJavaScriptInternal(static_cast<RCTLogLevel>(logLevel), [NSString stringWithUTF8String:message.c_str()]);
+#else
+    __android_log_write(
+        static_cast<android_LogPriority>(logLevel + ANDROID_LOG_DEBUG), "ReactNativeJS", message.c_str());
+#endif
+    return jsi::Value::undefined();
+  };
 }
+#endif // defined(ANDROID) || (defined(__APPLE__) && defined(__OBJC__))
 
 } // namespace worklets

package/Common/cpp/worklets/WorkletRuntime/RuntimeManager.cpp

@@ -56,11 +56,12 @@ std::shared_ptr<WorkletRuntime> RuntimeManager::createWorkletRuntime(
     const std::shared_ptr<SerializableWorklet> &initializer,
     const std::shared_ptr<AsyncQueue> &queue,
     bool enableEventLoop,
-    bool enableLocking) {
+    bool enableLocking,
+    bool enableNetworking) {
   const auto runtimeId = getNextRuntimeId();
 
   const auto workletRuntime = std::make_shared<WorkletRuntime>(
-      runtimeId, RuntimeData::RuntimeKind::Worker, name, queue, enableEventLoop, enableLocking);
+      runtimeId, RuntimeData::RuntimeKind::Worker, name, queue, enableEventLoop, enableLocking, enableNetworking);
   const auto targetProxy = JSIWorkletsModuleProxy::createForNewRuntime(sourceProxy, runtimeId);
 
   workletRuntime->init(targetProxy);
@@ -70,7 +71,7 @@ std::shared_ptr<WorkletRuntime> RuntimeManager::createWorkletRuntime(
 #endif // NDEBUG
 
   if (initializer) {
-    workletRuntime->runSync(initializer);
+    workletRuntime->runSyncAndDiscard(initializer);
   }
 
   registerRuntime(runtimeId, workletRuntime);

package/Common/cpp/worklets/WorkletRuntime/RuntimeManager.h

@@ -36,7 +36,8 @@ class RuntimeManager {
       const std::shared_ptr<SerializableWorklet> &initializer = nullptr,
       const std::shared_ptr<AsyncQueue> &queue = nullptr,
       bool enableEventLoop = true,
-      bool enableLocking = true);
+      bool enableLocking = true,
+      bool enableNetworking = true);
 
   std::shared_ptr<WorkletRuntime> createUninitializedUIRuntime(const std::shared_ptr<AsyncQueue> &uiAsyncQueue);