react-native-nitro-modules 0.0.2 → 0.0.4

package/cpp/jsi/Promise.hpp

@@ -0,0 +1,54 @@
+//
+//  Promise.hpp
+//  react-native-filament
+//
+//  Created by Marc Rousavy on 11.03.24.
+//
+
+#pragma once
+
+#include "OwningReference.hpp"
+#include <functional>
+#include <jsi/jsi.h>
+#include <memory>
+
+namespace margelo::nitro {
+
+using namespace facebook;
+
+/**
+ Represents a JS Promise.
+
+ `Promise` is not thread-safe: It has to be resolved/rejected
+ on the same thread and Runtime as it was created on.
+ */
+class Promise final {
+public:
+  Promise(jsi::Runtime& runtime, jsi::Function&& resolver, jsi::Function&& rejecter);
+
+  /**
+   Resolve the Promise with the given `jsi::Value`.
+   If the `jsi::Runtime` has already been deleted, this will do nothing.
+   */
+  void resolve(jsi::Runtime& runtime, jsi::Value&& result);
+  /**
+   Resolve the Promise with the given error message.
+   If the `jsi::Runtime` has already been deleted, this will do nothing.
+   */
+  void reject(jsi::Runtime& runtime, std::string error);
+
+private:
+  OwningReference<jsi::Function> _resolver;
+  OwningReference<jsi::Function> _rejecter;
+  static constexpr auto TAG = "Promise";
+
+public:
+  using RunPromise = std::function<void(jsi::Runtime& runtime, std::shared_ptr<Promise> promise)>;
+  /**
+   Create a new Promise using the JS `Promise` constructor and runs the given `run` function.
+   The resulting Promise should be returned to JS so it can be awaited.
+   */
+  static jsi::Value createPromise(jsi::Runtime& runtime, RunPromise&& run);
+};
+
+} // namespace margelo::nitro

package/cpp/platform/ThreadUtils.hpp

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

package/cpp/registry/HybridObjectRegistry.cpp

@@ -0,0 +1,57 @@
+//
+//  HybridObjectRegistry.cpp
+//  DoubleConversion
+//
+//  Created by Marc Rousavy on 22.07.24.
+//
+
+#include "HybridObjectRegistry.hpp"
+#include "NitroLogger.hpp"
+
+namespace margelo::nitro {
+
+std::unordered_map<std::string, HybridObjectRegistry::HybridObjectConstructorFn>& HybridObjectRegistry::getRegistry() {
+  static std::unordered_map<std::string, HybridObjectRegistry::HybridObjectConstructorFn> _constructorsMap;
+  return _constructorsMap;
+}
+
+void HybridObjectRegistry::registerHybridObjectConstructor(std::string hybridObjectName, HybridObjectConstructorFn&& constructorFn) {
+  Logger::log(TAG, "Registering HybridObject \"%s\"...", hybridObjectName);
+  auto& map = HybridObjectRegistry::getRegistry();
+  if (map.contains(hybridObjectName)) [[unlikely]] {
+    auto message =
+        "HybridObject \"" + std::string(hybridObjectName) +
+        "\" has already been "
+        "registered in the Nitro Modules HybridObjectRegistry! Suggestions:\n"
+        "- If you just installed another library, maybe both libraries are using the same name?\n"
+        "- If you just registered your own HybridObject, maybe you accidentally called `registerHybridObjectConstructor(...)` twice?";
+    throw std::runtime_error(message);
+  }
+  map.insert({hybridObjectName, std::move(constructorFn)});
+  Logger::log(TAG, "Successfully registered HybridObject \"%s\"!", hybridObjectName);
+}
+
+std::shared_ptr<HybridObject> HybridObjectRegistry::createHybridObject(std::string hybridObjectName) {
+  auto& map = HybridObjectRegistry::getRegistry();
+  auto fn = map.find(hybridObjectName);
+  if (fn == map.end()) [[unlikely]] {
+    auto message = "Cannot create an instance of HybridObject \"" + std::string(hybridObjectName) +
+                   "\" - "
+                   "It has not yet been registered in the Nitro Modules HybridObjectRegistry!";
+    throw std::runtime_error(message);
+  }
+  std::shared_ptr<HybridObject> instance = fn->second();
+
+#if DEBUG
+  if (instance->getName() != hybridObjectName) [[unlikely]] {
+    throw std::runtime_error("HybridObject's name (\"" + instance->getName() +
+                             "\") does not match"
+                             "the name it was registered with (\"" +
+                             hybridObjectName + "\")!");
+  }
+#endif
+
+  return instance;
+}
+
+} // namespace margelo::nitro

package/cpp/registry/HybridObjectRegistry.hpp

@@ -0,0 +1,44 @@
+//
+//  HybridObjectRegistry.hpp
+//  DoubleConversion
+//
+//  Created by Marc Rousavy on 22.07.24.
+//
+
+#pragma once
+
+#include "HybridObject.hpp"
+#include <functional>
+#include <string>
+
+namespace margelo::nitro {
+
+/**
+ * A registry that holds initializers for HybridObjects.
+ * This will be used to initialize them from JS using `NitroModules.get<T>(name)`.
+ */
+class HybridObjectRegistry {
+public:
+  HybridObjectRegistry() = delete;
+
+public:
+  using HybridObjectConstructorFn = std::function<std::shared_ptr<HybridObject>()>;
+
+public:
+  /**
+   * Registers the given HybridObject in the `HybridObjectRegistry`.
+   * It will be uniquely identified via it's `hybridObjectName`, and can be initialized from
+   * JS using `NitroModules.get<T>(name)` - which will call the `constructorFn` here.
+   */
+  static void registerHybridObjectConstructor(std::string hybridObjectName, HybridObjectConstructorFn&& constructorFn);
+
+  static std::shared_ptr<HybridObject> createHybridObject(std::string hybridObjectName);
+
+private:
+  static std::unordered_map<std::string, HybridObjectConstructorFn>& getRegistry();
+
+private:
+  static constexpr auto TAG = "HybridObjectRegistry";
+};
+
+} // namespace margelo::nitro

package/cpp/test-object/TestHybridObject.cpp

@@ -0,0 +1,37 @@
+//
+// Created by Marc Rousavy on 20.02.24.
+//
+
+#include "TestHybridObject.hpp"
+
+namespace margelo::nitro {
+
+void TestHybridObject::loadHybridMethods() {
+  HybridObject::loadHybridMethods();
+
+  // this.int get & set
+  registerHybridGetter("int", &TestHybridObject::getInt, this);
+  registerHybridSetter("int", &TestHybridObject::setInt, this);
+  // this.string get & set
+  registerHybridGetter("string", &TestHybridObject::getString, this);
+  registerHybridSetter("string", &TestHybridObject::setString, this);
+  // this.nullableString get & set
+  registerHybridGetter("nullableString", &TestHybridObject::getNullableString, this);
+  registerHybridSetter("nullableString", &TestHybridObject::setNullableString, this);
+  // methods
+  registerHybridMethod("multipleArguments", &TestHybridObject::multipleArguments, this);
+  // callbacks
+  registerHybridMethod("getIntGetter", &TestHybridObject::getIntGetter, this);
+  registerHybridMethod("sayHelloCallback", &TestHybridObject::sayHelloCallback, this);
+  // custom types
+  registerHybridMethod("createNewHybridObject", &TestHybridObject::createNewHybridObject, this);
+  // Promises
+  registerHybridMethod("calculateFibonacci", &TestHybridObject::calculateFibonacci, this);
+  registerHybridMethod("calculateFibonacciAsync", &TestHybridObject::calculateFibonacciAsync, this);
+  registerHybridMethod("asyncVoidFunc", &TestHybridObject::asyncVoidFunc, this);
+  registerHybridMethod("syncVoidFunc", &TestHybridObject::syncVoidFunc, this);
+  // Error
+  registerHybridMethod("throwError", &TestHybridObject::throwError, this);
+}
+
+} // namespace margelo::nitro

package/cpp/test-object/TestHybridObject.hpp

@@ -0,0 +1,87 @@
+//
+// Created by Marc Rousavy on 22.02.24.
+//
+
+#pragma once
+
+#include "HybridObject.hpp"
+#include <optional>
+#include <string>
+#include <vector>
+
+namespace margelo::nitro {
+
+class TestHybridObject : public HybridObject {
+public:
+  explicit TestHybridObject() : HybridObject("TestHybridObject") {}
+
+public:
+  int getInt() {
+    return _int;
+  }
+  void setInt(int newValue) {
+    _int = newValue;
+  }
+  std::string getString() {
+    return _string;
+  }
+  void setString(const std::string& newValue) {
+    _string = newValue;
+  }
+  std::optional<std::string> getNullableString() {
+    return _nullableString;
+  }
+  void setNullableString(std::optional<std::string> string) {
+    _nullableString = string;
+  }
+
+  std::unordered_map<std::string, double> multipleArguments(int first, bool second, std::string third) {
+    return std::unordered_map<std::string, double>{{"first", 5312}, {"second", 532233}, {"third", 2786}};
+  }
+
+  std::function<int()> getIntGetter() {
+    return [this]() -> int { return this->_int; };
+  }
+  void sayHelloCallback(std::function<void(std::string)> callback) {
+    callback("Test Hybrid");
+  }
+  std::shared_ptr<TestHybridObject> createNewHybridObject() {
+    return std::make_shared<TestHybridObject>();
+  }
+
+  void throwError() {
+    throw std::runtime_error("This is an error!");
+  }
+
+  uint64_t calculateFibonacci(int count) {
+    if (count <= 0)
+      return 0;
+    if (count == 1)
+      return 1;
+
+    return calculateFibonacci(count - 1) + calculateFibonacci(count - 2);
+  }
+
+  std::future<uint64_t> calculateFibonacciAsync(int count) {
+    return std::async(std::launch::async, [count, this]() { return this->calculateFibonacci(count); });
+  }
+
+  void syncVoidFunc() {
+    // this function does nothing
+  }
+
+  std::future<void> asyncVoidFunc() {
+    return std::async(std::launch::async, []() {
+      // this function does nothing
+    });
+  }
+
+private:
+  int _int;
+  std::string _string;
+  std::optional<std::string> _nullableString;
+
+  void loadHybridMethods() override;
+};
+
+} // namespace margelo::nitro

package/cpp/threading/CallInvokerDispatcher.hpp

@@ -0,0 +1,33 @@
+//
+// Created by Marc Rousavy on 27.03.24.
+//
+
+#pragma once
+
+#include "Dispatcher.hpp"
+#include <ReactCommon/CallInvoker.h>
+
+namespace margelo::nitro {
+
+using namespace facebook;
+
+/**
+ * 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::nitro

package/cpp/threading/Dispatcher.cpp

@@ -0,0 +1,56 @@
+#include "Dispatcher.hpp"
+#include "GetRuntimeID.hpp"
+#include "NitroLogger.hpp"
+
+namespace margelo::nitro {
+
+using namespace facebook;
+
+static constexpr auto GLOBAL_DISPATCHER_HOLDER_NAME = "__nitroDispatcher";
+
+std::unordered_map<jsi::Runtime*, std::weak_ptr<Dispatcher>> Dispatcher::_globalCache;
+
+void Dispatcher::installRuntimeGlobalDispatcher(jsi::Runtime& runtime, std::shared_ptr<Dispatcher> dispatcher) {
+  Logger::log(TAG, "Installing global Dispatcher Holder into Runtime \"%s\"...", getRuntimeId(runtime));
+
+  // Store a weak reference in global cache
+  _globalCache[&runtime] = std::weak_ptr(dispatcher);
+
+  // Inject the dispatcher into Runtime global (runtime will hold a strong reference)
+  jsi::Object dispatcherHolder(runtime);
+  dispatcherHolder.setNativeState(runtime, dispatcher);
+  runtime.global().setProperty(runtime, GLOBAL_DISPATCHER_HOLDER_NAME, dispatcherHolder);
+}
+
+std::shared_ptr<Dispatcher> Dispatcher::getRuntimeGlobalDispatcher(jsi::Runtime& runtime) {
+  if (_globalCache.contains(&runtime)) [[likely]] {
+    // the runtime is known - we have something in cache
+    std::weak_ptr<Dispatcher> weakDispatcher = _globalCache[&runtime];
+    std::shared_ptr<Dispatcher> strongDispatcher = weakDispatcher.lock();
+    if (strongDispatcher) {
+      // the weak reference we cached is still valid - return it!
+      return strongDispatcher;
+    }
+  }
+
+  Logger::log(TAG, "Unknown Runtime (%s), looking for Dispatcher through JSI global lookup...", getRuntimeId(runtime));
+  jsi::Value dispatcherHolderValue = getRuntimeGlobalDispatcherHolder(runtime);
+  jsi::Object dispatcherHolder = dispatcherHolderValue.getObject(runtime);
+  return dispatcherHolder.getNativeState<Dispatcher>(runtime);
+}
+
+jsi::Value Dispatcher::getRuntimeGlobalDispatcherHolder(jsi::Runtime& runtime) {
+#if DEBUG
+  if (!runtime.global().hasProperty(runtime, GLOBAL_DISPATCHER_HOLDER_NAME)) {
+    throw std::runtime_error("Failed to get current Dispatcher - the global Dispatcher "
+                             "holder (global." +
+                             std::string(GLOBAL_DISPATCHER_HOLDER_NAME) +
+                             ") "
+                             "does not exist! Was Dispatcher::installDispatcherIntoRuntime() called "
+                             "for this jsi::Runtime?");
+  }
+#endif
+  return runtime.global().getProperty(runtime, GLOBAL_DISPATCHER_HOLDER_NAME);
+}
+
+} // namespace margelo::nitro

package/cpp/threading/Dispatcher.hpp

@@ -0,0 +1,82 @@
+//
+// Created by Marc Rousavy on 12.03.24.
+//
+
+#pragma once
+
+#include <functional>
+#include <future>
+#include <jsi/jsi.h>
+#include <queue>
+#include <unordered_map>
+
+namespace margelo::nitro {
+
+using namespace facebook;
+
+class Dispatcher : public jsi::NativeState {
+public:
+  /**
+   Installs the Dispatcher into the given Runtime.
+   It can be accessed using `getRuntimeGlobalDispatcher` later.
+   */
+  static void installRuntimeGlobalDispatcher(jsi::Runtime& runtime, std::shared_ptr<Dispatcher> dispatcher);
+  /**
+   Gets the global Dispatcher in the given Runtime, or throws an error if not found.
+  */
+  static std::shared_ptr<Dispatcher> getRuntimeGlobalDispatcher(jsi::Runtime& runtime);
+
+private:
+  static jsi::Value getRuntimeGlobalDispatcherHolder(jsi::Runtime& runtime);
+
+public:
+  /**
+   * Run the given void function synchronously on the Thread this Dispatcher is managing.
+   */
+  virtual void runSync(std::function<void()>&& function) = 0;
+
+  /**
+   * Run the given void function asynchronously on the Thread this Dispatcher is managing.
+   */
+  virtual void runAsync(std::function<void()>&& function) = 0;
+
+  /**
+   * Run the given function asynchronously on the Thread this Dispatcher is managing,
+   * and return a future that will hold the result of the function.
+   */
+  template <typename T> std::future<T> runAsyncAwaitable(std::function<T()>&& function) {
+    // 1. Create Promise that can be shared between this and dispatcher thread
+    auto promise = std::make_shared<std::promise<T>>();
+    std::future<T> future = promise->get_future();
+
+    runAsync([function = std::move(function), promise]() {
+      try {
+        if constexpr (std::is_void_v<T>) {
+          // 4. Call the actual function on the new Thread
+          function();
+          // 5.a. Resolve the Promise if we succeeded
+          promise->set_value();
+        } else {
+          // 4. Call the actual function on the new Thread
+          T result = function();
+          // 5.a. Resolve the Promise if we succeeded
+          promise->set_value(std::move(result));
+        }
+      } catch (...) {
+        // 5.b. Reject the Promise if the call failed
+        promise->set_exception(std::current_exception());
+      }
+    });
+
+    // 3. Return an open future that gets resolved later by the dispatcher Thread
+    return future;
+  }
+
+private:
+  static std::unordered_map<jsi::Runtime*, std::weak_ptr<Dispatcher>> _globalCache;
+
+private:
+  static constexpr auto TAG = "Dispatcher";
+};
+
+} // namespace margelo::nitro

package/cpp/turbomodule/NativeNitroModules.cpp

@@ -0,0 +1,70 @@
+//
+//  NativeNitroModules.cpp
+//  NitroModules
+//
+//  Created by Marc Rousavy on 21.06.24.
+//
+
+#include "NativeNitroModules.hpp"
+#include "CallInvokerDispatcher.hpp"
+#include "Dispatcher.hpp"
+#include "HybridObjectRegistry.hpp"
+#include "TestHybridObject.hpp"
+
+namespace facebook::react {
+
+using namespace margelo::nitro;
+
+NativeNitroModules::NativeNitroModules(std::shared_ptr<CallInvoker> jsInvoker)
+    : TurboModule(kModuleName, jsInvoker), _callInvoker(jsInvoker) {}
+
+NativeNitroModules::~NativeNitroModules() {}
+
+jsi::Value NativeNitroModules::get(jsi::Runtime& runtime, const jsi::PropNameID& propName) {
+  std::string name = propName.utf8(runtime);
+
+  if (name == "install") {
+    return jsi::Function::createFromHostFunction(
+        runtime, jsi::PropNameID::forUtf8(runtime, "install"), 0,
+        [=](jsi::Runtime& runtime, const jsi::Value& thisArg, const jsi::Value* args, size_t count) -> jsi::Value {
+          install(runtime);
+          return jsi::Value::undefined();
+        });
+  }
+  if (name == "createHybridObject") {
+    return jsi::Function::createFromHostFunction(
+        runtime, jsi::PropNameID::forUtf8(runtime, "install"), 2,
+        [=](jsi::Runtime& runtime, const jsi::Value& thisArg, const jsi::Value* args, size_t count) -> jsi::Value {
+          if (count != 1 && count != 2) {
+            throw jsi::JSError(runtime, "NitroModules.createHybridObject(..) expects 1 or 2 arguments, but " + std::to_string(count) +
+                                            " were supplied!");
+          }
+          jsi::String objectName = args[0].asString(runtime);
+          std::optional<jsi::Object> optionalArgs = std::nullopt;
+          if (count > 1) {
+            optionalArgs = args[1].asObject(runtime);
+          }
+
+          return createHybridObject(runtime, objectName, optionalArgs);
+        });
+  }
+
+  return jsi::Value::undefined();
+}
+
+void NativeNitroModules::install(jsi::Runtime& runtime) {
+  // Installs the global Dispatcher mechanism into this Runtime.
+  // This allows creating Promises and calling back to JS.
+  auto dispatcher = std::make_shared<CallInvokerDispatcher>(_callInvoker);
+  Dispatcher::installRuntimeGlobalDispatcher(runtime, dispatcher);
+}
+
+jsi::Object NativeNitroModules::createHybridObject(jsi::Runtime& runtime, const jsi::String& hybridObjectName,
+                                                   const std::optional<jsi::Object>& args) {
+  auto name = hybridObjectName.utf8(runtime);
+  // TODO: Pass args? Do we need that?
+  auto hybridObject = HybridObjectRegistry::createHybridObject(name.c_str());
+  return jsi::Object::createFromHostObject(runtime, hybridObject);
+}
+
+} // namespace facebook::react

package/cpp/turbomodule/NativeNitroModules.h

@@ -0,0 +1,7 @@
+//
+// Created by Marc Rousavy on 26.07.24.
+//
+
+#pragma once
+
+#include "NativeNitroModules.hpp"

package/cpp/turbomodule/NativeNitroModules.hpp

@@ -0,0 +1,35 @@
+//
+//  NativeNitroModules.hpp
+//  NitroModules
+//
+//  Created by Marc Rousavy on 21.06.24.
+//
+
+#pragma once
+
+#include <ReactCommon/TurboModule.h>
+
+namespace facebook::react {
+
+using namespace facebook;
+
+// The base C++-based TurboModule. This is the entry point where all nitro modules get initialized.
+class NativeNitroModules : public TurboModule {
+public:
+  NativeNitroModules(std::shared_ptr<CallInvoker> jsInvoker);
+  ~NativeNitroModules();
+
+public:
+  jsi::Value get(jsi::Runtime& runtime, const jsi::PropNameID& propName) override;
+
+  void install(jsi::Runtime& runtime);
+  jsi::Object createHybridObject(jsi::Runtime& runtime, const jsi::String& hybridObjectName, const std::optional<jsi::Object>& args);
+
+public:
+  constexpr static auto kModuleName = "NitroModulesCxx";
+
+private:
+  std::shared_ptr<CallInvoker> _callInvoker;
+};
+
+} // namespace facebook::react

package/cpp/turbomodule/RegisterNativeNitroModules.cpp

@@ -0,0 +1,33 @@
+//
+//  RegisterNativeNitroModules.cpp
+//  DoubleConversion
+//
+//  Created by Marc Rousavy on 21.06.24.
+//
+
+#include "RegisterNativeNitroModules.hpp"
+#include "NativeNitroModules.hpp"
+#include <memory>
+#include <string>
+
+#if __has_include(<ReactCommon/CallInvoker.h>)
+// Android style imports
+#include <ReactCommon/CallInvoker.h>
+#include <ReactCommon/CxxTurboModuleUtils.h>
+#else
+// iOS style imports
+#include <React-callinvoker/ReactCommon/CallInvoker.h>
+#include <ReactCommon/ReactCommon/CxxTurboModuleUtils.h>
+#endif
+
+namespace margelo::nitro {
+
+using namespace facebook;
+
+void RegisterNativeNitroModules::registerNativeNitroModules() {
+  react::registerCxxModuleToGlobalModuleMap(
+      std::string(react::NativeNitroModules::kModuleName),
+      [&](std::shared_ptr<react::CallInvoker> jsInvoker) { return std::make_shared<react::NativeNitroModules>(jsInvoker); });
+}
+
+} // namespace margelo::nitro

package/cpp/turbomodule/RegisterNativeNitroModules.hpp

@@ -0,0 +1,21 @@
+//
+//  RegisterNativeNitroModules.hpp
+//  DoubleConversion
+//
+//  Created by Marc Rousavy on 21.06.24.
+//
+
+#pragma once
+
+namespace margelo::nitro {
+
+class RegisterNativeNitroModules {
+public:
+  /**
+   Registers the native NitroModules TurboModule into the React Runtime.
+   This can be called from Swift/Objective-C.
+   */
+  static void registerNativeNitroModules();
+};
+
+} // namespace margelo::nitro

package/cpp/utils/BorrowingReference+Owning.hpp

@@ -0,0 +1,34 @@
+//
+//  BorrowingReference+Owning.hpp
+//  react-native-nitro
+//
+//  Created by Marc Rousavy on 23.06.24.
+//
+
+#pragma once
+
+#include "OwningReference.hpp"
+
+namespace margelo::nitro {
+
+template <typename T> BorrowingReference<T>::BorrowingReference(const OwningReference<T>& ref) {
+  _value = ref._value;
+  _isDeleted = ref._isDeleted;
+  _strongRefCount = ref._strongRefCount;
+  _weakRefCount = ref._weakRefCount;
+  _mutex = ref._mutex;
+  (*_weakRefCount)++;
+}
+
+template <typename T> OwningReference<T> BorrowingReference<T>::lock() {
+  std::unique_lock lock(*_mutex);
+
+  if (*_isDeleted) {
+    // return nullptr
+    return OwningReference<T>();
+  }
+
+  return OwningReference(*this);
+}
+
+} // namespace margelo::nitro