react-native-nitro-modules 0.24.1 → 0.25.1

package/android/build.gradle

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

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

@@ -4,6 +4,8 @@
 
 #pragma once
 
+#include "NitroDefines.hpp"
+#include "NitroTypeInfo.hpp"
 #include <fbjni/fbjni.h>
 #include <memory>
 
@@ -13,19 +15,21 @@ using namespace facebook;
 
 template <typename T>
 struct GlobalRefDeleter {
-  explicit GlobalRefDeleter(jni::global_ref<typename T::javaobject> ref) : _ref(ref) {}
+  explicit GlobalRefDeleter(const jni::global_ref<typename T::javaobject>& ref) : _ref(ref) {}
+
+  GlobalRefDeleter(const GlobalRefDeleter& copy) = delete;
+  GlobalRefDeleter(GlobalRefDeleter&& move) = default;
 
   void operator()(T* /* cthis */) {
-    if (_ref) {
-      _ref.release();
-    }
+    // It's RAII - once `GlobalRefDeleter` goes out of scope, `jni::global_ref` will too.
+    _ref = nullptr;
   }
 
 private:
   jni::global_ref<typename T::javaobject> _ref;
 };
 
-class JNISharedPtr {
+class JNISharedPtr final {
 private:
   template <typename T, template <typename, typename...> class Base>
   struct is_base_template_of {
@@ -39,9 +43,23 @@ private:
   };
 
 public:
+  JNISharedPtr() = delete;
+  ~JNISharedPtr() = delete;
+
+public:
+  /**
+   * Creates a new `std::shared_ptr<T>` from the given `jni::global_ref<T::javaobject>`.
+   */
   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(jni::global_ref<typename T::javaobject> ref) {
-    return std::shared_ptr<T>(ref->cthis(), GlobalRefDeleter<T>{ref});
+  static std::shared_ptr<T> make_shared_from_jni(const jni::global_ref<typename T::javaobject>& ref) {
+#ifdef NITRO_DEBUG
+    if (ref == nullptr || ref->cthis() == nullptr) [[unlikely]] {
+      std::string typeName = TypeInfo::getFriendlyTypename<T>(true);
+      throw std::runtime_error("Failed to wrap jni::global_ref<" + typeName + "::javaobject> in std::shared_ptr<" + typeName +
+                               "> - it's null!");
+    }
+#endif
+    return std::shared_ptr<T>(ref->cthis(), GlobalRefDeleter<T>(ref));
   }
 };
 

package/cpp/core/ArrayBuffer.cpp

@@ -21,13 +21,13 @@ std::shared_ptr<ArrayBuffer> ArrayBuffer::wrap(uint8_t* data, size_t size, Delet
   return std::make_shared<NativeArrayBuffer>(data, size, std::move(deleteFunc));
 }
 
-std::shared_ptr<ArrayBuffer> ArrayBuffer::copy(uint8_t* data, size_t size) {
+std::shared_ptr<ArrayBuffer> ArrayBuffer::copy(const uint8_t* data, size_t size) {
   uint8_t* copy = new uint8_t[size];
   std::memcpy(copy, data, size);
   return ArrayBuffer::wrap(copy, size, [=]() { delete[] copy; });
 }
 
-std::shared_ptr<ArrayBuffer> ArrayBuffer::copy(std::vector<uint8_t>& data) {
+std::shared_ptr<ArrayBuffer> ArrayBuffer::copy(const std::vector<uint8_t>& data) {
   return ArrayBuffer::copy(data.data(), data.size());
 }
 

package/cpp/core/ArrayBuffer.hpp

@@ -58,11 +58,11 @@ public:
    * Create a new `NativeArrayBuffer` that copies the given data of the given size
    * into a newly allocated buffer.
    */
-  static std::shared_ptr<ArrayBuffer> copy(uint8_t* data, size_t size);
+  static std::shared_ptr<ArrayBuffer> copy(const uint8_t* data, size_t size);
   /**
    * Create a new `NativeArrayBuffer` that copies the given `std::vector`.
    */
-  static std::shared_ptr<ArrayBuffer> copy(std::vector<uint8_t>& data);
+  static std::shared_ptr<ArrayBuffer> copy(const std::vector<uint8_t>& data);
   /**
    * Create a new `NativeArrayBuffer` that allocates a new buffer of the given size.
    */

package/cpp/core/HybridObject.cpp

@@ -79,11 +79,17 @@ jsi::Value HybridObject::toObject(jsi::Runtime& runtime) {
   object.setProperty(runtime, "__type", jsi::String::createFromUtf8(runtime, "NativeState<" + std::string(_name) + ">"));
 #endif
 
-  // 8. Throw a jsi::WeakObject pointing to our object into cache so subsequent calls can use it from cache
+#ifdef NITRO_DEBUG
+  // 8. Freeze the object to prevent accidentally setting wrong props on it that do nothing.
+  jsi::Function freeze = objectConstructor.getPropertyAsFunction(runtime, "freeze");
+  freeze.call(runtime, object);
+#endif
+
+  // 9. Throw a jsi::WeakObject pointing to our object into cache so subsequent calls can use it from cache
   JSICacheReference cache = JSICache::getOrCreateCache(runtime);
-  _objectCache.emplace(&runtime, cache.makeShared(jsi::WeakObject(runtime, object)));
+  _objectCache[&runtime] = cache.makeShared(jsi::WeakObject(runtime, object));
 
-  // 9. Return it!
+  // 10. Return it!
   return object;
 }
 

package/cpp/jsi/JSICache.cpp

@@ -57,7 +57,7 @@ JSICacheReference JSICache::getOrCreateCache(jsi::Runtime& runtime) {
   // Cache doesn't exist yet.
   Logger::log(LogLevel::Info, TAG, "Creating new JSICache<T> for runtime %s..", getRuntimeId(runtime).c_str());
   // Create new cache
-  auto nativeState = std::shared_ptr<JSICache>(new JSICache());
+  std::shared_ptr<JSICache> nativeState(new JSICache());
   // Wrap it in a jsi::Value using NativeState
   jsi::Object cache(runtime);
   cache.setNativeState(runtime, nativeState);

package/cpp/prototype/HybridObjectPrototype.cpp

@@ -78,7 +78,8 @@ jsi::Value HybridObjectPrototype::createPrototype(jsi::Runtime& runtime, const s
   // 7. Throw it into our cache so the next lookup can be cached and therefore faster
   JSICacheReference jsiCache = JSICache::getOrCreateCache(runtime);
   BorrowingReference<jsi::Object> sharedObject = jsiCache.makeShared(std::move(object));
-  prototypeCache.emplace(prototype->getNativeInstanceId(), sharedObject);
+  auto instanceId = prototype->getNativeInstanceId();
+  prototypeCache[instanceId] = sharedObject;
 
   // 8. Return it!
   return jsi::Value(runtime, *sharedObject);

package/cpp/threading/Dispatcher.cpp

@@ -22,7 +22,7 @@ void Dispatcher::installRuntimeGlobalDispatcher(jsi::Runtime& runtime, std::shar
   Logger::log(LogLevel::Info, TAG, "Installing global Dispatcher Holder into Runtime \"%s\"...", getRuntimeId(runtime).c_str());
 
   // Store a weak reference in global cache
-  _globalCache[&runtime] = std::weak_ptr(dispatcher);
+  _globalCache[&runtime] = dispatcher;
 
   // Inject the dispatcher into Runtime global (runtime will hold a strong reference)
   jsi::Object dispatcherHolder(runtime);
@@ -31,9 +31,10 @@ void Dispatcher::installRuntimeGlobalDispatcher(jsi::Runtime& runtime, std::shar
 }
 
 std::shared_ptr<Dispatcher> Dispatcher::getRuntimeGlobalDispatcher(jsi::Runtime& runtime) {
-  if (_globalCache.contains(&runtime)) [[likely]] {
+  auto found = _globalCache.find(&runtime);
+  if (found != _globalCache.end()) [[likely]] {
     // the runtime is known - we have something in cache
-    std::weak_ptr<Dispatcher> weakDispatcher = _globalCache[&runtime];
+    std::weak_ptr<Dispatcher> weakDispatcher = found->second;
     std::shared_ptr<Dispatcher> strongDispatcher = weakDispatcher.lock();
     if (strongDispatcher) {
       // the weak reference we cached is still valid - return it!

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.24.1"
+#define NITRO_VERSION "0.25.1"
 
 // Sets whether to use debug or optimized production build flags
 #ifdef DEBUG

package/ios/platform/ThreadUtils.mm

@@ -0,0 +1,46 @@
+//
+//  ThreadUtils.mm
+//  react-native-nitro
+//
+//  Created by Marc Rousavy on 14.07.24.
+//
+
+#include "ThreadUtils.hpp"
+#include <pthread.h>
+#include <sstream>
+#include <thread>
+
+// ObjC import
+#import <Foundation/Foundation.h>
+
+namespace margelo::nitro {
+
+std::string ThreadUtils::getThreadName() {
+  // Try using NSThread APIs
+  NSString* threadName = NSThread.currentThread.name;
+  if (threadName != nil && threadName.length > 0) {
+    return threadName.UTF8String;
+  }
+
+  // Try using DispatchQueue APIs as fallback
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdeprecated-declarations"
+  dispatch_queue_t queue = dispatch_get_current_queue();
+#pragma clang diagnostic pop
+  const char* label = dispatch_queue_get_label(queue);
+  if (label != nullptr) {
+    return label;
+  }
+
+  // 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::nitro

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-nitro-modules",
-  "version": "0.24.1",
+  "version": "0.25.1",
   "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",

package/ios/platform/ThreadUtils.cpp

@@ -1,33 +0,0 @@
-//
-//  ThreadUtils.cpp
-//  react-native-nitro
-//
-//  Created by Marc Rousavy on 14.07.24.
-//
-
-#include "ThreadUtils.hpp"
-#include <pthread.h>
-#include <sstream>
-#include <thread>
-
-namespace margelo::nitro {
-
-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::nitro