react-native-nitro-modules 0.30.0 → 0.30.2

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

@@ -1,8 +1,8 @@
 package com.margelo.nitro.core
 
-import androidx.annotation.Keep
 import android.hardware.HardwareBuffer
 import android.os.Build
+import androidx.annotation.Keep
 import androidx.annotation.RequiresApi
 import com.facebook.jni.HybridData
 import com.facebook.proguard.annotations.DoNotStrip
@@ -23,185 +23,193 @@ typealias BoxedHardwareBuffer = Any
 @Keep
 @DoNotStrip
 class ArrayBuffer {
-    /**
-     * Holds the native C++ instance of the `ArrayBuffer`.
-     */
-    private val mHybridData: HybridData
+  /**
+   * 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()
+
+  /**
+   * 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`.
+   */
+  val size: Int
+    get() = getBufferSize()
+
+  /**
+   * 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)
+  }
+
+  /**
+   * 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.
+   */
+  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 **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)
+  }
 
-    /**
-     * 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()
+  /**
+   * Create a new **non-owning-** `ArrayBuffer` that holds foreign data, potentially coming from JS.
+   */
+  @Suppress("unused")
+  @Keep
+  @DoNotStrip
+  private constructor(hybridData: HybridData) {
+    mHybridData = hybridData
+  }
 
-    /**
-     * 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()
+  private external fun initHybrid(buffer: ByteBuffer): HybridData
 
-    /**
-     * 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()
+  @RequiresApi(Build.VERSION_CODES.O)
+  private external fun initHybridBoxedHardwareBuffer(hardwareBufferBoxed: BoxedHardwareBuffer): HybridData
 
-    /**
-     * Get the size of bytes in this `ArrayBuffer`.
-     */
-    val size: Int
-        get() = getBufferSize()
+  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 {
     /**
-     * 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.
+     * Allocate a new `ArrayBuffer` with the given [size].
      */
-    fun getBuffer(copyIfNeeded: Boolean): ByteBuffer {
-        return getByteBuffer(copyIfNeeded)
+    fun allocate(size: Int): ArrayBuffer {
+      val buffer = ByteBuffer.allocateDirect(size)
+      return ArrayBuffer(buffer)
     }
 
     /**
-     * Get the underlying `HardwareBuffer` if this `ArrayBuffer` was created with one.
-     * @throws Error if this `ArrayBuffer` was not created with a `HardwareBuffer`.
+     * Copy the given `ArrayBuffer` into a new **owning** `ArrayBuffer`.
      */
-    @RequiresApi(Build.VERSION_CODES.O)
-    fun getHardwareBuffer(): HardwareBuffer {
-        val boxed = getHardwareBufferBoxed()
-        return boxed as HardwareBuffer
+    fun copy(other: ArrayBuffer): ArrayBuffer {
+      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)
+      }
     }
 
     /**
-     * Create a new **owning-** `ArrayBuffer` that holds the given `ByteBuffer`.
-     * The `ByteBuffer` needs to remain valid for as long as the `ArrayBuffer` is alive.
+     * Copy the given `ByteBuffer` into a new **owning** `ArrayBuffer`.
      */
-    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)
+    fun copy(byteBuffer: ByteBuffer): ArrayBuffer {
+      // 1. Find out size
+      byteBuffer.rewind()
+      val size = byteBuffer.remaining()
+      // 2. Create a new buffer with the same size as the other
+      val newBuffer = ByteBuffer.allocateDirect(size)
+      // 3. Copy over the source buffer into the new buffer
+      newBuffer.put(byteBuffer)
+      // 4. Rewind both buffers again to index 0
+      newBuffer.rewind()
+      byteBuffer.rewind()
+      // 5. Create a new `ArrayBuffer`
+      return ArrayBuffer(newBuffer)
     }
 
     /**
-     * Create a new **owning-** `ArrayBuffer` that holds the given `HardwareBuffer`.
-     * The `HardwareBuffer` needs to remain valid for as long as the `ArrayBuffer` is alive.
+     * Copy the given `HardwareBuffer` into a new **owning** `ArrayBuffer`.
      */
     @RequiresApi(Build.VERSION_CODES.O)
-    constructor(hardwareBuffer: HardwareBuffer) {
-        if (hardwareBuffer.isClosed) {
-            throw Error("Cannot create ArrayBuffer from an already-closed HardwareBuffer!")
-        }
-        mHybridData = initHybridBoxedHardwareBuffer(hardwareBuffer)
+    fun copy(hardwareBuffer: HardwareBuffer): ArrayBuffer {
+      val copy = HardwareBufferUtils.copyHardwareBuffer(hardwareBuffer)
+      return ArrayBuffer(copy)
     }
 
     /**
-     * Create a new **non-owning-** `ArrayBuffer` that holds foreign data, potentially coming from JS.
+     * Wrap the given `ByteBuffer` in a new **owning** `ArrayBuffer`.
      */
-    @Suppress("unused")
-    @Keep
-    @DoNotStrip
-    private constructor(hybridData: HybridData) {
-        mHybridData = hybridData
+    fun wrap(byteBuffer: ByteBuffer): ArrayBuffer {
+      byteBuffer.rewind()
+      return ArrayBuffer(byteBuffer)
     }
 
-    private external fun initHybrid(buffer: ByteBuffer): HybridData
+    /**
+     * Wrap the given `HardwareBuffer` in a new **owning** `ArrayBuffer`.
+     */
     @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 {
-        /**
-         * Allocate a new `ArrayBuffer` with the given [size].
-         */
-        fun allocate(size: Int): ArrayBuffer {
-            val buffer = ByteBuffer.allocateDirect(size)
-            return ArrayBuffer(buffer)
-        }
-
-        /**
-         * Copy the given `ArrayBuffer` into a new **owning** `ArrayBuffer`.
-         */
-        fun copy(other: ArrayBuffer): ArrayBuffer {
-            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)
-            }
-        }
-
-        /**
-         * Copy the given `ByteBuffer` into a new **owning** `ArrayBuffer`.
-         */
-        fun copy(byteBuffer: ByteBuffer): ArrayBuffer {
-            // 1. Find out size
-            byteBuffer.rewind()
-            val size = byteBuffer.remaining()
-            // 2. Create a new buffer with the same size as the other
-            val newBuffer = ByteBuffer.allocateDirect(size)
-            // 3. Copy over the source buffer into the new buffer
-            newBuffer.put(byteBuffer)
-            // 4. Rewind both buffers again to index 0
-            newBuffer.rewind()
-            byteBuffer.rewind()
-            // 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`.
-         */
-        fun wrap(byteBuffer: ByteBuffer): 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)
-        }
+    fun wrap(hardwareBuffer: HardwareBuffer): ArrayBuffer {
+      return ArrayBuffer(hardwareBuffer)
     }
+  }
 }

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

@@ -10,58 +10,58 @@ import com.facebook.proguard.annotations.DoNotStrip
 @Keep
 @DoNotStrip
 abstract class HybridObject {
-    /**
-     * Get the memory size of the Kotlin instance (plus any external heap allocations),
-     * in bytes.
-     *
-     * Override this to allow tracking heap allocations such as buffers or images,
-     * which will help the JS GC be more efficient in deleting large unused objects.
-     *
-     * @example
-     * ```kotlin
-     * override val memorySize: ULong
-     *   get() {
-     *     val imageSize = this.bitmap.bytesPerRow * this.bitmap.height
-     *     return imageSize
-     *   }
-     * ```
-     */
-    @get:DoNotStrip
-    @get:Keep
-    open val memorySize: Long
-        get() = 0L
+  /**
+   * Get the memory size of the Kotlin instance (plus any external heap allocations),
+   * in bytes.
+   *
+   * Override this to allow tracking heap allocations such as buffers or images,
+   * which will help the JS GC be more efficient in deleting large unused objects.
+   *
+   * @example
+   * ```kotlin
+   * override val memorySize: ULong
+   *   get() {
+   *     val imageSize = this.bitmap.bytesPerRow * this.bitmap.height
+   *     return imageSize
+   *   }
+   * ```
+   */
+  @get:DoNotStrip
+  @get:Keep
+  open val memorySize: Long
+    get() = 0L
 
-    /**
-     * Eagerly- (and manually-) dispose all native resources this `HybridObject` holds.
-     * This method can only be manually called from JS using `dispose()`.
-     *
-     * If this method is never manually called, a `HybridObject` is expected to disposes it's
-     * resources as usual via the object's destructor (`~HybridObject()`, `deinit` or `finalize()`).
-     *
-     * By default, this method does nothing. It can be overridden to perform actual disposing/cleanup
-     * if required.
-     * This method must not throw.
-     */
-    @DoNotStrip
-    @Keep
-    open fun dispose() { }
+  /**
+   * Eagerly- (and manually-) dispose all native resources this `HybridObject` holds.
+   * This method can only be manually called from JS using `dispose()`.
+   *
+   * If this method is never manually called, a `HybridObject` is expected to disposes it's
+   * resources as usual via the object's destructor (`~HybridObject()`, `deinit` or `finalize()`).
+   *
+   * By default, this method does nothing. It can be overridden to perform actual disposing/cleanup
+   * if required.
+   * This method must not throw.
+   */
+  @DoNotStrip
+  @Keep
+  open fun dispose() { }
 
-    /**
-     * Holds the native C++ instance.
-     * In `HybridObject`, the C++ instance is a sub-class of `JHybridObject`, such as one of it's specs.
-     * This is `null`, until `updateNative(..)` is called.
-     */
-    private var mHybridData: HybridData? = null
+  /**
+   * Holds the native C++ instance.
+   * In `HybridObject`, the C++ instance is a sub-class of `JHybridObject`, such as one of it's specs.
+   * This is `null`, until `updateNative(..)` is called.
+   */
+  private var mHybridData: HybridData? = null
 
-    /**
-     * If `HybridObject` is subclassed, the sub-class needs to create it's own `HybridData`
-     * with a C++ `jni::HybridClass` representing the subclass directly.
-     * Then, that `HybridData` must be passed upwards to `HybridObject` using `updateNative(..)`.
-     *
-     * This must happen for each sub/base class in the whole inheritance chain to ensure
-     * overrides and type-erasure works as expected.
-     */
-    protected open fun updateNative(hybridData: HybridData) {
-        mHybridData = hybridData
-    }
+  /**
+   * If `HybridObject` is subclassed, the sub-class needs to create it's own `HybridData`
+   * with a C++ `jni::HybridClass` representing the subclass directly.
+   * Then, that `HybridData` must be passed upwards to `HybridObject` using `updateNative(..)`.
+   *
+   * This must happen for each sub/base class in the whole inheritance chain to ensure
+   * overrides and type-erasure works as expected.
+   */
+  protected open fun updateNative(hybridData: HybridData) {
+    mHybridData = hybridData
+  }
 }

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

@@ -96,9 +96,13 @@ class Promise<T> {
 
   // C++ functions
   private external fun nativeResolve(result: Any)
+
   private external fun nativeReject(error: Throwable)
+
   private external fun addOnResolvedListener(callback: OnResolvedCallback)
+
   private external fun addOnRejectedListener(callback: OnRejectedCallback)
+
   private external fun initHybrid(): HybridData
 
   // Nested callbacks - need to be JavaClasses so we can access them with JNI
@@ -110,6 +114,7 @@ class Promise<T> {
     @DoNotStrip
     fun onResolved(result: Any)
   }
+
   @Keep
   @DoNotStrip
   private fun interface OnRejectedCallback {
@@ -131,7 +136,10 @@ class Promise<T> {
      * When the suspending function returns, the Promise gets resolved. If the suspending
      * function throws, the Promise gets rejected.
      */
-    fun <T> async(scope: CoroutineScope = defaultScope, run: suspend () -> T): Promise<T> {
+    fun <T> async(
+      scope: CoroutineScope = defaultScope,
+      run: suspend () -> T,
+    ): Promise<T> {
       val promise = Promise<T>()
       scope.launch {
         try {

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

@@ -10,6 +10,5 @@ import androidx.annotation.RequiresApi
  */
 @RequiresApi(Build.VERSION_CODES.O)
 fun HardwareBuffer.updateFrom(hardwareBuffer: HardwareBuffer) {
-    HardwareBufferUtils.copyHardwareBuffer(hardwareBuffer, this)
+  HardwareBufferUtils.copyHardwareBuffer(hardwareBuffer, this)
 }
-

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

@@ -1,10 +1,10 @@
 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.Keep
 import androidx.annotation.RequiresApi
+import com.facebook.proguard.annotations.DoNotStrip
 
 /**
  * HardwareBuffers are special types in JNI (`AHardwareBuffer*`)
@@ -16,31 +16,38 @@ typealias BoxedHardwareBuffer = Any
 @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)
+  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 [[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)
-        }
+    /**
+     * 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/android/src/main/java/com/margelo/nitro/views/HybridView.kt

@@ -11,24 +11,25 @@ import com.margelo.nitro.core.HybridObject
  */
 @Keep
 @DoNotStrip
-abstract class HybridView: HybridObject() {
-    /**
-     * Get the `UIView` this HybridView is holding.
-     *
-     * This value should not change during the lifetime of this `HybridView`.
-     */
-    @get:DoNotStrip
-    @get:Keep
-    abstract val view: View
+abstract class HybridView : HybridObject() {
+  /**
+   * Get the `UIView` this HybridView is holding.
+   *
+   * This value should not change during the lifetime of this `HybridView`.
+   */
+  @get:DoNotStrip
+  @get:Keep
+  abstract val view: View
 
-    /**
-     * Called right before updating props.
-     * React props are updated in a single batch/transaction.
-     */
-    open fun beforeUpdate() { /* noop */ }
-    /**
-     * Called right after updating props.
-     * React props are updated in a single batch/transaction.
-     */
-    open fun afterUpdate() { /* noop */ }
+  /**
+   * Called right before updating props.
+   * React props are updated in a single batch/transaction.
+   */
+  open fun beforeUpdate() { /* noop */ }
+
+  /**
+   * Called right after updating props.
+   * React props are updated in a single batch/transaction.
+   */
+  open fun afterUpdate() { /* noop */ }
 }