react-native-nitro-modules 0.26.1 → 0.26.3

package/android/build.gradle

@@ -7,7 +7,7 @@ buildscript {
   }
 
   dependencies {
-    classpath "com.android.tools.build:gradle:8.10.1"
+    classpath "com.android.tools.build:gradle:8.11.0"
   }
 }
 
@@ -51,7 +51,7 @@ android {
     externalNativeBuild {
       cmake {
         cppFlags "-frtti -fexceptions -Wall -Wextra -fstack-protector-all"
-        arguments "-DANDROID_STL=c++_shared"
+        arguments "-DANDROID_STL=c++_shared", "-DANDROID_SUPPORT_FLEXIBLE_PAGE_SIZES=ON"
         abiFilters (*reactNativeArchitectures())
 
         buildTypes {

package/android/src/main/cpp/JNIOnLoad.cpp

@@ -3,6 +3,7 @@
 #include "JAnyMap.hpp"
 #include "JAnyValue.hpp"
 #include "JArrayBuffer.hpp"
+#include "JHardwareBufferUtils.hpp"
 #include "JNitroModules.hpp"
 #include "JPromise.hpp"
 #include <fbjni/fbjni.h>
@@ -16,6 +17,7 @@ JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM* vm, void*) {
     JArrayBuffer::registerNatives();
     JAnyMap::registerNatives();
     JAnyValue::registerNatives();
+    JHardwareBufferUtils::registerNatives();
     JPromise::registerNatives();
 
     // 2. Initialize the React Native TurboModule C++ part

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

@@ -0,0 +1,93 @@
+//
+//  HardwareBufferArrayBuffer.hpp
+//  react-native-nitro
+//
+//  Created by Marc Rousavy on 14.07.24.
+//
+
+#pragma once
+
+#include "ArrayBuffer.hpp"
+#include "JHardwareBufferUtils.hpp"
+#include <android/hardware_buffer.h>
+#include <android/hardware_buffer_jni.h>
+#include <fbjni/ByteBuffer.h>
+#include <fbjni/fbjni.h>
+
+namespace margelo::nitro {
+
+using namespace facebook;
+
+#if __ANDROID_API__ >= 26
+/**
+ * Represents an `ArrayBuffer` that holds a `HardwareBuffer`.
+ */
+class HardwareBufferArrayBuffer final : public ArrayBuffer {
+public:
+  /**
+   * Create a new `HardwareBufferArrayBuffer` instance that wraps the given `HardwareBuffer`.
+   * This constructor will add a +1 retain count on the given `hardwareBuffer` using
+   * `AHardwareBuffer_acquire(...)`, and release it again once it is destructured.
+   */
+  explicit HardwareBufferArrayBuffer(AHardwareBuffer* hardwareBuffer)
+      : _hardwareBuffer(hardwareBuffer), _dataCached(nullptr), _isLocked(false) {
+    AHardwareBuffer_acquire(hardwareBuffer);
+  }
+
+  ~HardwareBufferArrayBuffer() override {
+    // Hermes GC can destroy JS objects on a non-JNI Thread.
+    unlock();
+    jni::ThreadScope::WithClassLoader([&] { AHardwareBuffer_release(_hardwareBuffer); });
+  }
+
+public:
+  /**
+   * Unlocks the HardwareBuffer if it was locked.
+   * Subsequent calls to `data()` will have to lock the buffer again.
+   *
+   * It is a good practice to call this when the buffer is likely not being
+   * read from using this `HardwareBufferArrayBuffer` instance again anytime soon.
+   */
+  void unlock() {
+    if (_isLocked) {
+      AHardwareBuffer_unlock(_hardwareBuffer, nullptr);
+      _isLocked = false;
+    }
+    _dataCached = nullptr;
+  }
+
+public:
+  [[nodiscard]] uint8_t* data() override {
+    if (_isLocked && _dataCached != nullptr) {
+      // We are still locked on the AHardwareBuffer* and have a valid buffer.
+      return _dataCached;
+    }
+    void* buffer;
+    int result = AHardwareBuffer_lock(_hardwareBuffer, AHARDWAREBUFFER_USAGE_CPU_READ_MASK, -1, nullptr, &buffer);
+    if (result != 0) {
+      throw std::runtime_error("Failed to read HardwareBuffer bytes!");
+    }
+    _dataCached = static_cast<uint8_t*>(buffer);
+    _isLocked = true;
+    return _dataCached;
+  }
+  [[nodiscard]] size_t size() const override {
+    return JHardwareBufferUtils::getHardwareBufferSize(_hardwareBuffer);
+  }
+  [[nodiscard]] bool isOwner() const noexcept override {
+    return true;
+  }
+
+public:
+  [[nodiscard]] AHardwareBuffer* getBuffer() const {
+    return _hardwareBuffer;
+  }
+
+private:
+  AHardwareBuffer* _hardwareBuffer;
+  uint8_t* _dataCached;
+  bool _isLocked;
+};
+#endif
+
+} // namespace margelo::nitro

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

@@ -40,7 +40,7 @@ private:
   JAnyMap() {
     _map = std::make_shared<AnyMap>();
   }
-  JAnyMap(const std::shared_ptr<AnyMap>& map) : _map(map) {}
+  explicit JAnyMap(const std::shared_ptr<AnyMap>& map) : _map(map) {}
 
 protected:
   bool contains(const std::string& key) {
@@ -52,6 +52,17 @@ protected:
   void clear() {
     _map->clear();
   }
+  jni::local_ref<jni::JArrayClass<jni::JString>> getAllKeys() {
+    auto& map = _map->getMap();
+    auto array = jni::JArrayClass<jni::JString>::newArray(map.size());
+    size_t index = 0;
+    for (const auto& pair : map) {
+      auto jKey = jni::make_jstring(pair.first);
+      array->setElement(index, *jKey);
+      index++;
+    }
+    return array;
+  }
 
 protected:
   bool isNull(const std::string& key) {
@@ -163,6 +174,7 @@ public:
         makeNativeMethod("contains", JAnyMap::contains),
         makeNativeMethod("remove", JAnyMap::remove),
         makeNativeMethod("clear", JAnyMap::clear),
+        makeNativeMethod("getAllKeys", JAnyMap::getAllKeys),
         // is
         makeNativeMethod("isNull", JAnyMap::isNull),
         makeNativeMethod("isDouble", JAnyMap::isDouble),

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

@@ -9,6 +9,9 @@
 
 #include "ArrayBuffer.hpp"
 #include "ByteBufferArrayBuffer.hpp"
+#include "HardwareBufferArrayBuffer.hpp"
+#include <android/hardware_buffer.h>
+#include <android/hardware_buffer_jni.h>
 #include <fbjni/ByteBuffer.h>
 #include <fbjni/fbjni.h>
 #include <functional>
@@ -38,9 +41,23 @@ public:
   /**
    * Create a new `JArrayBuffer` that wraps the given `ByteBuffer` from Java.
    */
-  static jni::local_ref<JArrayBuffer::jhybriddata> initHybrid(jni::alias_ref<jhybridobject>, jni::alias_ref<jni::JByteBuffer> buffer) {
+  static jni::local_ref<JArrayBuffer::jhybriddata> initHybridByteBuffer(jni::alias_ref<jhybridobject>,
+                                                                        jni::alias_ref<jni::JByteBuffer> buffer) {
     return makeCxxInstance(buffer);
   }
+  /**
+   * Create a new `JArrayBuffer` that wraps the given `HardwareBuffer` from Java.
+   */
+  static jni::local_ref<JArrayBuffer::jhybriddata> initHybridHardwareBuffer(jni::alias_ref<jhybridobject>,
+                                                                            jni::alias_ref<jni::JObject> boxedHardwareBuffer) {
+#if __ANDROID_API__ >= 26
+    // Cast jobject* to AHardwareBuffer*. It has a retain count of 0 which will be retained in `HardwareBufferArrayBuffer(..)`.
+    AHardwareBuffer* hardwareBuffer = AHardwareBuffer_fromHardwareBuffer(jni::Environment::current(), boxedHardwareBuffer.get());
+    return makeCxxInstance(hardwareBuffer);
+#else
+    throw std::runtime_error("ArrayBuffer(HardwareBuffer) requires NDK API 26 or above! (minSdk >= 26)");
+#endif
+  }
 
 public:
   /**
@@ -51,6 +68,18 @@ public:
     return byteBufferArrayBuffer != nullptr;
   }
 
+  /**
+   * Get whether the `ArrayBuffer` is holding data from a `HardwareBuffer`.
+   */
+  bool getIsHardwareBuffer() {
+#if __ANDROID_API__ >= 26
+    auto hardwareBufferArrayBuffer = std::dynamic_pointer_cast<HardwareBufferArrayBuffer>(_arrayBuffer);
+    return hardwareBufferArrayBuffer != nullptr;
+#else
+    return false;
+#endif
+  }
+
   /**
    * Get whether the `ArrayBuffer` is owning the data and can safely hold onto it longer.
    */
@@ -67,7 +96,7 @@ public:
    * `ByteBuffer`. In this case, `getBuffer()` will **copy** the data into a new `ByteBuffer` if
    * `copyIfNeeded` is `true`, and **wrap** the data into a new `ByteBuffer` if `copyIfNeeded` is false.
    */
-  jni::local_ref<jni::JByteBuffer> getByteBuffer(bool copyIfNeeded) {
+  [[nodiscard]] jni::local_ref<jni::JByteBuffer> getByteBuffer(bool copyIfNeeded) {
     auto byteBufferArrayBuffer = std::dynamic_pointer_cast<ByteBufferArrayBuffer>(_arrayBuffer);
     if (byteBufferArrayBuffer != nullptr) {
       // It is a `ByteBufferArrayBuffer`, which has a `ByteBuffer` underneath!
@@ -88,6 +117,16 @@ public:
     }
   }
 
+  [[nodiscard]] jni::local_ref<jni::JObject> getHardwareBufferBoxed() {
+#if __ANDROID_API__ >= 26
+    AHardwareBuffer* buffer = getHardwareBuffer();
+    jobject boxed = AHardwareBuffer_toHardwareBuffer(jni::Environment::current(), buffer);
+    return jni::make_local(boxed);
+#else
+    throw std::runtime_error("ArrayBuffer(HardwareBuffer) requires NDK API 26 or above! (minSdk >= 26)");
+#endif
+  }
+
   int getBufferSize() {
     return static_cast<int>(_arrayBuffer->size());
   }
@@ -96,16 +135,38 @@ public:
   /**
    * Get the underlying `ArrayBuffer`.
    */
-  std::shared_ptr<ArrayBuffer> getArrayBuffer() const {
+  [[nodiscard]] std::shared_ptr<ArrayBuffer> getArrayBuffer() const {
     return _arrayBuffer;
   }
+  /**
+   * Get the underlying `HardwareBuffer` if it has one.
+   * This method will throw if this `ArrayBuffer` was not created with a `HardwareBuffer`.
+   */
+  [[nodiscard]] AHardwareBuffer* getHardwareBuffer() const {
+#if __ANDROID_API__ >= 26
+    auto hardwareBufferArrayBuffer = std::dynamic_pointer_cast<HardwareBufferArrayBuffer>(_arrayBuffer);
+    if (hardwareBufferArrayBuffer != nullptr) {
+      return hardwareBufferArrayBuffer->getBuffer();
+    } else {
+      throw std::runtime_error("The underlying buffer is not a HardwareBuffer!");
+    }
+#else
+    throw std::runtime_error("ArrayBuffer(HardwareBuffer) requires NDK API 26 or above! (minSdk >= 26)");
+#endif
+  }
 
 private:
-  JArrayBuffer(const std::shared_ptr<ArrayBuffer>& arrayBuffer) : _arrayBuffer(arrayBuffer) {}
-  JArrayBuffer(jni::alias_ref<jni::JByteBuffer> byteBuffer) {
+  explicit JArrayBuffer(const std::shared_ptr<ArrayBuffer>& arrayBuffer) : _arrayBuffer(arrayBuffer) {}
+  explicit JArrayBuffer(const jni::alias_ref<jni::JByteBuffer>& byteBuffer) {
     _arrayBuffer = std::make_shared<ByteBufferArrayBuffer>(byteBuffer);
   }
 
+#if __ANDROID_API__ >= 26
+  explicit JArrayBuffer(AHardwareBuffer* /* 0 retain */ hardwareBuffer) {
+    _arrayBuffer = std::make_shared<HardwareBufferArrayBuffer>(hardwareBuffer);
+  }
+#endif
+
 private:
   friend HybridBase;
   using HybridBase::HybridBase;
@@ -114,9 +175,12 @@ private:
 public:
   static void registerNatives() {
     registerHybrid(
-        {makeNativeMethod("initHybrid", JArrayBuffer::initHybrid), makeNativeMethod("getByteBuffer", JArrayBuffer::getByteBuffer),
-         makeNativeMethod("getIsByteBuffer", JArrayBuffer::getIsByteBuffer), makeNativeMethod("getIsOwner", JArrayBuffer::getIsOwner),
-         makeNativeMethod("getBufferSize", JArrayBuffer::getBufferSize)});
+        {makeNativeMethod("initHybrid", JArrayBuffer::initHybridByteBuffer),
+         makeNativeMethod("initHybridBoxedHardwareBuffer", JArrayBuffer::initHybridHardwareBuffer),
+         makeNativeMethod("getByteBuffer", JArrayBuffer::getByteBuffer), makeNativeMethod("getIsByteBuffer", JArrayBuffer::getIsByteBuffer),
+         makeNativeMethod("getHardwareBufferBoxed", JArrayBuffer::getHardwareBufferBoxed),
+         makeNativeMethod("getIsHardwareBuffer", JArrayBuffer::getIsHardwareBuffer),
+         makeNativeMethod("getIsOwner", JArrayBuffer::getIsOwner), makeNativeMethod("getBufferSize", JArrayBuffer::getBufferSize)});
   }
 };
 

package/android/src/main/cpp/utils/JHardwareBufferUtils.cpp

@@ -0,0 +1,95 @@
+//
+//  JHardwareBufferUtils.cpp
+//  react-native-nitro
+//
+//  Created by Marc Rousavy on 11.07.25.
+//
+
+#include "JHardwareBufferUtils.hpp"
+#include "NitroDefines.hpp"
+#include <android/hardware_buffer_jni.h>
+
+namespace margelo::nitro {
+
+size_t JHardwareBufferUtils::getHardwareBufferSize(AHardwareBuffer* hardwareBuffer) {
+#if __ANDROID_API__ >= 26
+  AHardwareBuffer_Desc description;
+  AHardwareBuffer_describe(hardwareBuffer, &description);
+  size_t sourceSize = description.height * description.stride;
+  return sourceSize;
+#else
+  throw std::runtime_error("ArrayBuffer(HardwareBuffer) requires NDK API 26 or above! (minSdk >= 26)");
+#endif
+}
+
+jni::local_ref<jni::JObject> JHardwareBufferUtils::copyHardwareBufferBoxedNew(jni::alias_ref<jni::JClass>,
+                                                                              jni::alias_ref<jni::JObject> boxedHardwareBuffer) {
+#if __ANDROID_API__ >= 26
+  // 1. Unbox HardwareBuffer from jobject
+  AHardwareBuffer* sourceHardwareBuffer = AHardwareBuffer_fromHardwareBuffer(jni::Environment::current(), boxedHardwareBuffer.get());
+  // 2. Describe the buffer
+  AHardwareBuffer_Desc description;
+  AHardwareBuffer_describe(sourceHardwareBuffer, &description);
+  // 3. Create a new buffer from the same description
+  AHardwareBuffer* destinationHardwareBuffer;
+  AHardwareBuffer_allocate(&description, &destinationHardwareBuffer);
+  // 4. Copy the data over
+  copyHardwareBuffer(sourceHardwareBuffer, destinationHardwareBuffer);
+  // 5. Box it into jobject again
+  jobject boxed = AHardwareBuffer_toHardwareBuffer(jni::Environment::current(), destinationHardwareBuffer);
+  return jni::make_local(boxed);
+#else
+  throw std::runtime_error("ArrayBuffer(HardwareBuffer) requires NDK API 26 or above! (minSdk >= 26)");
+#endif
+}
+
+void JHardwareBufferUtils::copyHardwareBufferBoxed(jni::alias_ref<jni::JClass>, jni::alias_ref<jni::JObject> boxedSourceHardwareBuffer,
+                                                   jni::alias_ref<jni::JObject> boxedDestinationHardwareBuffer) {
+#if __ANDROID_API__ >= 26
+  // 1. Unbox HardwareBuffer from jobject
+  AHardwareBuffer* sourceHardwareBuffer = AHardwareBuffer_fromHardwareBuffer(jni::Environment::current(), boxedSourceHardwareBuffer.get());
+  AHardwareBuffer* destinationHardwareBuffer =
+      AHardwareBuffer_fromHardwareBuffer(jni::Environment::current(), boxedDestinationHardwareBuffer.get());
+  // 2. Copy data over from source -> destination
+  copyHardwareBuffer(sourceHardwareBuffer, destinationHardwareBuffer);
+#else
+  throw std::runtime_error("ArrayBuffer(HardwareBuffer) requires NDK API 26 or above! (minSdk >= 26)");
+#endif
+}
+
+void JHardwareBufferUtils::copyHardwareBuffer(AHardwareBuffer* sourceHardwareBuffer, AHardwareBuffer* destinationHardwareBuffer) {
+#if __ANDROID_API__ >= 26
+  // 1. Get info about source buffer
+  size_t sourceSize = getHardwareBufferSize(sourceHardwareBuffer);
+
+  // 2. Get info about the destination buffer
+#ifdef NITRO_DEBUG
+  size_t destinationSize = getHardwareBufferSize(sourceHardwareBuffer);
+  if (sourceSize != destinationSize) {
+    throw std::runtime_error("Source HardwareBuffer (" + std::to_string(sourceSize) + " bytes) and destination HardwareBuffer (" +
+                             std::to_string(destinationSize) + " bytes) are not the same size!");
+  }
+#endif
+
+  // 3. Copy data over
+  void* sourceData;
+  void* destinationData;
+  int lockSource = AHardwareBuffer_lock(sourceHardwareBuffer, AHARDWAREBUFFER_USAGE_CPU_READ_MASK, -1, nullptr, &sourceData);
+  if (lockSource != 0) {
+    throw std::runtime_error("Failed to lock source HardwareBuffer! Error: " + std::to_string(lockSource));
+  }
+  int lockDestination =
+      AHardwareBuffer_lock(destinationHardwareBuffer, AHARDWAREBUFFER_USAGE_CPU_WRITE_MASK, -1, nullptr, &destinationData);
+  if (lockDestination != 0) {
+    AHardwareBuffer_unlock(sourceHardwareBuffer, nullptr);
+    throw std::runtime_error("Failed to lock destination HardwareBuffer! Error: " + std::to_string(lockDestination));
+  }
+  memcpy(destinationData, sourceData, sourceSize);
+  AHardwareBuffer_unlock(sourceHardwareBuffer, nullptr);
+  AHardwareBuffer_unlock(destinationHardwareBuffer, nullptr);
+#else
+  throw std::runtime_error("ArrayBuffer(HardwareBuffer) requires NDK API 26 or above! (minSdk >= 26)");
+#endif
+}
+
+} // namespace margelo::nitro

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

@@ -0,0 +1,39 @@
+//
+//  JHardwareBufferUtils.hpp
+//  react-native-nitro
+//
+//  Created by Marc Rousavy on 11.07.25.
+//
+
+#pragma once
+
+#include <android/hardware_buffer.h>
+#include <fbjni/fbjni.h>
+
+namespace margelo::nitro {
+
+using namespace facebook;
+
+class JHardwareBufferUtils final : public jni::JavaClass<JHardwareBufferUtils> {
+public:
+  static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/utils/HardwareBufferUtils;";
+
+public:
+  static size_t getHardwareBufferSize(AHardwareBuffer* hardwareBuffer);
+
+  static void copyHardwareBufferBoxed(jni::alias_ref<jni::JClass>, jni::alias_ref<jni::JObject> boxedSourceHardwareBuffer,
+                                      jni::alias_ref<jni::JObject> boxedDestinationHardwareBuffer);
+
+  static jni::local_ref<jni::JObject> copyHardwareBufferBoxedNew(jni::alias_ref<jni::JClass>,
+                                                                 jni::alias_ref<jni::JObject> boxedSourceHardwareBuffer);
+
+  static void copyHardwareBuffer(AHardwareBuffer* sourceHardwareBuffer, AHardwareBuffer* destinationHardwareBuffer);
+
+public:
+  static void registerNatives() {
+    javaClassStatic()->registerNatives({makeNativeMethod("copyHardwareBuffer", JHardwareBufferUtils::copyHardwareBufferBoxed),
+                                        makeNativeMethod("copyHardwareBuffer", JHardwareBufferUtils::copyHardwareBufferBoxedNew)});
+  }
+};
+
+} // namespace margelo::nitro

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

@@ -37,6 +37,7 @@ class AnyMap {
   external fun remove(key: String)
   @FastNative
   external fun clear()
+  external fun getAllKeys(): Array<String>
 
   @FastNative
   external fun isNull(key: String): Boolean

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

@@ -1,11 +1,18 @@
 package com.margelo.nitro.core
 
 import androidx.annotation.Keep
+import android.hardware.HardwareBuffer
+import android.os.Build
+import androidx.annotation.RequiresApi
 import com.facebook.jni.HybridData
 import com.facebook.proguard.annotations.DoNotStrip
+import com.margelo.nitro.utils.HardwareBufferUtils
 import dalvik.annotation.optimization.FastNative
 import java.nio.ByteBuffer
 
+// AHardwareBuffer* needs to be boxed in jobject*
+typealias BoxedHardwareBuffer = Any
+
 /**
  * An ArrayBuffer instance shared between native (Kotlin/C++) and JS.
  *
@@ -41,6 +48,15 @@ class ArrayBuffer {
     val isByteBuffer: Boolean
         get() = getIsByteBuffer()
 
+    /**
+     * Whether this `ArrayBuffer` is holding a `HardwareBuffer`, or not.
+     * - If the `ArrayBuffer` holds a `HardwareBuffer`, `getHardwareBuffer()` can safely be called without copy.
+     * - If the `ArrayBuffer` doesn't hold a `HardwareBuffer`, `getHardwareBuffer()` will throw.
+     * You will need to call `getByteBuffer(copyIfNeeded)` instead.
+     */
+    val isHardwareBuffer: Boolean
+        get() = getIsHardwareBuffer()
+
     /**
      * Get the size of bytes in this `ArrayBuffer`.
      */
@@ -64,6 +80,16 @@ class ArrayBuffer {
         return getByteBuffer(copyIfNeeded)
     }
 
+    /**
+     * Get the underlying `HardwareBuffer` if this `ArrayBuffer` was created with one.
+     * @throws Error if this `ArrayBuffer` was not created with a `HardwareBuffer`.
+     */
+    @RequiresApi(Build.VERSION_CODES.O)
+    fun getHardwareBuffer(): HardwareBuffer {
+        val boxed = getHardwareBufferBoxed()
+        return boxed as HardwareBuffer
+    }
+
     /**
      * Create a new **owning-** `ArrayBuffer` that holds the given `ByteBuffer`.
      * The `ByteBuffer` needs to remain valid for as long as the `ArrayBuffer` is alive.
@@ -76,6 +102,18 @@ class ArrayBuffer {
         mHybridData = initHybrid(byteBuffer)
     }
 
+    /**
+     * Create a new **owning-** `ArrayBuffer` that holds the given `HardwareBuffer`.
+     * The `HardwareBuffer` needs to remain valid for as long as the `ArrayBuffer` is alive.
+     */
+    @RequiresApi(Build.VERSION_CODES.O)
+    constructor(hardwareBuffer: HardwareBuffer) {
+        if (hardwareBuffer.isClosed) {
+            throw Error("Cannot create ArrayBuffer from an already-closed HardwareBuffer!")
+        }
+        mHybridData = initHybridBoxedHardwareBuffer(hardwareBuffer)
+    }
+
     /**
      * Create a new **non-owning-** `ArrayBuffer` that holds foreign data, potentially coming from JS.
      */
@@ -87,12 +125,19 @@ class ArrayBuffer {
     }
 
     private external fun initHybrid(buffer: ByteBuffer): HybridData
+    @RequiresApi(Build.VERSION_CODES.O)
+    private external fun initHybridBoxedHardwareBuffer(hardwareBufferBoxed: BoxedHardwareBuffer): HybridData
+
     private external fun getByteBuffer(copyIfNeeded: Boolean): ByteBuffer
+    private external fun getHardwareBufferBoxed(): BoxedHardwareBuffer
+
     @FastNative
     private external fun getIsOwner(): Boolean
     @FastNative
     private external fun getIsByteBuffer(): Boolean
     @FastNative
+    private external fun getIsHardwareBuffer(): Boolean
+    @FastNative
     private external fun getBufferSize(): Int
 
     companion object {
@@ -108,8 +153,13 @@ class ArrayBuffer {
          * Copy the given `ArrayBuffer` into a new **owning** `ArrayBuffer`.
          */
         fun copy(other: ArrayBuffer): ArrayBuffer {
-            val byteBuffer = other.getBuffer(false)
-            return copy(byteBuffer)
+            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O && other.isHardwareBuffer) {
+                val hardwareBuffer = other.getHardwareBuffer()
+                return copy(hardwareBuffer)
+            } else {
+                val byteBuffer = other.getBuffer(false)
+                return copy(byteBuffer)
+            }
         }
 
         /**
@@ -129,6 +179,14 @@ class ArrayBuffer {
             // 5. Create a new `ArrayBuffer`
             return ArrayBuffer(newBuffer)
         }
+        /**
+         * Copy the given `HardwareBuffer` into a new **owning** `ArrayBuffer`.
+         */
+        @RequiresApi(Build.VERSION_CODES.O)
+        fun copy(hardwareBuffer: HardwareBuffer): ArrayBuffer {
+            val copy = HardwareBufferUtils.copyHardwareBuffer(hardwareBuffer)
+            return ArrayBuffer(copy)
+        }
 
         /**
          * Wrap the given `ByteBuffer` in a new **owning** `ArrayBuffer`.
@@ -137,5 +195,13 @@ class ArrayBuffer {
             byteBuffer.rewind()
             return ArrayBuffer(byteBuffer)
         }
+
+        /**
+         * Wrap the given `HardwareBuffer` in a new **owning** `ArrayBuffer`.
+         */
+        @RequiresApi(Build.VERSION_CODES.O)
+        fun wrap(hardwareBuffer: HardwareBuffer): ArrayBuffer {
+            return ArrayBuffer(hardwareBuffer)
+        }
     }
 }

package/android/src/main/java/com/margelo/nitro/utils/HardwareBuffer+updateFrom.kt

@@ -0,0 +1,15 @@
+package com.margelo.nitro.utils
+
+import android.hardware.HardwareBuffer
+import android.os.Build
+import androidx.annotation.RequiresApi
+
+/**
+ * Updates this [[HardwareBuffer]] with the data in the given [[hardwareBuffer]].
+ * The given [[hardwareBuffer]] has to have the same description and shape as this [[HardwareBuffer]].
+ */
+@RequiresApi(Build.VERSION_CODES.O)
+fun HardwareBuffer.updateFrom(hardwareBuffer: HardwareBuffer) {
+    HardwareBufferUtils.copyHardwareBuffer(hardwareBuffer, this)
+}
+

package/android/src/main/java/com/margelo/nitro/utils/HardwareBufferUtils.kt

@@ -0,0 +1,42 @@
+package com.margelo.nitro.utils
+
+import android.hardware.HardwareBuffer
+import android.os.Build
+import androidx.annotation.RequiresApi
+
+/**
+ * HardwareBuffers are special types in JNI (`AHardwareBuffer*`)
+ * and have to be boxed to `jobject*`.
+ */
+typealias BoxedHardwareBuffer = Any
+
+@Suppress("KotlinJniMissingFunction")
+class HardwareBufferUtils {
+    companion object {
+        @JvmStatic
+        @RequiresApi(Build.VERSION_CODES.O)
+        private external fun copyHardwareBuffer(sourceHardwareBuffer: BoxedHardwareBuffer): BoxedHardwareBuffer
+        @JvmStatic
+        @RequiresApi(Build.VERSION_CODES.O)
+        private external fun copyHardwareBuffer(sourceHardwareBuffer: BoxedHardwareBuffer, destinationHardwareBuffer: BoxedHardwareBuffer)
+
+        /**
+         * Copies the given [[hardwareBuffer]] into a new, identically shaped [[HardwareBuffer]].
+         */
+        @Throws
+        @RequiresApi(Build.VERSION_CODES.O)
+        fun copyHardwareBuffer(hardwareBuffer: HardwareBuffer): HardwareBuffer {
+            val resultBoxed = copyHardwareBuffer(hardwareBuffer as Any)
+            return resultBoxed as HardwareBuffer
+        }
+
+        /**
+         * Copies the given [[source]] [[HardwareBuffer]] into the given [[destination]] [[HardwareBuffer]].
+         */
+        @Throws
+        @RequiresApi(Build.VERSION_CODES.O)
+        fun copyHardwareBuffer(source: HardwareBuffer, destination: HardwareBuffer) {
+            copyHardwareBuffer(source as Any, destination as Any)
+        }
+    }
+}

package/cpp/core/AnyMap.cpp

@@ -16,6 +16,14 @@ void AnyMap::remove(const std::string& key) {
 void AnyMap::clear() noexcept {
   _map.clear();
 }
+std::vector<std::string> AnyMap::getAllKeys() const {
+  std::vector<std::string> keys;
+  keys.reserve(_map.size());
+  for (const auto& pair : _map) {
+    keys.push_back(pair.first);
+  }
+  return keys;
+}
 
 // Is
 bool AnyMap::isNull(const std::string& key) const {

package/cpp/core/AnyMap.hpp

@@ -75,6 +75,10 @@ public:
    * Deletes all keys and values inside the map.
    */
   void clear() noexcept;
+  /**
+   * Get all keys this `AnyMap` instance contains.
+   */
+  std::vector<std::string> getAllKeys() const;
 
 public:
   /**

package/cpp/core/ArrayBuffer.cpp

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

package/cpp/core/ArrayBuffer.hpp

@@ -63,6 +63,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 copies the given `std::shared_ptr<ArrayBuffer>`.
+   */
+  static std::shared_ptr<ArrayBuffer> copy(const std::shared_ptr<ArrayBuffer>& buffer);
   /**
    * Create a new `NativeArrayBuffer` that allocates a new buffer of the given size.
    */

package/cpp/core/HybridFunction.hpp

@@ -181,8 +181,9 @@ private:
    * Get the `NativeState` of the given `value`.
    */
   template <typename THybrid>
-  static inline std::shared_ptr<THybrid> getHybridObjectNativeState(jsi::Runtime& runtime, const jsi::Value& value, FunctionKind funcKind,
-                                                                    const std::string& funcName) {
+  static inline std::shared_ptr<THybrid> getHybridObjectNativeState(jsi::Runtime& runtime, const jsi::Value& value,
+                                                                    [[maybe_unused]] FunctionKind funcKind,
+                                                                    [[maybe_unused]] const std::string& funcName) {
     // 1. Convert jsi::Value to jsi::Object
 #ifdef NITRO_DEBUG
     if (!value.isObject()) [[unlikely]] {

package/cpp/platform/NitroLogger.hpp

@@ -22,7 +22,8 @@ private:
 
 public:
   template <typename... Args>
-  static void log(LogLevel level, const char* tag, const char* format, Args... args) {
+  static void log([[maybe_unused]] LogLevel level, [[maybe_unused]] const char* tag, [[maybe_unused]] const char* format,
+                  [[maybe_unused]] Args... args) {
 #ifdef NITRO_DEBUG
     // 1. Make sure args can be passed to sprintf(..)
     static_assert(all_are_trivially_copyable<Args...>(), "All arguments passed to Logger::log(..) must be trivially copyable! "

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

package/ios/core/AnyMapHolder.swift

@@ -82,6 +82,19 @@ public final class AnyMapHolder {
     cppPart.pointee.clear()
   }
 
+  /**
+   * Get all keys in this map.
+   */
+  public func getAllKeys() -> [String] {
+    let cppKeys = cppPart.pointee.getAllKeys()
+    var keys = [String]()
+    keys.reserveCapacity(cppKeys.count)
+    for cppKey in cppKeys {
+      keys.append(String(cppKey))
+    }
+    return keys
+  }
+
   // pragma MARK: Getters
 
   /**

package/package.json

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