react-native-nitro-modules 0.26.2 → 0.26.4

package/NitroModules.podspec

@@ -1,4 +1,5 @@
 require "json"
+require "./nitro_pod_utils"
 
 package = JSON.parse(File.read(File.join(__dir__, "package.json")))
 
@@ -47,25 +48,33 @@ Pod::Spec.new do |s|
     "cpp/views/CachedProp.hpp",
     # Public iOS-specific headers that will be exposed in modulemap (for Swift)
     "ios/core/ArrayBufferHolder.hpp",
-    "ios/core/AnyMapHolder.hpp",
     "ios/core/PromiseHolder.hpp",
+    "ios/utils/AnyMapUtils.hpp",
     "ios/utils/Result.hpp",
     "ios/utils/DateToChronoDate.hpp",
     "ios/utils/RuntimeError.hpp",
     "ios/utils/SwiftClosure.hpp",
   ]
 
-  s.pod_target_xcconfig = {
+  xcconfig = {
     # Use C++ 20
     "CLANG_CXX_LANGUAGE_STANDARD" => "c++20",
     # Enables C++ <-> Swift interop (by default it's only C)
     "SWIFT_OBJC_INTEROP_MODE" => "objcxx",
     # Enables stricter modular headers
     "DEFINES_MODULE" => "YES",
-    # C++ compiler flags, mainly for RN version and folly.
-    "GCC_PREPROCESSOR_DEFINITIONS" => "$(inherited) FOLLY_NO_CONFIG FOLLY_CFG_NO_COROUTINES"
   }
 
+  if has_react_native()
+    react_native_version = get_react_native_version()
+    if (react_native_version < 80)
+      # C++ compiler flags, for folly when building as static framework:
+      xcconfig["GCC_PREPROCESSOR_DEFINITIONS"] = "$(inherited) FOLLY_NO_CONFIG FOLLY_CFG_NO_COROUTINES"
+    end
+  end
+
+  s.pod_target_xcconfig = xcconfig
+
   # Nitro depends on JSI.
   s.dependency 'React-jsi'
   # For React Native, we implement nitro::Dispatcher using react::CallInvoker

package/README.md

@@ -202,13 +202,13 @@ The following C++ / JS types are supported out of the box:
   <tr>
     <td><code>{ ... }</code></td>
     <td><code>std::shared_ptr&lt;<a href="./cpp/core/AnyMap.hpp">AnyMap</a>&gt;</code></td>
-    <td><code><a href="./ios/core/AnyMapHolder.swift">AnyMapHolder</a></code></td>
+    <td><code><a href="./ios/core/AnyMap.swift">AnyMap</a></code></td>
     <td><code><a href="./android/src/main/java/com/margelo/nitro/core/AnyMap.kt">AnyMap</a></code></td>
   </tr>
   <tr>
     <td><code>ArrayBuffer</code></td>
     <td><code>std::shared_ptr&lt;<a href="./cpp/core/ArrayBuffer.hpp">ArrayBuffer</a>&gt;</code></td>
-    <td><code><a href="./ios/core/ArrayBufferHolder.swift">ArrayBufferHolder</a></code></td>
+    <td><code><a href="./ios/core/ArrayBuffer.swift">ArrayBuffer</a></code></td>
     <td><code><a href="./android/src/main/java/com/margelo/nitro/core/ArrayBuffer.kt">ArrayBuffer</a></code></td>
   </tr>
   <tr>

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.1"
   }
 }
 

package/android/gradle.properties

@@ -1,4 +1,4 @@
-Nitro_kotlinVersion=2.0.21
+Nitro_kotlinVersion=2.1.20
 Nitro_minSdkVersion=23
 Nitro_targetSdkVersion=35
 Nitro_compileSdkVersion=34

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/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>, [[maybe_unused]] 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,98 @@
+//
+//  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([[maybe_unused]] 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>,
+                                                 [[maybe_unused]] 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>,
+                                                   [[maybe_unused]] jni::alias_ref<jni::JObject> boxedSourceHardwareBuffer,
+                                                   [[maybe_unused]] 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([[maybe_unused]] AHardwareBuffer* sourceHardwareBuffer,
+                                              [[maybe_unused]] 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/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,46 @@
+package com.margelo.nitro.utils
+
+import androidx.annotation.Keep
+import com.facebook.proguard.annotations.DoNotStrip
+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")
+@Keep
+@DoNotStrip
+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/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; });