react-native-nitro-modules 0.4.1 → 0.6.0

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

@@ -0,0 +1,119 @@
+//
+//  JArrayBuffer.hpp
+//  react-native-nitro
+//
+//  Created by Marc Rousavy on 14.07.24.
+//
+
+#pragma once
+
+#include "ArrayBuffer.hpp"
+#include "ByteBufferArrayBuffer.hpp"
+#include <fbjni/ByteBuffer.h>
+#include <fbjni/fbjni.h>
+#include <functional>
+#include <utility>
+
+namespace margelo::nitro {
+
+using namespace facebook;
+
+/**
+ * Represents a `ArrayBuffer` that can either hold a `ByteBuffer` (owning),
+ * or unknown/foreign memory, potentially from JS (non-owning).
+ */
+class JArrayBuffer final : public jni::HybridClass<JArrayBuffer> {
+public:
+  static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/core/ArrayBuffer;";
+
+public:
+  /**
+   * Create a new `JArrayBuffer` that wraps the given ArrayBuffer.
+   */
+  static jni::local_ref<JArrayBuffer::javaobject> wrap(const std::shared_ptr<ArrayBuffer>& arrayBuffer) {
+    return newObjectCxxArgs(arrayBuffer);
+  }
+
+public:
+  /**
+   * Create a new `JArrayBuffer` that wraps the given `ByteBuffer` from Java.
+   */
+  static jni::local_ref<JArrayBuffer::jhybriddata> initHybrid(jni::alias_ref<jhybridobject> jThis,
+                                                              jni::alias_ref<jni::JByteBuffer> buffer) {
+    return makeCxxInstance(buffer);
+  }
+
+public:
+  /**
+   * Get whether the `ArrayBuffer` is holding data from a `ByteBuffer`.
+   */
+  bool getIsByteBuffer() {
+    auto byteBufferArrayBuffer = std::dynamic_pointer_cast<ByteBufferArrayBuffer>(_arrayBuffer);
+    return byteBufferArrayBuffer != nullptr;
+  }
+
+  /**
+   * Get whether the `ArrayBuffer` is owning the data and can safely hold onto it longer.
+   */
+  bool getIsOwner() {
+    return _arrayBuffer->isOwner();
+  }
+
+  /**
+   * Get the `ArrayBuffer`'s data as a `ByteBuffer`.
+   *
+   * - If the `ArrayBuffer` was created from a `ByteBuffer` (`isByteBuffer()`), this returns
+   * a reference to the original `ByteBuffer`, which is safe to be kept in memory for longer.
+   * - If the `ArrayBuffer` was created elsewhere (either in JS, or in C++), it does not have a
+   * `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::alias_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!
+      return byteBufferArrayBuffer->getBuffer();
+    } else {
+      // It is a different kind of `ArrayBuffer`, we need to copy or wrap the data.
+      size_t size = _arrayBuffer->size();
+      if (copyIfNeeded) {
+        auto buffer = jni::JByteBuffer::allocateDirect(size);
+        buffer->order(jni::JByteOrder::bigEndian());
+        memcpy(buffer->getDirectAddress(), _arrayBuffer->data(), size);
+        return buffer;
+      } else {
+        auto buffer = jni::JByteBuffer::wrapBytes(_arrayBuffer->data(), size);
+        buffer->order(jni::JByteOrder::bigEndian());
+        return buffer;
+      }
+    }
+  }
+
+public:
+  /**
+   * Get the underlying `ArrayBuffer`.
+   */
+  std::shared_ptr<ArrayBuffer> getArrayBuffer() const {
+    return _arrayBuffer;
+  }
+
+private:
+  JArrayBuffer(const std::shared_ptr<ArrayBuffer>& arrayBuffer) : _arrayBuffer(arrayBuffer) {}
+  JArrayBuffer(jni::alias_ref<jni::JByteBuffer> byteBuffer) {
+    _arrayBuffer = std::make_shared<ByteBufferArrayBuffer>(byteBuffer);
+  }
+
+private:
+  friend HybridBase;
+  using HybridBase::HybridBase;
+  std::shared_ptr<ArrayBuffer> _arrayBuffer;
+
+public:
+  static void registerNatives() {
+    registerHybrid(
+        {makeNativeMethod("initHybrid", JArrayBuffer::initHybrid), makeNativeMethod("getByteBuffer", JArrayBuffer::getByteBuffer),
+         makeNativeMethod("getIsByteBuffer", JArrayBuffer::getIsByteBuffer), makeNativeMethod("getIsOwner", JArrayBuffer::getIsOwner)});
+  }
+};
+
+} // namespace margelo::nitro

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

@@ -14,12 +14,19 @@ namespace margelo::nitro {
 
 using namespace facebook;
 
-struct JHybridObject : public jni::HybridClass<JHybridObject>, public HybridObject {
+/**
+ * Represents the Java `HybridObject` instance.
+ * HybridData is passed up from inherited members, so this acts like a base class
+ * and has to be inherited as "virtual" in C++ to properly avoid creating multiple `HybridObject` instances.
+ */
+class JHybridObject : public jni::HybridClass<JHybridObject>, public virtual HybridObject {
 public:
-  static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/HybridObject;";
+  static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/core/HybridObject;";
 
-public:
-  static void registerNatives();
+  ~JHybridObject() override = default;
+
+private:
+  friend HybridBase;
 };
 
 } // namespace margelo::nitro

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

@@ -0,0 +1,88 @@
+//
+//  JPromise.hpp
+//  react-native-nitro
+//
+//  Created by Marc Rousavy on 14.07.24.
+//
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+
+namespace margelo::nitro {
+
+using namespace facebook;
+
+/**
+ * Represents a Promise implemented in Java.
+ */
+class JPromise final : public jni::HybridClass<JPromise> {
+public:
+  static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/core/Promise;";
+  using OnResolvedFunc = std::function<void(jni::alias_ref<jni::JObject>)>;
+  using OnRejectedFunc = std::function<void(jni::alias_ref<jni::JString>)>;
+
+public:
+  /**
+   * Create a new, still unresolved `JPromise` from Java.
+   */
+  static jni::local_ref<JPromise::jhybriddata> initHybrid(jni::alias_ref<jhybridobject>) {
+    return makeCxxInstance();
+  }
+
+public:
+  void resolve(jni::alias_ref<jni::JObject> result) {
+    _result = jni::make_global(result);
+    for (const auto& onResolved : _onResolvedListeners) {
+      onResolved(_result);
+    }
+  }
+  void reject(jni::alias_ref<jni::JString> error) {
+    _error = jni::make_global(error);
+    for (const auto& onRejected : _onRejectedListeners) {
+      onRejected(_error);
+    }
+  }
+
+public:
+  void addOnResolvedListener(OnResolvedFunc&& onResolved) {
+    if (_result != nullptr) {
+      // Promise is already resolved! Call the callback immediately
+      onResolved(_result);
+    } else {
+      // Promise is not yet resolved, put the listener in our queue.
+      _onResolvedListeners.push_back(std::move(onResolved));
+    }
+  }
+  void addOnRejectedListener(OnRejectedFunc&& onRejected) {
+    if (_error != nullptr) {
+      // Promise is already rejected! Call the callback immediately
+      onRejected(_error);
+    } else {
+      // Promise is not yet rejected, put the listener in our queue.
+      _onRejectedListeners.push_back(std::move(onRejected));
+    }
+  }
+
+private:
+  JPromise() {}
+
+private:
+  friend HybridBase;
+  using HybridBase::HybridBase;
+  jni::global_ref<jni::JObject> _result;
+  jni::global_ref<jni::JString> _error;
+  std::vector<OnResolvedFunc> _onResolvedListeners;
+  std::vector<OnRejectedFunc> _onRejectedListeners;
+
+public:
+  static void registerNatives() {
+    registerHybrid({
+        makeNativeMethod("initHybrid", JPromise::initHybrid),
+        makeNativeMethod("nativeResolve", JPromise::resolve),
+        makeNativeMethod("nativeReject", JPromise::reject),
+    });
+  }
+};
+
+} // namespace margelo::nitro

package/android/src/main/cpp/platform/NitroLogger.cpp

@@ -0,0 +1,36 @@
+//
+//  NitroLogger.cpp
+//  react-native-nitro
+//
+//  Created by Marc Rousavy on 14.07.24.
+//
+
+#include "NitroLogger.hpp"
+#include <android/log.h>
+
+namespace margelo::nitro {
+
+int levelToAndroidLevel(LogLevel level) {
+  switch (level) {
+    case LogLevel::Debug:
+      return ANDROID_LOG_DEBUG;
+    case LogLevel::Info:
+      return ANDROID_LOG_INFO;
+    case LogLevel::Warning:
+      return ANDROID_LOG_WARN;
+    case LogLevel::Error:
+      return ANDROID_LOG_ERROR;
+    default:
+      throw std::runtime_error("Invalid LogLevel!");
+  }
+}
+
+void Logger::nativeLog(LogLevel level, const char* tag, const std::string& message) {
+#ifndef NDEBUG
+  int logLevel = levelToAndroidLevel(level);
+  std::string combinedTag = "Nitro." + std::string(tag);
+  __android_log_print(logLevel, combinedTag.c_str(), "%s", message.c_str());
+#endif
+}
+
+} // namespace margelo::nitro

package/android/src/main/cpp/registry/JHybridObjectInitializer.hpp

@@ -23,7 +23,7 @@ public:
   }
 
 public:
-  static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/HybridObjectInitializer;";
+  static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/core/HybridObjectInitializer;";
 };
 
 } // namespace margelo::nitro

package/android/src/main/cpp/registry/JHybridObjectRegistry.cpp

@@ -7,7 +7,7 @@
 
 #include "JHybridObjectRegistry.hpp"
 #include "HybridObjectRegistry.hpp"
-#include "JNISharedPtr.h"
+#include "JNISharedPtr.hpp"
 
 namespace margelo::nitro {
 

package/android/src/main/cpp/registry/JHybridObjectRegistry.hpp

@@ -17,7 +17,7 @@ using namespace facebook;
 
 struct JHybridObjectRegistry : public jni::JavaClass<JHybridObjectRegistry> {
 public:
-  static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/HybridObjectRegistry;";
+  static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/core/HybridObjectRegistry;";
 
 public:
   static void registerHybridObjectConstructor(jni::alias_ref<jni::JClass> clazz, std::string hybridObjectName,

package/android/src/main/cpp/utils/{JNISharedPtr.h → JNISharedPtr.hpp}

@@ -26,8 +26,20 @@ private:
 };
 
 class JNISharedPtr {
+private:
+  template <typename T, template <typename, typename...> class Base>
+  struct is_base_template_of {
+    template <typename U>
+    static std::true_type test(Base<U>*) {}
+
+    template <typename>
+    static std::false_type test(...) {}
+
+    static constexpr bool value = decltype(test<T>(nullptr))::value;
+  };
+
 public:
-  template <typename T, typename std::enable_if<std::is_base_of<jni::HybridClass<T>, T>::value>::type* = nullptr>
+  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});
   }

package/android/src/main/java/com/margelo/nitro/JNIOnLoad.java

@@ -0,0 +1,27 @@
+package com.margelo.nitro;
+
+import android.util.Log;
+
+public class JNIOnLoad {
+    private static final String TAG = "NitroModules";
+    private static boolean isInitialized = false;
+
+    /**
+     * Initializes the C++ (JNI) part of Nitro Modules.
+     * This function should be called in a `static` block everytime the Java part
+     * interacts with the native C++ (JNI) part of Nitro Modules.
+     * If Native Nitro is already initialized, this function will do nothing.
+     */
+    public synchronized static void initializeNativeNitro() {
+        if (isInitialized) return;
+        try {
+            Log.i(TAG, "Loading NitroModules C++ library...");
+            System.loadLibrary("NitroModules");
+            Log.i(TAG, "Successfully loaded NitroModules C++ library!");
+            isInitialized = true;
+        } catch (Throwable e) {
+            Log.e(TAG, "Failed to load NitroModules C++ library! Is it properly installed and linked?", e);
+            throw e;
+        }
+    }
+}

package/android/src/main/java/com/margelo/nitro/NitroModulesPackage.java

@@ -11,16 +11,8 @@ import com.facebook.react.TurboReactPackage;
 import java.util.HashMap;
 
 public class NitroModulesPackage extends TurboReactPackage {
-  private static final String TAG = "NitroModules";
   static {
-    try {
-      Log.i(TAG, "Loading NitroModules C++ library...");
-      System.loadLibrary("NitroModules");
-      Log.i(TAG, "Successfully loaded NitroModules C++ library!");
-    } catch (Throwable e) {
-      Log.e(TAG, "Failed to load NitroModules C++ library! Is it properly installed and linked?", e);
-      throw e;
-    }
+    JNIOnLoad.initializeNativeNitro();
   }
 
   @Nullable

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

@@ -0,0 +1,61 @@
+package com.margelo.nitro.core
+
+import androidx.annotation.Keep
+import com.facebook.jni.HybridData
+import com.facebook.proguard.annotations.DoNotStrip
+
+/**
+ * Represents an untyped map of string keys with associated values.
+ * This is like a JS [`object`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object).
+ */
+@Suppress("KotlinJniMissingFunction")
+@Keep
+@DoNotStrip
+class AnyMap {
+  private val mHybridData: HybridData
+
+  /**
+   * Create a new empty `AnyMap`.
+   */
+  constructor() {
+    mHybridData = initHybrid()
+  }
+
+  /**
+   * Create a new `AnyMap` from C++, which potentially already holds data.
+   */
+  @Suppress("unused")
+  private constructor(hybridData: HybridData) {
+    mHybridData = hybridData
+  }
+
+
+  external fun contains(key: String): Boolean
+  external fun remove(key: String)
+  external fun clear()
+
+  external fun isNull(key: String): Boolean
+  external fun isDouble(key: String): Boolean
+  external fun isBoolean(key: String): Boolean
+  external fun isBigInt(key: String): Boolean
+  external fun isString(key: String): Boolean
+  external fun isArray(key: String): Boolean
+  external fun isObject(key: String): Boolean
+
+  external fun getDouble(key: String): Double
+  external fun getBoolean(key: String): Boolean
+  external fun getBigInt(key: String): Long
+  external fun getString(key: String): String
+  external fun getAnyArray(key: String): AnyArray
+  external fun getAnyObject(key: String): AnyObject
+
+  external fun setNull(key: String)
+  external fun setDouble(key: String, value: Double)
+  external fun setBoolean(key: String, value: Boolean)
+  external fun setBigInt(key: String, value: Long)
+  external fun setString(key: String, value: String)
+  external fun setAnyArray(key: String, value: AnyArray)
+  external fun setAnyObject(key: String, value: AnyObject)
+
+  private external fun initHybrid(): HybridData
+}

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

@@ -0,0 +1,153 @@
+package com.margelo.nitro.core
+
+import androidx.annotation.Keep
+import com.facebook.jni.HybridData
+import com.facebook.proguard.annotations.DoNotStrip
+
+typealias AnyArray = Array<AnyValue>
+typealias AnyObject = Map<String, AnyValue>
+
+/**
+ * Represents a value that can be any of the following types:
+ * - `null`
+ * - [Double]
+ * - [Boolean]
+ * - [Long]
+ * - [String]
+ * - [AnyArray] ([Array]`<AnyValue>`)
+ * - [AnyObject] ([Map]`<String, AnyValue>`)
+ */
+@Suppress("KotlinJniMissingFunction")
+@Keep
+@DoNotStrip
+class AnyValue {
+    private val mHybridData: HybridData
+
+    /**
+     * Create a new [AnyValue] that holds `null`.
+     */
+    constructor() {
+        mHybridData = initHybrid()
+    }
+
+    /**
+     * Create a new [AnyValue] that holds the given [Double]
+     */
+    constructor(value: Double) {
+        mHybridData = initHybrid(value)
+    }
+
+    /**
+     * Create a new [AnyValue] that holds the given [Boolean]
+     */
+    constructor(value: Boolean) {
+        mHybridData = initHybrid(value)
+    }
+
+    /**
+     * Create a new [AnyValue] that holds the given [Long]
+     */
+    constructor(value: Long) {
+        mHybridData = initHybrid(value)
+    }
+
+    /**
+     * Create a new [AnyValue] that holds the given [String]
+     */
+    constructor(value: String) {
+        mHybridData = initHybrid(value)
+    }
+
+    /**
+     * Create a new [AnyValue] that holds the given [AnyArray]
+     */
+    constructor(value: AnyArray) {
+        mHybridData = initHybrid(value)
+    }
+
+    /**
+     * Create a new [AnyValue] that holds the given [AnyObject]
+     */
+    constructor(value: AnyObject) {
+        mHybridData = initHybrid(value)
+    }
+
+    /**
+     * Gets whether this [AnyValue] instance is holding a `null`.
+     */
+    external fun isNull(): Boolean
+
+    /**
+     * Gets whether this [AnyValue] instance is holding a [Double] value.
+     */
+    external fun isDouble(): Boolean
+
+    /**
+     * Gets whether this [AnyValue] instance is holding a [Boolean] value.
+     */
+    external fun isBoolean(): Boolean
+
+    /**
+     * Gets whether this [AnyValue] instance is holding a [Long] value.
+     */
+    external fun isBigInt(): Boolean
+
+    /**
+     * Gets whether this [AnyValue] instance is holding a [String] value.
+     */
+    external fun isString(): Boolean
+
+    /**
+     * Gets whether this [AnyValue] instance is holding an [AnyArray] value.
+     */
+    external fun isAnyArray(): Boolean
+
+    /**
+     * Gets whether this [AnyValue] instance is holding an [AnyObject] value.
+     */
+    external fun isAnyObject(): Boolean
+
+    /**
+     * Get the [Double] value this [AnyValue] is holding.
+     * @throws Error if this [AnyValue] is not holding a [Double] (see [isDouble]`()`)
+     */
+    external fun asDouble(): Double
+
+    /**
+     * Get the [Boolean] value this [AnyValue] is holding.
+     * @throws Error if this [AnyValue] is not holding a [Boolean] (see [isBoolean]`()`)
+     */
+    external fun asBoolean(): Boolean
+
+    /**
+     * Get the [Long] value this [AnyValue] is holding.
+     * @throws Error if this [AnyValue] is not holding a [Long] (see [isLong]`()`)
+     */
+    external fun asBigInt(): Long
+
+    /**
+     * Get the [String] value this [AnyValue] is holding.
+     * @throws Error if this [AnyValue] is not holding a [String] (see [isString]`()`)
+     */
+    external fun asString(): String
+
+    /**
+     * Get the [AnyArray] value this [AnyValue] is holding.
+     * @throws Error if this [AnyValue] is not holding an [AnyArray] (see [isAnyArray]`()`)
+     */
+    external fun asAnyArray(): AnyArray
+
+    /**
+     * Get the [AnyObject] value this [AnyValue] is holding.
+     * @throws Error if this [AnyValue] is not holding an [AnyObject] (see [isAnyObject]`()`)
+     */
+    external fun asAnyObject(): AnyObject
+
+    private external fun initHybrid(): HybridData
+    private external fun initHybrid(value: Double): HybridData
+    private external fun initHybrid(value: Boolean): HybridData
+    private external fun initHybrid(value: Long): HybridData
+    private external fun initHybrid(value: String): HybridData
+    private external fun initHybrid(value: AnyArray): HybridData
+    private external fun initHybrid(value: AnyObject): HybridData
+}

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

@@ -0,0 +1,84 @@
+package com.margelo.nitro.core
+
+import androidx.annotation.Keep
+import com.facebook.jni.HybridData
+import com.facebook.proguard.annotations.DoNotStrip
+import java.nio.ByteBuffer
+
+/**
+ * An ArrayBuffer instance shared between native (Kotlin/C++) and JS.
+ *
+ * A `ByteBuffer` will be used as the underlying `ArrayBuffer`'s data,
+ * which has to remain valid for as long as the `ArrayBuffer` is alive.
+ */
+@Suppress("KotlinJniMissingFunction")
+@Keep
+@DoNotStrip
+class ArrayBuffer {
+    /**
+     * Holds the native C++ instance of the `ArrayBuffer`.
+     */
+    private val mHybridData: HybridData
+
+    /**
+     * Whether this `ArrayBuffer` is an **owning-**, or a **non-owning-** `ArrayBuffer`.
+     * - **Owning** ArrayBuffers can safely be held in memory for longer, and accessed at any point.
+     * - **Non-owning** ArrayBuffers can not be held in memory for longer, and can only be safely
+     * accessed within the synchronous function's scope (aka on the JS Thread). Once you switch Threads,
+     * data access is not safe anymore. If you need to access data longer, copy the data.
+     */
+    val isOwner: Boolean
+        get() = getIsOwner()
+
+    /**
+     * Whether this `ArrayBuffer` is holding a `ByteBuffer`, or not.
+     * - If the `ArrayBuffer` holds a `ByteBuffer`, `getBuffer(false)` can safely be called to
+     * get shared access to the underlying data, without performing any copies.
+     * - If the `ArrayBuffer` doesn't hold a `ByteBuffer`, it can still be accessed via `getBuffer(false)`,
+     * but the returned `ByteBuffer` is only valid as long as it's parent `ArrayBuffer` is alive.
+     */
+    val isByteBuffer: Boolean
+        get() = getIsByteBuffer()
+
+    /**
+     * Get a `ByteBuffer` that holds- or wraps- the underlying data.
+     * - If this `ArrayBuffer` has been created from Kotlin/Java, it is already holding a
+     * `ByteBuffer` (`isByteBuffer == true`). In this case, the returned buffer is safe to access,
+     * even after the `ArrayBuffer` has already been destroyed in JS.
+     * - If this `ArrayBuffer` has been created elsewhere (C++/JS), it is not holding a
+     * `ByteBuffer` (`isByteBuffer == false`). In this case, the returned buffer will either be a copy
+     * of the data (`copyIfNeeded == true`), or just wrapping the data (`copyIfNeeded == false`).
+     *
+     * @param copyIfNeeded If this `ArrayBuffer` is not holding a `ByteBuffer` (`isByteBuffer == false`),
+     * the foreign data needs to be either _wrapped_, or _copied_ to be represented as a `ByteBuffer`.
+     * This flag controls that behaviour.
+     */
+    fun getBuffer(copyIfNeeded: Boolean): ByteBuffer {
+        return getByteBuffer(copyIfNeeded)
+    }
+
+    /**
+     * 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) {
+        if (!byteBuffer.isDirect) {
+            throw Error("ArrayBuffers can only be created from direct ByteBuffers, " +
+                    "and the given ByteBuffer is not direct!")
+        }
+        mHybridData = initHybrid(byteBuffer)
+    }
+
+    /**
+     * Create a new **non-owning-** `ArrayBuffer` that holds foreign data, potentially coming from JS.
+     */
+    @Suppress("unused")
+    private constructor(hybridData: HybridData) {
+        mHybridData = hybridData
+    }
+
+    private external fun getByteBuffer(copyIfNeeded: Boolean): ByteBuffer
+    private external fun getIsOwner(): Boolean
+    private external fun getIsByteBuffer(): Boolean
+    private external fun initHybrid(buffer: ByteBuffer): HybridData
+}