react-native-nitro-modules 0.27.4 → 0.27.6

package/android/src/main/cpp/core/JHybridObject.cpp

@@ -0,0 +1,38 @@
+//
+//  JHybridObject.cpp
+//  react-native-nitro
+//
+//  Created by Marc Rousavy on 11.08.25.
+//
+
+#include "JHybridObject.hpp"
+#include "JNISharedPtr.hpp"
+#include <fbjni/fbjni.h>
+
+namespace margelo::nitro {
+
+using namespace facebook;
+
+std::shared_ptr<HybridObject> JHybridObject::shared() {
+  if (auto shared = weak_from_this().lock()) {
+    // We have a cached shared_ptr
+    return shared;
+  }
+  if (_javaPart == nullptr) [[unlikely]] {
+    // We don't have a _javaPart! Maybe the implementing JHybridObject
+    // was generated with an old version of nitrogen which doesn't call the JHybridObject(…)
+    // constructor yet. This is bad!
+    throw std::runtime_error(std::string("JHybridObject \"") + getName() +
+                             "\" does not have a _javaPart, "
+                             "and wasn't constructed from a std::shared_ptr! "
+                             "Try upgrading nitrogen and re-generate your specs.");
+  }
+  return JNISharedPtr::make_shared_from_jni<JHybridObject>(_javaPart);
+}
+
+JHybridObject::~JHybridObject() {
+  // Hermes GC can destroy JS objects on a non-JNI Thread.
+  jni::ThreadScope::WithClassLoader([&] { _javaPart.reset(); });
+}
+
+} // namespace margelo::nitro

package/android/src/main/cpp/core/JHybridObject.hpp

@@ -23,9 +23,21 @@ class JHybridObject : public jni::HybridClass<JHybridObject>, public virtual Hyb
 public:
   static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/core/HybridObject;";
 
-  ~JHybridObject() override = default;
+public:
+  // C++ constructor (called from Java via `initHybrid()`)
+  explicit JHybridObject(jni::alias_ref<jhybridobject> jThis) : _javaPart(jni::make_global(jThis)) {}
+  // C++ default constructor used by older Nitro versions (deprecated in favor of the jThis one)
+  [[deprecated]] JHybridObject() = default;
+
+public:
+  ~JHybridObject() override;
+
+public:
+  // `shared()` has custom logic because we ref-count using `jni::global_ref`!
+  std::shared_ptr<HybridObject> shared() override;
 
 private:
+  jni::global_ref<JHybridObject::javaobject> _javaPart;
   friend HybridBase;
 };
 

package/android/src/main/cpp/utils/JNISharedPtr.hpp

@@ -49,6 +49,9 @@ public:
 public:
   /**
    * Creates a new `std::shared_ptr<T>` from the given `jni::global_ref<T::javaobject>`.
+   * Note: This does not perform any caching and will just re-create the shared_ptr control-block
+   *       each time. It is not safe to call this multiple times if you use enable_shared_from_this.
+   *       Instead, use HybridObject::shared().
    */
   template <typename T, typename std::enable_if<is_base_template_of<T, jni::HybridClass>::value, int>::type = 0>
   static std::shared_ptr<T> make_shared_from_jni(const jni::global_ref<typename T::javaobject>& ref) {

package/cpp/core/HybridObject.cpp

@@ -22,6 +22,16 @@ bool HybridObject::equals(const std::shared_ptr<HybridObject>& other) {
   return this == other.get();
 }
 
+std::shared_ptr<HybridObject> HybridObject::shared() {
+  std::weak_ptr<HybridObject> weak = weak_from_this();
+  if (auto shared = weak.lock()) [[likely]] {
+    // We can lock to a shared_ptr!
+    return shared;
+  }
+  // We are not managed inside a shared_ptr..
+  throw std::runtime_error(std::string("HybridObject \"") + _name + "\" is not managed inside a std::shared_ptr - cannot access shared()!");
+}
+
 jsi::Value HybridObject::disposeRaw(jsi::Runtime& runtime, const jsi::Value& thisArg, const jsi::Value*, size_t) {
   // 1. Dispose any resources - this might be overridden by child classes to perform manual cleanup.
   dispose();
@@ -71,7 +81,7 @@ jsi::Value HybridObject::toObject(jsi::Runtime& runtime) {
   jsi::Object object = create.call(runtime, prototype).asObject(runtime);
 
   // 5. Assign NativeState to the object so the prototype can resolve the native methods
-  object.setNativeState(runtime, shared_from_this());
+  object.setNativeState(runtime, shared());
 
   // 6. Set memory size so Hermes GC knows about actual memory
   object.setExternalMemoryPressure(runtime, getExternalMemorySize());

package/cpp/core/HybridObject.hpp

@@ -61,13 +61,17 @@ public:
 
 public:
   /**
-   * Get the `std::shared_ptr` instance of this HybridObject.
+   * Get the `std::shared_ptr` instance of this HybridObject as it's concrete type.
    * The HybridObject must be managed inside a `shared_ptr` already, otherwise this will fail.
    */
   template <typename Derived>
-  std::shared_ptr<Derived> shared() {
-    return std::dynamic_pointer_cast<Derived>(shared_from_this());
+  std::shared_ptr<Derived> shared_cast() {
+    return std::dynamic_pointer_cast<Derived>(shared());
   }
+  /**
+   * Get the `std::shared_ptr` instance of this HybridObject.
+   */
+  virtual std::shared_ptr<HybridObject> shared();
 
 public:
   /**

package/cpp/utils/NitroDefines.hpp

@@ -9,7 +9,7 @@
 #define NitroDefines_h
 
 // Sets the version of the native Nitro core library
-#define NITRO_VERSION "0.27.4"
+#define NITRO_VERSION "0.27.6"
 
 // Sets whether to use debug or optimized production build flags
 #ifdef DEBUG

package/package.json

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