react-native-wgpu 0.1.13 → 0.1.14

package/android/CMakeLists.txt

@@ -25,6 +25,7 @@ find_package(fbjni REQUIRED CONFIG)
 
 add_library(${PACKAGE_NAME} SHARED
     ./cpp/cpp-adapter.cpp
+    ./cpp/platform/ThreadUtils.cpp
     ../cpp/rnwgpu/api/GPU.cpp
     ../cpp/rnwgpu/api/GPUAdapter.cpp
     ../cpp/rnwgpu/api/GPUSupportedLimits.cpp
@@ -48,6 +49,8 @@ add_library(${PACKAGE_NAME} SHARED
     ../cpp/jsi/RNFHybridObject.cpp
     ../cpp/jsi/RNFRuntimeCache.cpp
     ../cpp/jsi/RNFWorkletRuntimeRegistry.cpp
+    ../cpp/threading/Dispatcher.cpp
+    ../cpp/threading/ThreadPool.cpp
 )
 
 target_include_directories(
@@ -61,6 +64,7 @@ target_include_directories(
         "${NODE_MODULES_DIR}/react-native/ReactCommon/runtimeexecutor"
         "${NODE_MODULES_DIR}/react-native/ReactAndroid/src/main/jni"
         "${NODE_MODULES_DIR}/react-native/ReactAndroid/src/main/java/com/facebook/react/turbomodule/core/jni"
+        "${NODE_MODULES_DIR}/react-native/ReactAndroid/src/main/jni/react/turbomodule"
 
         ../cpp
         ../cpp/rnwgpu
@@ -68,6 +72,8 @@ target_include_directories(
         ../cpp/rnwgpu/api/descriptors
         ../cpp/jsi
         ../cpp/webgpu
+        ../cpp/threading
+        ../cpp/platform
 
         ${libfbjni_include_DIRS}
 )
@@ -84,5 +90,6 @@ target_link_libraries(
         android
         fbjni::fbjni
         ReactAndroid::jsi
+        ReactAndroid::reactnativejni
         webgpu_dawn
     )

package/android/build.gradle

@@ -87,10 +87,10 @@ android {
   }
 
   packagingOptions {
-    exclude "lib/arm64-v8a/libjsi.so"
-    exclude "lib/x86_64/libjsi.so"
-    exclude "lib/x86/libjsi.so"
-    exclude "lib/armeabi-v7a/libjsi.so"
+    excludes = [
+      "**/libjsi.so",
+      "**/libreactnativejni.so",
+    ]
   }
 
   buildFeatures {

package/android/cpp/cpp-adapter.cpp

@@ -5,6 +5,7 @@
 #include <jni.h>
 #include <jsi/jsi.h>
 
+#include <ReactCommon/CallInvokerHolder.h>
 #include <android/native_window_jni.h>
 #include <webgpu/webgpu_cpp.h>
 
@@ -17,13 +18,18 @@
 std::shared_ptr<rnwgpu::RNWebGPUManager> manager;
 
 extern "C" JNIEXPORT void JNICALL Java_com_webgpu_WebGPUModule_initializeNative(
-    JNIEnv *env, jobject /* this */, jlong jsRuntime, jobject jsInvokerHolder,
-    jobject blobModule) {
+    JNIEnv *env, jobject /* this */, jlong jsRuntime,
+    jobject jsCallInvokerHolder, jobject blobModule) {
   auto runtime = reinterpret_cast<facebook::jsi::Runtime *>(jsRuntime);
   jobject globalBlobModule = env->NewGlobalRef(blobModule);
+  auto jsCallInvoker{
+      facebook::jni::alias_ref<facebook::react::CallInvokerHolder::javaobject>{
+          reinterpret_cast<facebook::react::CallInvokerHolder::javaobject>(
+              jsCallInvokerHolder)} -> cthis()
+          ->getCallInvoker()};
   auto platformContext =
       std::make_shared<rnwgpu::AndroidPlatformContext>(globalBlobModule);
-  manager = std::make_shared<rnwgpu::RNWebGPUManager>(runtime, nullptr,
+  manager = std::make_shared<rnwgpu::RNWebGPUManager>(runtime, jsCallInvoker,
                                                       platformContext);
 }
 
@@ -55,7 +61,7 @@ Java_com_webgpu_WebGPUView_switchToOffscreenSurface(JNIEnv *env, jobject thiz,
                                                     jint contextId) {
   auto &registry = rnwgpu::SurfaceRegistry::getInstance();
   auto nativeSurface = registry.getSurfaceInfo(contextId)->switchToOffscreen();
-  ANativeWindow_release(reinterpret_cast<ANativeWindow *>(nativeSurface));
+  // ANativeWindow_release(reinterpret_cast<ANativeWindow *>(nativeSurface));
 }
 
 extern "C" JNIEXPORT void JNICALL Java_com_webgpu_WebGPUView_onSurfaceDestroy(

package/android/cpp/platform/ThreadUtils.cpp

@@ -0,0 +1,41 @@
+//
+//  ThreadUtils.cpp
+//  react-native-nitro
+//
+//  Created by Marc Rousavy on 14.07.24.
+//
+
+#include "ThreadUtils.h"
+#include <pthread.h>
+#include <sstream>
+#include <string>
+#include <sys/prctl.h>
+#include <thread>
+
+namespace margelo {
+
+std::string ThreadUtils::getThreadName() {
+#ifdef HAVE_ANDROID_PTHREAD_SETNAME_NP
+  // Try using pthread APIs
+  pthread_t this_thread = pthread_self();
+  char thread_name[16]; // Thread name length limit in Android is 16 characters
+
+  int result =
+      pthread_getname_np(this_thread, thread_name, sizeof(thread_name));
+  if (result == 0) {
+    return std::string(thread_name);
+  }
+#endif
+
+  // Fall back to this_thread ID
+  std::stringstream stream;
+  stream << std::this_thread::get_id();
+  std::string threadId = stream.str();
+  return "Thread #" + threadId;
+}
+
+void ThreadUtils::setThreadName(const std::string &name) {
+  prctl(PR_SET_NAME, name.c_str(), 0, 0, 0);
+}
+
+} // namespace margelo

package/apple/platform/ThreadUtils.cpp

@@ -0,0 +1,33 @@
+//
+//  ThreadUtils.cpp
+//  react-native-nitro
+//
+//  Created by Marc Rousavy on 14.07.24.
+//
+
+#include "ThreadUtils.h"
+#include <pthread.h>
+#include <sstream>
+#include <thread>
+
+namespace margelo {
+
+std::string ThreadUtils::getThreadName() {
+  // Try using pthread APIs
+  char name[256];
+  if (pthread_getname_np(pthread_self(), name, sizeof(name)) == 0) {
+    return std::string(name);
+  }
+
+  // Fall back to this_thread ID
+  std::stringstream stream;
+  stream << std::this_thread::get_id();
+  std::string threadId = stream.str();
+  return "Thread #" + threadId;
+}
+
+void ThreadUtils::setThreadName(const std::string &name) {
+  pthread_setname_np(name.c_str());
+}
+
+} // namespace margelo

package/cpp/jsi/RNFJSIConverter.h

@@ -25,6 +25,9 @@
 #include "RNFPromise.h"
 #include "RNFWorkletRuntimeRegistry.h"
 
+#include "Dispatcher.h"
+#include "ThreadPool.h"
+
 #if __has_include(<cxxabi.h>)
 #include <cxxabi.h>
 #endif
@@ -207,39 +210,55 @@ template <typename TResult> struct JSIConverter<std::future<TResult>> {
   }
   static jsi::Value toJSI(jsi::Runtime& runtime, std::future<TResult>&& arg) {
     auto sharedFuture = std::make_shared<std::future<TResult>>(std::move(arg));
-    return Promise::createPromise(runtime, [sharedFuture = std::move(sharedFuture)](jsi::Runtime& runtime,
+    std::shared_ptr<Dispatcher> strongDispatcher = Dispatcher::getRuntimeGlobalDispatcher(runtime);
+    std::weak_ptr<Dispatcher> weakDispatcher = strongDispatcher;
+
+    return Promise::createPromise(runtime, [sharedFuture = std::move(sharedFuture), weakDispatcher](jsi::Runtime& runtime,
                                                                                            std::shared_ptr<Promise> promise) {
-      try {
-        // wait until the future completes.
+      // Spawn new async thread to synchronously wait for the `future<T>` to complete
+      std::shared_ptr<ThreadPool> pool = ThreadPool::getSharedPool();
+      pool->run([promise, &runtime, weakDispatcher, sharedFuture]() {
+        // synchronously wait until the `future<T>` completes. we are running on a background task here.
         sharedFuture->wait();
 
-        if constexpr (std::is_same_v<TResult, void>) {
-          // it's returning void, just return undefined to JS
-          sharedFuture->get();
-          promise->resolve(jsi::Value::undefined());
-        } else {
-          // it's returning a custom type, convert it to a jsi::Value
-          TResult result = sharedFuture->get();
-          jsi::Value jsResult = JSIConverter<TResult>::toJSI(runtime, result);
-          promise->resolve(std::move(jsResult));
+        std::shared_ptr<Dispatcher> dispatcher = weakDispatcher.lock();
+        if (!dispatcher) {
+          throw std::runtime_error("Tried resolving Promise on JS Thread, but the `Dispatcher` has already been destroyed!");
+          return;
         }
-      } catch (const std::exception& exception) {
-        // the async function threw an error, reject the promise
-        std::string what = exception.what();
-        promise->reject(what);
-      } catch (...) {
-        // the async function threw a non-std error, try getting it
-#if __has_include(<cxxabi.h>)
-        std::string name = __cxxabiv1::__cxa_current_exception_type()->name();
-#else
-        std::string name = "<unknown>";
-#endif
-        promise->reject("Unknown non-std exception: " + name);
-      }
 
-      // This lambda owns the promise shared pointer, and we need to call its
-      // destructor correctly here - ensuring it's properly handled.
-      promise = nullptr;
+        dispatcher->runAsync([&runtime, promise, sharedFuture]() mutable {
+          try {
+            if constexpr (std::is_same_v<TResult, void>) {
+                // it's returning void, just return undefined to JS
+              sharedFuture->get();
+              promise->resolve(jsi::Value::undefined());
+            } else {
+              // it's returning a custom type, convert it to a jsi::Value
+              TResult result = sharedFuture->get();
+              jsi::Value jsResult = JSIConverter<TResult>::toJSI(runtime, result);
+              promise->resolve(std::move(jsResult));
+            }
+          } catch (const std::exception& exception) {
+            // the async function threw an error, reject the promise
+            std::string what = exception.what();
+            promise->reject(what);
+          } catch (...) {
+            // the async function threw a non-std error, try getting it
+    #if __has_include(<cxxabi.h>)
+            std::string name = __cxxabiv1::__cxa_current_exception_type()->name();
+    #else
+            std::string name = "<unknown>";
+    #endif
+            promise->reject("Unknown non-std exception: " + name);
+          }
+
+          // This lambda owns the promise shared pointer, and we need to call its
+          // destructor correctly here - otherwise it might be called
+          // from the threadPool thread.
+          promise = nullptr;
+        });
+      });
     });
   }
 };

package/cpp/platform/ThreadUtils.h

@@ -0,0 +1,30 @@
+//
+//  ThreadUtils.hpp
+//  react-native-nitro
+//
+//  Created by Marc Rousavy on 14.07.24.
+//
+#pragma once
+
+#include <string>
+
+namespace margelo {
+
+class ThreadUtils final {
+public:
+  ThreadUtils() = delete;
+
+  /**
+   * Get the current Thread's name.
+   * This is implemented differently on iOS and Android.
+   */
+  static std::string getThreadName();
+
+  /**
+   * Set the current Thread's name.
+   * This is implemented differently on iOS and Android.
+   */
+  static void setThreadName(const std::string &name);
+};
+
+} // namespace margelo

package/cpp/rnwgpu/RNWebGPUManager.cpp

@@ -1,5 +1,7 @@
 #include "RNWebGPUManager.h"
 
+#include "CallInvokerDispatcher.h"
+#include "Dispatcher.h"
 #include "GPU.h"
 #include "RNWebGPU.h"
 
@@ -22,6 +24,12 @@ RNWebGPUManager::RNWebGPUManager(
     : _jsRuntime(jsRuntime), _jsCallInvoker(jsCallInvoker),
       _platformContext(platformContext) {
 
+  // Installs the global Dispatcher mechanism into this Runtime.
+  // This allows creating Promises and calling back to JS.
+  auto dispatcher =
+      std::make_shared<margelo::CallInvokerDispatcher>(_jsCallInvoker);
+  margelo::Dispatcher::installRuntimeGlobalDispatcher(*_jsRuntime, dispatcher);
+
   auto gpu = std::make_shared<GPU>();
   auto rnWebGPU = std::make_shared<RNWebGPU>(gpu, _platformContext);
   _gpu = gpu->get();

package/cpp/rnwgpu/api/Convertors.h

@@ -175,6 +175,17 @@ public:
     return true;
   }
 
+  [[nodiscard]] bool Convert(wgpu::OptionalBool &out,
+                             const std::optional<bool> &in) {
+    out = in;
+    return true;
+  }
+
+  [[nodiscard]] bool Convert(wgpu::StringView &out, const std::string &in) {
+    out = {in.data(), in.size()};
+    return true;
+  }
+
   [[nodiscard]] bool Convert(const char *&out, const std::string &in) {
     out = in.c_str();
     return true;
@@ -481,11 +492,8 @@ public:
                              const GPUPrimitiveState &in) {
     out = {};
 
-    if (in.unclippedDepth) {
-      wgpu::PrimitiveDepthClipControl *depthClip =
-          Allocate<wgpu::PrimitiveDepthClipControl>();
-      depthClip->unclippedDepth = true;
-      out.nextInChain = depthClip;
+    if (in.unclippedDepth.has_value()) {
+      out.unclippedDepth = in.unclippedDepth.value();
     }
 
     return Convert(out.topology, in.topology) &&

package/cpp/rnwgpu/api/GPU.cpp

@@ -28,10 +28,10 @@ GPU::requestAdapter(
   wgpu::Adapter adapter = nullptr;
   _instance.RequestAdapter(
       &aOptions,
-      [](WGPURequestAdapterStatus, WGPUAdapter cAdapter, const char *message,
-         void *userdata) {
-        if (message != nullptr) {
-          fprintf(stderr, "%s", message);
+      [](WGPURequestAdapterStatus, WGPUAdapter cAdapter,
+         const WGPUStringView message, void *userdata) {
+        if (message.length) {
+          fprintf(stderr, "%s", message.data);
           return;
         }
         *static_cast<wgpu::Adapter *>(userdata) =

package/cpp/rnwgpu/api/GPUAdapter.cpp

@@ -23,7 +23,7 @@ std::future<std::shared_ptr<GPUDevice>> GPUAdapter::requestDevice(
   }
   wgpu::DeviceLostCallbackInfo info = {
       .callback = [](WGPUDevice const *device, WGPUDeviceLostReason reason,
-                     char const *message, void *userdata) {
+                     const WGPUStringView message, void *userdata) {
         const char *lostReason = "";
         switch (reason) {
         case WGPUDeviceLostReason_Destroyed:
@@ -35,12 +35,13 @@ std::future<std::shared_ptr<GPUDevice>> GPUAdapter::requestDevice(
         default:
           lostReason = "Unknown";
         }
-        Logger::logToConsole("GPU Device Lost (%s): %s", lostReason, message);
+        Logger::logToConsole("GPU Device Lost (%s): %s", lostReason,
+                             message.data);
       }};
   aDescriptor.deviceLostCallbackInfo = info;
   wgpu::UncapturedErrorCallbackInfo errorInfo;
   errorInfo.userdata = static_cast<void *>(_creationRuntime);
-  errorInfo.callback = [](WGPUErrorType type, const char *message,
+  errorInfo.callback = [](WGPUErrorType type, const WGPUStringView message,
                           void *userdata) {
     auto creationRuntime = static_cast<jsi::Runtime *>(userdata);
     const char *errorType = "";
@@ -60,16 +61,16 @@ std::future<std::shared_ptr<GPUDevice>> GPUAdapter::requestDevice(
     default:
       errorType = "Unknown";
     }
-    std::string fullMessage = std::string(errorType) + ": " + message;
-    Logger::errorToJavascriptConsole(*creationRuntime, fullMessage.c_str());
+    std::string fullMessage = std::string(errorType) + ": " + message.data;
+    Logger::errorToJavascriptConsole(*creationRuntime, fullMessage);
   };
   aDescriptor.uncapturedErrorCallbackInfo = errorInfo;
   _instance.RequestDevice(
       &aDescriptor,
       [](WGPURequestDeviceStatus status, WGPUDevice cDevice,
-         const char *message, void *userdata) {
-        if (message != nullptr) {
-          fprintf(stderr, "%s", message);
+         const WGPUStringView message, void *userdata) {
+        if (message.length) {
+          fprintf(stderr, "%s", message.data);
           return;
         }
         *static_cast<wgpu::Device *>(userdata) = wgpu::Device::Acquire(cDevice);
@@ -80,17 +81,17 @@ std::future<std::shared_ptr<GPUDevice>> GPUAdapter::requestDevice(
     throw std::runtime_error("Failed to request device");
   }
   device.SetLoggingCallback(
-      [](WGPULoggingType type, const char *message, void *userdata) {
+      [](WGPULoggingType type, const WGPUStringView message, void *userdata) {
         auto creationRuntime = static_cast<jsi::Runtime *>(userdata);
         const char *logLevel = "";
         switch (type) {
         case WGPULoggingType_Warning:
           logLevel = "Warning";
-          Logger::warnToJavascriptConsole(*creationRuntime, message);
+          Logger::warnToJavascriptConsole(*creationRuntime, message.data);
           break;
         case WGPULoggingType_Error:
           logLevel = "Error";
-          Logger::errorToJavascriptConsole(*creationRuntime, message);
+          Logger::errorToJavascriptConsole(*creationRuntime, message.data);
           break;
         case WGPULoggingType_Verbose:
           logLevel = "Verbose";
@@ -139,9 +140,9 @@ std::shared_ptr<GPUAdapterInfo> GPUAdapter::getInfo() {
 }
 
 bool GPUAdapter::getIsFallbackAdapter() {
-  wgpu::AdapterProperties adapterProperties = {};
-  _instance.GetProperties(&adapterProperties);
-  return adapterProperties.adapterType == wgpu::AdapterType::DiscreteGPU;
+  wgpu::AdapterInfo adapterInfo = {};
+  _instance.GetInfo(&adapterInfo);
+  return adapterInfo.adapterType == wgpu::AdapterType::CPU;
 }
 
 } // namespace rnwgpu

package/cpp/rnwgpu/api/GPUAdapterInfo.h

@@ -8,6 +8,7 @@
 #include "RNFHybridObject.h"
 
 #include "AsyncRunner.h"
+#include "Convertors.h"
 
 #include "webgpu/webgpu_cpp.h"
 
@@ -23,10 +24,30 @@ public:
 public:
   std::string getBrand() { return _name; }
 
-  std::string getVendor() { return _instance.vendor; }
-  std::string getArchitecture() { return _instance.architecture; }
-  std::string getDevice() { return _instance.device; }
-  std::string getDescription() { return _instance.description; }
+  std::string getVendor() {
+    if (_instance.vendor.length) {
+      return _instance.vendor.data;
+    }
+    return "";
+  }
+  std::string getArchitecture() {
+    if (_instance.architecture.length) {
+      return _instance.architecture.data;
+    }
+    return "";
+  }
+  std::string getDevice() {
+    if (_instance.device.length) {
+      return _instance.device.data;
+    }
+    return "";
+  }
+  std::string getDescription() {
+    if (_instance.device.length) {
+      return _instance.device.data;
+    }
+    return "";
+  }
 
   void loadHybridMethods() override {
     registerHybridGetter("__brand", &GPUAdapterInfo::getBrand, this);

package/cpp/rnwgpu/api/GPUCanvasContext.cpp

@@ -16,8 +16,9 @@ void GPUCanvasContext::configure(
       throw std::runtime_error("Error with SurfaceConfiguration");
     }
   }
-  if (!conv(surfaceConfiguration.usage, configuration->usage) || !conv(surfaceConfiguration.format, configuration->format)) {
-        throw std::runtime_error("Error with SurfaceConfiguration");
+  if (!conv(surfaceConfiguration.usage, configuration->usage) ||
+      !conv(surfaceConfiguration.format, configuration->format)) {
+    throw std::runtime_error("Error with SurfaceConfiguration");
   }
 
 #ifdef __APPLE__

package/cpp/rnwgpu/api/GPUDevice.cpp

@@ -76,10 +76,9 @@ std::shared_ptr<GPUShaderModule> GPUDevice::createShaderModule(
   }
   sm_desc.nextInChain = &wgsl_desc;
   if (descriptor->code.find('\0') != std::string::npos) {
-    return std::make_shared<GPUShaderModule>(
-        _instance.CreateErrorShaderModule(
-            &sm_desc, "The WGSL shader contains an illegal character '\\0'"),
-        _async, sm_desc.label);
+    auto mod = _instance.CreateErrorShaderModule(
+        &sm_desc, "The WGSL shader contains an illegal character '\\0'");
+    return std::make_shared<GPUShaderModule>(mod, _async, sm_desc.label.data);
   }
   auto module = _instance.CreateShaderModule(&sm_desc);
   return std::make_shared<GPUShaderModule>(module, _async,
@@ -337,6 +336,7 @@ std::unordered_set<std::string> GPUDevice::getFeatures() {
 }
 
 std::future<std::shared_ptr<GPUDeviceLostInfo>> GPUDevice::getLost() {
-  return m_lostPromise->get_future();
+  return std::async(std::launch::async,
+                    [=]() { return m_lostSharedFuture->get(); });
 }
 } // namespace rnwgpu

package/cpp/rnwgpu/api/GPUDevice.h

@@ -57,6 +57,10 @@ public:
         _label(label) {
     m_lostPromise =
         std::make_shared<std::promise<std::shared_ptr<GPUDeviceLostInfo>>>();
+
+    auto sharedFuture = m_lostPromise->get_future().share();
+    m_lostSharedFuture = std::make_shared<
+        std::shared_future<std::shared_ptr<GPUDeviceLostInfo>>>(sharedFuture);
   }
 
 public:
@@ -154,6 +158,8 @@ private:
   std::string _label;
   std::shared_ptr<std::promise<std::shared_ptr<GPUDeviceLostInfo>>>
       m_lostPromise;
+  std::shared_ptr<std::shared_future<std::shared_ptr<GPUDeviceLostInfo>>>
+      m_lostSharedFuture;
 };
 
-} // namespace rnwgpu
+} // namespace rnwgpu

package/cpp/rnwgpu/api/GPUFeatures.h

@@ -65,9 +65,9 @@ static void convertEnumToJSUnion(wgpu::FeatureName inEnum,
   case wgpu::FeatureName::ImplicitDeviceSynchronization:
     *outUnion = "implicit-device-synchronization";
     break;
-  case wgpu::FeatureName::SurfaceCapabilities:
-    *outUnion = "surface-capabilities";
-    break;
+    //  case wgpu::FeatureName::SurfaceCapabilities:
+    //    *outUnion = "surface-capabilities";
+    //    break;
   case wgpu::FeatureName::TransientAttachments:
     *outUnion = "transient-attachments";
     break;
@@ -218,4 +218,4 @@ static void convertEnumToJSUnion(wgpu::FeatureName inEnum,
   }
 }
 
-} // namespace rnwgpu
+} // namespace rnwgpu

package/cpp/rnwgpu/api/GPUShaderModule.cpp

@@ -18,7 +18,8 @@ GPUShaderModule::getCompilationInfo() {
             for (size_t i = 0; i < compilationInfo->messageCount; ++i) {
               const auto &wgpuMessage = compilationInfo->messages[i];
               GPUCompilationMessage message;
-              message.message = wgpuMessage.message ? wgpuMessage.message : "";
+              message.message =
+                  wgpuMessage.message.length ? wgpuMessage.message.data : "";
               message.type = wgpuMessage.type;
               message.lineNum = wgpuMessage.lineNum;
               message.linePos = wgpuMessage.linePos;

package/cpp/rnwgpu/api/descriptors/GPUCanvasConfiguration.h

@@ -60,7 +60,9 @@ struct JSIConverter<std::shared_ptr<rnwgpu::GPUCanvasConfiguration>> {
                                                                       false);
       }
       if (value.hasProperty(runtime, "alphaMode")) {
-        auto prop = value.getProperty(runtime, "alphaMode").asString(runtime).utf8(runtime);
+        auto prop = value.getProperty(runtime, "alphaMode")
+                        .asString(runtime)
+                        .utf8(runtime);
         if (prop == "premultiplied") {
           result->alphaMode = wgpu::CompositeAlphaMode::Premultiplied;
         }

package/cpp/threading/CallInvokerDispatcher.h

@@ -0,0 +1,37 @@
+
+//
+// Created by Marc Rousavy on 27.03.24.
+//
+
+#pragma once
+
+#include "Dispatcher.h"
+
+#include <utility>
+#include <memory>
+#include <ReactCommon/CallInvoker.h>
+
+namespace margelo {
+
+/**
+ * A Dispatcher that uses react::CallInvoker for it's implementation
+ */
+class CallInvokerDispatcher final : public Dispatcher {
+public:
+  explicit CallInvokerDispatcher(
+      std::shared_ptr<react::CallInvoker> callInvoker)
+      : _callInvoker(callInvoker) {}
+
+  void runAsync(std::function<void()> &&function) override {
+    _callInvoker->invokeAsync(std::move(function));
+  }
+
+  void runSync(std::function<void()> &&function) override {
+    _callInvoker->invokeSync(std::move(function));
+  }
+
+private:
+  std::shared_ptr<react::CallInvoker> _callInvoker;
+};
+
+} // namespace margelo