react-native-nitro-modules 0.1.5 → 0.1.6

package/cpp/core/HybridObject.cpp

@@ -99,7 +99,7 @@ jsi::Value HybridObject::toObject(jsi::Runtime& runtime) {
   }
 
   // 2. There is either no value in cache, or it's already dead. Create a new one
-  auto cache = JSICache<jsi::Object>::getOrCreateCache(runtime);
+  auto cache = JSICache::getOrCreateCache(runtime);
   // 3. Create a new jsi::Object from this HybridObject/jsi::HostObject
   std::shared_ptr<HybridObject> shared = shared_from_this();
   jsi::Object object = jsi::Object::createFromHostObject(runtime, shared);
@@ -107,7 +107,7 @@ jsi::Value HybridObject::toObject(jsi::Runtime& runtime) {
   size_t memorySize = getTotalExternalMemorySize();
   object.setExternalMemoryPressure(runtime, memorySize);
   // 5. Make it a global (weak) reference
-  auto global = cache.makeGlobal(std::move(object));
+  auto global = cache.makeGlobal<jsi::Object>(std::move(object));
   _jsObjects[&runtime] = global.weak();
   // 6. Return a jsi::Value copy again to the caller.
   return jsi::Value(runtime, *global);
@@ -177,12 +177,12 @@ jsi::Value HybridObject::get(facebook::jsi::Runtime& runtime, const facebook::js
     // it's a function. we now need to wrap it in a jsi::Function, store it in cache, then return it.
     HybridFunction& hybridFunction = _methods.at(name);
     // get (or create) a runtime-specific function cache
-    auto runtimeCache = JSICache<jsi::Function>::getOrCreateCache(runtime);
+    auto runtimeCache = JSICache::getOrCreateCache(runtime);
     // create the jsi::Function
     jsi::Function function = jsi::Function::createFromHostFunction(runtime, jsi::PropNameID::forUtf8(runtime, name),
                                                                    hybridFunction.parameterCount, hybridFunction.function);
     // throw it into the cache for next time
-    OwningReference<jsi::Function> globalFunction = runtimeCache.makeGlobal(std::move(function));
+    OwningReference<jsi::Function> globalFunction = runtimeCache.makeGlobal<jsi::Function>(std::move(function));
     functionCache[name] = globalFunction;
     // copy the reference & return it to JS
     return jsi::Value(runtime, *globalFunction);

package/cpp/jsi/JSICache.cpp

@@ -0,0 +1,55 @@
+//
+//  JSICache.cpp
+//  NitroModules
+//
+//  Created by Marc Rousavy on 20.06.24.
+//
+
+#include "JSICache.hpp"
+
+namespace margelo::nitro {
+
+static constexpr auto CACHE_PROP_NAME = "__nitroModulesJSICache";
+
+JSICache::~JSICache() {
+  Logger::log(TAG, "Destroying JSICache...");
+  std::unique_lock lock(_mutex);
+
+  for (auto& func : _cache) {
+    OwningReference<jsi::Object> owning = func.lock();
+    if (owning) {
+      // Destroy all functions that we might still have in cache, some callbacks and Promises may now become invalid.
+      owning.destroy();
+    }
+  }
+}
+
+JSICacheReference JSICache::getOrCreateCache(jsi::Runtime& runtime) {
+  auto found = _globalCache.find(&runtime);
+  if (found != _globalCache.end()) {
+    // Fast path: get weak_ptr to JSICache from our global list.
+    std::weak_ptr<JSICache> weak = found->second;
+    std::shared_ptr<JSICache> strong = weak.lock();
+    if (strong) {
+      // It's still alive! Return it
+      return JSICacheReference(strong);
+    }
+    Logger::log(TAG, "JSICache was created, but it is no longer strong!");
+  }
+
+  // Cache doesn't exist yet.
+  Logger::log(TAG, "Creating new JSICache<T> for runtime %s..", getRuntimeId(runtime));
+  // Create new cache
+  auto nativeState = std::make_shared<JSICache>(&runtime);
+  // Wrap it in a jsi::Value using NativeState
+  jsi::Object cache(runtime);
+  cache.setNativeState(runtime, nativeState);
+  // Inject it into the jsi::Runtime's global so it's memory is managed by it
+  runtime.global().setProperty(runtime, CACHE_PROP_NAME, std::move(cache));
+  // Add it to our map of caches
+  _globalCache[&runtime] = nativeState;
+  // Return it
+  return JSICacheReference(nativeState);
+}
+
+} // namespace margelo::nitro

package/cpp/jsi/JSICache.hpp

@@ -21,73 +21,23 @@ namespace margelo::nitro {
 
 using namespace facebook;
 
-static constexpr auto CACHE_PROP_NAME = "__nitroModulesJSICache";
-
-template <typename T>
-class JSICache;
-
-template <typename T>
-class JSICacheReference final {
-public:
-  JSICacheReference() = delete;
-  JSICacheReference(const JSICacheReference&) = delete;
-  JSICacheReference(JSICacheReference&&) = delete;
-
-  ~JSICacheReference() {
-    _strongCache->_mutex.unlock();
-  }
-
-public:
-  /**
-   Creates a reference to a `jsi::Value` that can be stored in memory and accessed later.
-   The `jsi::Value` will be managed by the `jsi::Runtime`, if the `jsi::Runtime` gets the destroyed,
-   so will the `jsi::Value`.
-
-   To access the `jsi::Value`, try to `.lock()` the `weak_ptr`.
-   If it can be locked, it is still valid, otherwise the Runtime has already been deleted.
-   Do not hold the returned `shared_ptr` in memory, only use it in the calling function's scope.
-   Note: By design, this is not thread-safe, the returned `weak_ptr` must only be locked on the same thread as it was created on.
-   */
-  OwningReference<T> makeGlobal(T&& value) {
-    auto owning = OwningReference<T>(new T(std::move(value)));
-    _strongCache->_cache.push_back(owning.weak());
-    return owning;
-  }
-
-private:
-  explicit JSICacheReference(const std::shared_ptr<JSICache<T>>& cache) : _strongCache(cache) {
-    _strongCache->_mutex.lock();
-  }
-
-private:
-  std::shared_ptr<JSICache<T>> _strongCache;
-
-  friend class JSICache<T>;
-};
+class JSICacheReference;
 
 /**
- * A `JSICache` can safely store `jsi::Pointer` instances (e.g. `jsi::Object` or
+ * A `JSICache` can safely store `jsi::Object` instances (e.g. `jsi::Object` or
  * `jsi::Function`) inside `OwningReference<T>`.
  *
- * `jsi::Pointer`s are managed by a `jsi::Runtime`, and will be deleted if the `jsi::Runtime`
- * is deleted - even if there are still strong references to the `jsi::Pointer`.
+ * `jsi::Object`s are managed by a `jsi::Runtime`, and will be deleted if the `jsi::Runtime`
+ * is deleted - even if there are still strong references to the `jsi::Object`.
+ *
+ * To access a `OwningReference<jsi::Object>` safely, use `lock()` to get an `OwningLock<jsi::Object>`.
+ * This will allow you to access the `jsi::Object` as long as the `OwningLock` is alive,
+ * and `JSICache` will hold any garbage collection calls until the `OwningLock` is destroyed.
  */
-template <typename T = jsi::Pointer>
 class JSICache final : public jsi::NativeState {
 public:
   explicit JSICache(jsi::Runtime* runtime) : _runtime(runtime) {}
-
-  ~JSICache() {
-    std::unique_lock lock(_mutex);
-
-    for (auto& func : _cache) {
-      OwningReference<T> owning = func.lock();
-      if (owning) {
-        // Destroy all functions that we might still have in cache, some callbacks and Promises may now become invalid.
-        owning.destroy();
-      }
-    }
-  }
+  ~JSICache();
 
 public:
   JSICache() = delete;
@@ -102,47 +52,61 @@ public:
    Do not hold the returned `shared_ptr` in memory, only use it in the calling function's scope.
    */
   [[nodiscard]]
-  static JSICacheReference<T> getOrCreateCache(jsi::Runtime& runtime) {
-    auto found = _globalCache.find(&runtime);
-    if (found != _globalCache.end()) {
-      // Fast path: get weak_ptr to JSICache from our global list.
-      std::weak_ptr<JSICache<T>> weak = found->second;
-      std::shared_ptr<JSICache<T>> strong = weak.lock();
-      if (strong) {
-        // It's still alive! Return it
-        return JSICacheReference<T>(strong);
-      }
-    }
-
-    // Cache doesn't exist yet.
-    Logger::log(TAG, "Creating new JSICache<T> for runtime %s..", getRuntimeId(runtime));
-    // Create new cache
-    auto nativeState = std::make_shared<JSICache<T>>(&runtime);
-    // Wrap it in a jsi::Value using NativeState
-    jsi::Object cache(runtime);
-    cache.setNativeState(runtime, nativeState);
-    // Inject it into the jsi::Runtime's global so it's memory is managed by it
-    runtime.global().setProperty(runtime, CACHE_PROP_NAME, std::move(cache));
-    // Add it to our map of caches
-    _globalCache[&runtime] = nativeState;
-    // Return it
-    return JSICacheReference<T>(nativeState);
-  }
+  static JSICacheReference getOrCreateCache(jsi::Runtime& runtime);
 
-public:
 private:
-  friend class JSICacheReference<T>;
+  friend class JSICacheReference;
 
 private:
   jsi::Runtime* _runtime;
   std::mutex _mutex;
-  std::vector<BorrowingReference<T>> _cache;
+  std::vector<BorrowingReference<jsi::Object>> _cache;
 
 private:
-  static inline std::unordered_map<jsi::Runtime*, std::weak_ptr<JSICache<T>>> _globalCache;
+  static inline std::unordered_map<jsi::Runtime*, std::weak_ptr<JSICache>> _globalCache;
 
 private:
   static constexpr auto TAG = "JSICache";
 };
 
+class JSICacheReference final {
+public:
+  JSICacheReference() = delete;
+  JSICacheReference(const JSICacheReference&) = delete;
+  JSICacheReference(JSICacheReference&&) = delete;
+
+  ~JSICacheReference() {
+    _strongCache->_mutex.unlock();
+  }
+
+public:
+  /**
+   * Creates a semi-strong reference to a `jsi::Object` that can be stored in memory and accessed later.
+   *
+   * The returned `OwningReference<T>` keeps the `T` semi-strong, and once it gets deleted, `T` will also be freed.
+   *
+   * Note: The JS Runtime can still delete `T` at any point (e.g. when it gets destroyed or reloaded),
+   * so any operations on `T` should be under an `OwningLock<T>`.
+   *
+   * To get an `OwningLock<T>` (which implies safe access to `T`), call `.locK()` on the `OwningReference<T>`.
+   * This will hold off any JS Runtime GC calls that will destroy `T` for as long as the `OwningLock<T>` is alive.
+   */
+  template <typename T>
+  OwningReference<T> makeGlobal(T&& value) {
+    OwningReference<jsi::Object> owning(new T(std::move(value)));
+    _strongCache->_cache.push_back(owning.weak());
+    return owning.as<T>();
+  }
+
+private:
+  explicit JSICacheReference(const std::shared_ptr<JSICache>& cache) : _strongCache(cache) {
+    _strongCache->_mutex.lock();
+  }
+
+private:
+  std::shared_ptr<JSICache> _strongCache;
+
+  friend class JSICache;
+};
+
 } // namespace margelo::nitro

package/cpp/jsi/JSIConverter+ArrayBuffer.hpp

@@ -7,9 +7,7 @@
 // Forward declare a few of the common types that might have cyclic includes.
 namespace margelo::nitro {
 class ArrayBuffer;
-
-template <typename T>
-struct JSICache;
+class JSICache;
 
 template <typename T, typename Enable>
 struct JSIConverter;
@@ -37,12 +35,12 @@ struct JSIConverter<T, std::enable_if_t<is_shared_ptr_to_v<T, jsi::MutableBuffer
       throw std::runtime_error("Object \"" + arg.toString(runtime).utf8(runtime) + "\" is not an ArrayBuffer!");
     }
 
-    JSICacheReference<jsi::ArrayBuffer> cache = JSICache<jsi::ArrayBuffer>::getOrCreateCache(runtime);
-    auto owningArrayBuffer = cache.makeGlobal(object.getArrayBuffer(runtime));
+    JSICacheReference cache = JSICache::getOrCreateCache(runtime);
+    auto owningArrayBuffer = cache.makeGlobal<jsi::ArrayBuffer>(object.getArrayBuffer(runtime));
 
     return std::make_shared<JSArrayBuffer>(&runtime, owningArrayBuffer);
   }
-  static inline jsi::Value toJSI(jsi::Runtime& runtime, std::shared_ptr<jsi::MutableBuffer> buffer) {
+  static inline jsi::Value toJSI(jsi::Runtime& runtime, const std::shared_ptr<jsi::MutableBuffer>& buffer) {
     return jsi::ArrayBuffer(runtime, buffer);
   }
 };

package/cpp/jsi/JSIConverter+Function.hpp

@@ -6,7 +6,6 @@
 
 // Forward declare a few of the common types that might have cyclic includes.
 namespace margelo::nitro {
-template <typename T>
 class JSICache;
 
 template <typename T, typename Enable>
@@ -34,9 +33,9 @@ struct JSIConverter<std::function<ReturnType(Args...)>> {
 
   static inline std::function<ReturnType(Args...)> fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) {
     // Make function global - it'll be managed by the Runtime's memory, and we only have a weak_ref to it.
-    auto cache = JSICache<jsi::Function>::getOrCreateCache(runtime);
+    auto cache = JSICache::getOrCreateCache(runtime);
     jsi::Function function = arg.asObject(runtime).asFunction(runtime);
-    OwningReference<jsi::Function> sharedFunction = cache.makeGlobal(std::move(function));
+    OwningReference<jsi::Function> sharedFunction = cache.makeGlobal<jsi::Function>(std::move(function));
 
     std::shared_ptr<Dispatcher> strongDispatcher = Dispatcher::getRuntimeGlobalDispatcher(runtime);
     std::weak_ptr<Dispatcher> weakDispatcher = strongDispatcher;

package/cpp/jsi/Promise.cpp

@@ -8,9 +8,9 @@ namespace margelo::nitro {
 using namespace facebook;
 
 Promise::Promise(jsi::Runtime& runtime, jsi::Function&& resolver, jsi::Function&& rejecter) {
-  auto functionCache = JSICache<jsi::Function>::getOrCreateCache(runtime);
-  _resolver = functionCache.makeGlobal(std::move(resolver));
-  _rejecter = functionCache.makeGlobal(std::move(rejecter));
+  auto functionCache = JSICache::getOrCreateCache(runtime);
+  _resolver = functionCache.makeGlobal<jsi::Function>(std::move(resolver));
+  _rejecter = functionCache.makeGlobal<jsi::Function>(std::move(rejecter));
 }
 
 jsi::Value Promise::createPromise(jsi::Runtime& runtime, RunPromise&& run) {
@@ -35,6 +35,8 @@ jsi::Value Promise::createPromise(jsi::Runtime& runtime, RunPromise&& run) {
 }
 
 void Promise::resolve(jsi::Runtime& runtime, jsi::Value&& result) {
+  OwningLock<jsi::Function> lock = _resolver.lock();
+
   if (!_resolver) {
     Logger::log(TAG, "Promise resolver function has already been deleted! Ignoring call..");
     return;
@@ -43,6 +45,8 @@ void Promise::resolve(jsi::Runtime& runtime, jsi::Value&& result) {
 }
 
 void Promise::reject(jsi::Runtime& runtime, std::string message) {
+  OwningLock<jsi::Function> lock = _rejecter.lock();
+
   if (!_rejecter) {
     Logger::log(TAG, "Promise rejecter function has already been deleted! Ignoring call..");
     return;

package/cpp/utils/OwningReference.hpp

@@ -76,12 +76,25 @@ public:
   }
 
 private:
+  // BorrowingReference<T> -> OwningReference<T> Lock-constructor
   OwningReference(const BorrowingReference<T>& ref)
       : _value(ref._value), _isDeleted(ref._isDeleted), _strongRefCount(ref._strongRefCount), _weakRefCount(ref._weakRefCount),
         _mutex(ref._mutex) {
     (*_strongRefCount)++;
   }
 
+private:
+  // OwningReference<C> -> OwningReference<T> Cast-constructor
+  template <typename OldT>
+  OwningReference(T* value, const OwningReference<OldT>& originalRef)
+      : _value(value), _isDeleted(originalRef._isDeleted), _strongRefCount(originalRef._strongRefCount),
+        _weakRefCount(originalRef._weakRefCount), _mutex(originalRef._mutex) {
+    (*_strongRefCount)++;
+  }
+
+  template <typename C>
+  friend class OwningReference;
+
 public:
   ~OwningReference() {
     if (_strongRefCount == nullptr) {
@@ -94,6 +107,15 @@ public:
     maybeDestroy();
   }
 
+public:
+  /**
+   Casts this `OwningReference<T>` to a `OwningReference<C>`.
+   */
+  template <typename C>
+  OwningReference<C> as() {
+    return OwningReference<C>(static_cast<C*>(_value), *this);
+  }
+
 public:
   /**
    Creates an `OwningLock<T>` for the given `OwningReference<T>` to guarantee safe

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-nitro-modules",
-  "version": "0.1.5",
+  "version": "0.1.6",
   "description": "Insanely fast native C++, Swift or Kotlin modules with a statically compiled binding layer to JSI.",
   "main": "lib/index",
   "module": "lib/index",