react-native-nitro-modules 0.27.3 → 0.27.5

package/android/build.gradle

@@ -7,7 +7,7 @@ buildscript {
   }
 
   dependencies {
-    classpath "com.android.tools.build:gradle:8.11.1"
+    classpath "com.android.tools.build:gradle:8.12.0"
   }
 }
 

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

@@ -0,0 +1,33 @@
+//
+//  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);
+}
+
+} // namespace margelo::nitro

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

@@ -23,9 +23,17 @@ class JHybridObject : public jni::HybridClass<JHybridObject>, public virtual Hyb
 public:
   static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/core/HybridObject;";
 
+  // 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;
   ~JHybridObject() override = default;
 
+  // `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/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());
+    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.3"
+#define NITRO_VERSION "0.27.5"
 
 // 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.3",
+  "version": "0.27.5",
   "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",
@@ -75,7 +75,7 @@
     "@types/react": "*",
     "jest": "*",
     "react": "19.1.0",
-    "react-native": "0.80.1",
+    "react-native": "0.80.2",
     "react-native-builder-bob": "^0.37.0"
   },
   "peerDependencies": {