react-native-nitro-modules 0.31.1 → 0.31.2

package/android/src/main/java/com/margelo/nitro/core/ArrayBuffer.kt

@@ -90,11 +90,47 @@ class ArrayBuffer {
     return boxed as HardwareBuffer
   }
 
+  /**
+   * Copies the underlying data into a `ByteArray`.
+   * If this `ArrayBuffer` is backed by a GPU-HardwareBuffer,
+   * this performs a GPU-download.
+   */
+  fun toByteArray(): ByteArray {
+    val buffer = this.getBuffer(false)
+    if (buffer.hasArray()) {
+      // It's a CPU-backed array - we can return this directly if the size matches
+      val array = buffer.array()
+      if (array.size == this.size) {
+        // The ByteBuffer is 1:1 mapped to a byte array - return as is!
+        return array
+      }
+      // we had a CPU-backed array, but it's size differs from our ArrayBuffer size.
+      // This might be because the ArrayBuffer has a smaller view of the data, so we need
+      // to resort back to a good ol' copy.
+    }
+    // It's not a 1:1 mapped array (e.g. HardwareBuffer) - we need to copy to the CPU
+    val copy = ByteBuffer.allocate(buffer.capacity())
+    copy.put(buffer)
+    return copy.array()
+  }
+
+  /**
+   * Returns an **owning** version of this `ArrayBuffer`.
+   * If this `ArrayBuffer` already is **owning**, it is returned as-is.
+   * If this `ArrayBuffer` is **non-owning**, it is _copied_.
+   */
+  fun asOwning(): ArrayBuffer {
+    if (!isOwner) {
+      return ArrayBuffer.copy(this)
+    }
+    return this
+  }
+
   /**
    * Create a new **owning-** `ArrayBuffer` that holds the given `ByteBuffer`.
    * The `ByteBuffer` needs to remain valid for as long as the `ArrayBuffer` is alive.
    */
-  constructor(byteBuffer: ByteBuffer) {
+  internal constructor(byteBuffer: ByteBuffer) {
     if (!byteBuffer.isDirect) {
       throw Error(
         "ArrayBuffers can only be created from direct ByteBuffers, " +
@@ -109,7 +145,7 @@ class ArrayBuffer {
    * The `HardwareBuffer` needs to remain valid for as long as the `ArrayBuffer` is alive.
    */
   @RequiresApi(Build.VERSION_CODES.O)
-  constructor(hardwareBuffer: HardwareBuffer) {
+  internal constructor(hardwareBuffer: HardwareBuffer) {
     if (hardwareBuffer.isClosed) {
       throw Error("Cannot create ArrayBuffer from an already-closed HardwareBuffer!")
     }
@@ -187,6 +223,15 @@ class ArrayBuffer {
       return ArrayBuffer(newBuffer)
     }
 
+    /**
+     * Copy the given `ByteArray` into a new **owning** `ArrayBuffer`.
+     */
+    fun copy(byteArray: ByteArray): ArrayBuffer {
+      val byteBuffer = ByteBuffer.allocateDirect(byteArray.size)
+      byteBuffer.put(byteArray)
+      return ArrayBuffer.wrap(byteBuffer)
+    }
+
     /**
      * Copy the given `HardwareBuffer` into a new **owning** `ArrayBuffer`.
      */

package/cpp/core/ArrayBuffer.cpp

@@ -32,6 +32,11 @@ std::shared_ptr<ArrayBuffer> ArrayBuffer::copy(const std::vector<uint8_t>& data)
   return ArrayBuffer::copy(data.data(), data.size());
 }
 
+std::shared_ptr<ArrayBuffer> ArrayBuffer::move(std::vector<uint8_t>&& data) {
+  auto* vector = new std::vector<uint8_t>(std::move(data));
+  return ArrayBuffer::wrap(vector->data(), vector->size(), [=]() { delete vector; });
+}
+
 std::shared_ptr<ArrayBuffer> ArrayBuffer::copy(const std::shared_ptr<ArrayBuffer>& buffer) {
   return ArrayBuffer::copy(buffer->data(), buffer->size());
 }

package/cpp/core/ArrayBuffer.hpp

@@ -64,6 +64,10 @@ public:
    * Create a new `NativeArrayBuffer` that copies the given `std::vector`.
    */
   static std::shared_ptr<ArrayBuffer> copy(const std::vector<uint8_t>& data);
+  /**
+   * Create a new `NativeArrayBuffer` that moves the given `std::vector`.
+   */
+  static std::shared_ptr<ArrayBuffer> move(std::vector<uint8_t>&& data);
   /**
    * Create a new `NativeArrayBuffer` that copies the given `std::shared_ptr<ArrayBuffer>`.
    */

package/cpp/core/Promise.cpp

@@ -7,4 +7,130 @@
 
 #include "Promise.hpp"
 
-namespace margelo::nitro {} // namespace margelo::nitro
+namespace margelo::nitro {
+
+Promise<void>::~Promise() {
+  if (isPending()) [[unlikely]] {
+    std::runtime_error error("Timeouted: Promise<void> was destroyed!");
+    reject(std::make_exception_ptr(error));
+  }
+}
+
+std::shared_ptr<Promise<void>> Promise<void>::create() {
+  return std::shared_ptr<Promise<void>>(new Promise());
+}
+
+std::shared_ptr<Promise<void>> Promise<void>::async(std::function<void()>&& run) {
+  auto promise = create();
+  ThreadPool::shared().run([run = std::move(run), promise]() {
+    try {
+      // Run the code, then resolve.
+      run();
+      promise->resolve();
+    } catch (...) {
+      // It threw an error.
+      promise->reject(std::current_exception());
+    }
+  });
+  return promise;
+}
+
+std::shared_ptr<Promise<void>> Promise<void>::awaitFuture(std::future<void>&& future) {
+  auto sharedFuture = std::make_shared<std::future<void>>(std::move(future));
+  return async([sharedFuture = std::move(sharedFuture)]() { sharedFuture->get(); });
+}
+
+std::shared_ptr<Promise<void>> Promise<void>::resolved() {
+  auto promise = create();
+  promise->resolve();
+  return promise;
+}
+std::shared_ptr<Promise<void>> Promise<void>::rejected(const std::exception_ptr& error) {
+  auto promise = create();
+  promise->reject(error);
+  return promise;
+}
+
+void Promise<void>::resolve() {
+  std::unique_lock lock(_mutex);
+#ifdef NITRO_DEBUG
+  assertPromiseState(*this, PromiseTask::WANTS_TO_RESOLVE);
+#endif
+  _isResolved = true;
+  for (const auto& onResolved : _onResolvedListeners) {
+    onResolved();
+  }
+  didFinish();
+}
+
+void Promise<void>::reject(const std::exception_ptr& exception) {
+  if (exception == nullptr) [[unlikely]] {
+    throw std::runtime_error("Cannot reject Promise<void> with a null exception_ptr!");
+  }
+
+  std::unique_lock lock(_mutex);
+#ifdef NITRO_DEBUG
+  assertPromiseState(*this, PromiseTask::WANTS_TO_REJECT);
+#endif
+  _error = exception;
+  for (const auto& onRejected : _onRejectedListeners) {
+    onRejected(exception);
+  }
+  didFinish();
+}
+
+void Promise<void>::addOnResolvedListener(OnResolvedFunc&& onResolved) {
+  std::unique_lock lock(_mutex);
+  if (_isResolved) {
+    onResolved();
+  } else {
+    _onResolvedListeners.push_back(std::move(onResolved));
+  }
+}
+void Promise<void>::addOnResolvedListener(const OnResolvedFunc& onResolved) {
+  std::unique_lock lock(_mutex);
+  if (_isResolved) {
+    onResolved();
+  } else {
+    _onResolvedListeners.push_back(onResolved);
+  }
+}
+void Promise<void>::addOnRejectedListener(OnRejectedFunc&& onRejected) {
+  std::unique_lock lock(_mutex);
+  if (_error) {
+    onRejected(_error);
+  } else {
+    // Promise is not yet rejected, put the listener in our queue.
+    _onRejectedListeners.push_back(std::move(onRejected));
+  }
+}
+void Promise<void>::addOnRejectedListener(const OnRejectedFunc& onRejected) {
+  std::unique_lock lock(_mutex);
+  if (_error) {
+    onRejected(_error);
+  } else {
+    // Promise is not yet rejected, put the listener in our queue.
+    _onRejectedListeners.push_back(onRejected);
+  }
+}
+
+std::future<void> Promise<void>::await() {
+  auto promise = std::make_shared<std::promise<void>>();
+  addOnResolvedListener([promise]() { promise->set_value(); });
+  addOnRejectedListener([promise](const std::exception_ptr& error) { promise->set_exception(error); });
+  return promise->get_future();
+}
+
+const std::exception_ptr& Promise<void>::getError() {
+  if (!isRejected()) {
+    throw std::runtime_error("Cannot get error when Promise<void> is not yet rejected!");
+  }
+  return _error;
+}
+
+void Promise<void>::didFinish() noexcept {
+  _onResolvedListeners.clear();
+  _onRejectedListeners.clear();
+}
+
+} // namespace margelo::nitro

package/cpp/core/Promise.hpp

@@ -270,153 +270,48 @@ public:
 
 public:
   Promise(const Promise&) = delete;
+  Promise(Promise&&) = delete;
+  ~Promise();
 
 private:
   Promise() = default;
 
 public:
-  ~Promise() {
-    if (isPending()) [[unlikely]] {
-      std::runtime_error error("Timeouted: Promise<void> was destroyed!");
-      reject(std::make_exception_ptr(error));
-    }
-  }
+  static std::shared_ptr<Promise> create();
+  static std::shared_ptr<Promise> async(std::function<void()>&& run);
+  static std::shared_ptr<Promise> awaitFuture(std::future<void>&& future);
+  static std::shared_ptr<Promise> resolved();
+  static std::shared_ptr<Promise> rejected(const std::exception_ptr& error);
 
 public:
-  static std::shared_ptr<Promise> create() {
-    return std::shared_ptr<Promise>(new Promise());
-  }
-
-  static std::shared_ptr<Promise> async(std::function<void()>&& run) {
-    auto promise = create();
-    ThreadPool::shared().run([run = std::move(run), promise]() {
-      try {
-        // Run the code, then resolve.
-        run();
-        promise->resolve();
-      } catch (...) {
-        // It threw an error.
-        promise->reject(std::current_exception());
-      }
-    });
-    return promise;
-  }
-
-  static std::shared_ptr<Promise> awaitFuture(std::future<void>&& future) {
-    auto sharedFuture = std::make_shared<std::future<void>>(std::move(future));
-    return async([sharedFuture = std::move(sharedFuture)]() { sharedFuture->get(); });
-  }
-
-  static std::shared_ptr<Promise> resolved() {
-    auto promise = create();
-    promise->resolve();
-    return promise;
-  }
-  static std::shared_ptr<Promise> rejected(const std::exception_ptr& error) {
-    auto promise = create();
-    promise->reject(error);
-    return promise;
-  }
+  void resolve();
+  void reject(const std::exception_ptr& exception);
 
 public:
-  void resolve() {
-    std::unique_lock lock(_mutex);
-#ifdef NITRO_DEBUG
-    assertPromiseState(*this, PromiseTask::WANTS_TO_RESOLVE);
-#endif
-    _isResolved = true;
-    for (const auto& onResolved : _onResolvedListeners) {
-      onResolved();
-    }
-    didFinish();
-  }
-  void reject(const std::exception_ptr& exception) {
-    if (exception == nullptr) [[unlikely]] {
-      throw std::runtime_error("Cannot reject Promise<void> with a null exception_ptr!");
-    }
-
-    std::unique_lock lock(_mutex);
-#ifdef NITRO_DEBUG
-    assertPromiseState(*this, PromiseTask::WANTS_TO_REJECT);
-#endif
-    _error = exception;
-    for (const auto& onRejected : _onRejectedListeners) {
-      onRejected(exception);
-    }
-    didFinish();
-  }
-
-public:
-  void addOnResolvedListener(OnResolvedFunc&& onResolved) {
-    std::unique_lock lock(_mutex);
-    if (_isResolved) {
-      onResolved();
-    } else {
-      _onResolvedListeners.push_back(std::move(onResolved));
-    }
-  }
-  void addOnResolvedListener(const OnResolvedFunc& onResolved) {
-    std::unique_lock lock(_mutex);
-    if (_isResolved) {
-      onResolved();
-    } else {
-      _onResolvedListeners.push_back(onResolved);
-    }
-  }
-  void addOnRejectedListener(OnRejectedFunc&& onRejected) {
-    std::unique_lock lock(_mutex);
-    if (_error) {
-      onRejected(_error);
-    } else {
-      // Promise is not yet rejected, put the listener in our queue.
-      _onRejectedListeners.push_back(std::move(onRejected));
-    }
-  }
-  void addOnRejectedListener(const OnRejectedFunc& onRejected) {
-    std::unique_lock lock(_mutex);
-    if (_error) {
-      onRejected(_error);
-    } else {
-      // Promise is not yet rejected, put the listener in our queue.
-      _onRejectedListeners.push_back(onRejected);
-    }
-  }
+  void addOnResolvedListener(OnResolvedFunc&& onResolved);
+  void addOnResolvedListener(const OnResolvedFunc& onResolved);
+  void addOnRejectedListener(OnRejectedFunc&& onRejected);
+  void addOnRejectedListener(const OnRejectedFunc& onRejected);
 
 public:
-  std::future<void> await() {
-    auto promise = std::make_shared<std::promise<void>>();
-    addOnResolvedListener([promise]() { promise->set_value(); });
-    addOnRejectedListener([promise](const std::exception_ptr& error) { promise->set_exception(error); });
-    return promise->get_future();
-  }
+  std::future<void> await();
 
 public:
-  inline const std::exception_ptr& getError() {
-    if (!isRejected()) {
-      throw std::runtime_error("Cannot get error when Promise<void> is not yet rejected!");
-    }
-    return _error;
-  }
+  const std::exception_ptr& getError();
 
 public:
-  [[nodiscard]]
   inline bool isResolved() const noexcept {
     return _isResolved;
   }
-  [[nodiscard]]
   inline bool isRejected() const noexcept {
     return _error != nullptr;
   }
-  [[nodiscard]]
   inline bool isPending() const noexcept {
     return !isResolved() && !isRejected();
   }
 
 private:
-  void didFinish() noexcept {
-    _onResolvedListeners.clear();
-    _onRejectedListeners.clear();
-  }
+  void didFinish() noexcept;
 
 private:
   std::mutex _mutex;

package/cpp/utils/FastVectorCopy.hpp

@@ -21,6 +21,7 @@ namespace margelo::nitro {
  * the data will be bulk-memcopied.
  */
 template <typename T>
+[[deprecated("FastVectorCopy is not safe for Swift - upgrade Nitro!")]]
 std::vector<T> FastVectorCopy(const T* CONTIGUOUS_MEMORY NON_NULL data, size_t size) {
   assert(data != nullptr && "FastVectoryCopy: data cannot be null!");
 

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

package/cpp/utils/ObjectUtils.cpp

@@ -145,9 +145,12 @@ BorrowingReference<jsi::Function> ObjectUtils::getGlobalFunction(jsi::Runtime& r
     std::string stringKey = key;
     auto iterator = functionCache.find(stringKey);
     if (iterator != functionCache.end()) {
-      // We found it! Copy & return the reference
+      // We found it! Let's check if the reference is still valid...
       BorrowingReference<jsi::Function> function = iterator->second;
-      return function;
+      if (function != nullptr) [[likely]] {
+        // It's still alive - let's use it from cache!
+        return function;
+      }
     }
   }
   // We haven't found the function with the given key in cache - so let's get it:

package/ios/core/ArrayBuffer.swift

@@ -10,7 +10,7 @@ import Foundation
 /// Holds instances of `std::shared_ptr<ArrayBuffer>`, which can be passed
 /// between native and JS **without copy**.
 ///
-/// See `data`, `size` and `isOwning`.
+/// See `data`, `size` and `isOwner`.
 public typealias ArrayBuffer = margelo.nitro.ArrayBufferHolder
 
 @available(*, deprecated, renamed: "ArrayBuffer")
@@ -77,10 +77,10 @@ extension ArrayBuffer {
 
 extension ArrayBuffer {
   /**
-   * Copy the given `UnsafeMutablePointer<UInt8>` into a new **owning** `ArrayBuffer`.
+   * Copy the given `UnsafePointer<UInt8>` into a new **owning** `ArrayBuffer`.
    */
   public static func copy(
-    of other: UnsafeMutablePointer<UInt8>,
+    of other: UnsafePointer<UInt8>,
     size: Int
   ) -> ArrayBuffer {
     // 1. Create new `UnsafeMutablePointer<UInt8>`
@@ -94,18 +94,6 @@ extension ArrayBuffer {
     return ArrayBuffer.wrap(copy, size, deleteFunc)
   }
 
-  /**
-   * Copy the given `UnsafeMutableRawPointer` into a new **owning** `ArrayBuffer`.
-   */
-  public static func copy(
-    of other: UnsafeMutableRawPointer,
-    size: Int
-  ) -> ArrayBuffer {
-    return ArrayBuffer.copy(
-      of: other.assumingMemoryBound(to: UInt8.self),
-      size: size)
-  }
-
   /**
    * Copy the given `ArrayBuffer` into a new **owning** `ArrayBuffer`.
    */
@@ -161,3 +149,19 @@ extension ArrayBuffer {
     }
   }
 }
+
+// pragma MARK: Helper
+
+extension ArrayBuffer {
+  /**
+   * Returns an **owning** version of this `ArrayBuffer`.
+   * If this `ArrayBuffer` already is **owning**, it is returned as-is.
+   * If this `ArrayBuffer` is **non-owning**, it is _copied_.
+   */
+  public func asOwning() -> ArrayBuffer {
+    if !isOwner {
+      return ArrayBuffer.copy(of: self)
+    }
+    return self
+  }
+}

package/package.json

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