Bumps and fixes for react native version bump

Reviewed-on: #8

package/.envrc

@@ -1,5 +0,0 @@
-use flake . --impure
-
-if [ -f .envrc.local ]; then
-    source .envrc.local
-fi

package/android/CMakeLists.txt

@@ -63,7 +63,7 @@ target_link_libraries(
         ${LOG_LIB}                          # <-- Logcat logger
         android                             # <-- Android JNI core
         ReactAndroid::jsi                   # <-- RN: JSI
-        ReactAndroid::reactnativejni        # <-- RN: React Native JNI bindings
+        # ReactAndroid::reactnativejni      # <-- Temporarily disabled for RN 0.79+ compatibility
         fbjni::fbjni                        # <-- fbjni
         GLESv2                              # <-- OpenGL (for VideoPipeline)
         EGL                                 # <-- OpenGL (EGL) (for VideoPipeline)

package/android/src/main/java/com/mrousavy/camera/CameraView+TakePhoto.kt

@@ -13,69 +13,36 @@ import com.facebook.react.bridge.ReadableMap
 import com.facebook.react.bridge.WritableMap
 import com.mrousavy.camera.core.CameraSession
 import com.mrousavy.camera.core.InsufficientStorageError
+import com.mrousavy.camera.utils.FileUtils
 import com.mrousavy.camera.types.Flash
-import com.mrousavy.camera.types.QualityPrioritization
 import com.mrousavy.camera.utils.*
 import java.io.File
 import java.io.FileOutputStream
 import java.io.IOException
 import kotlinx.coroutines.*
 
-private const val TAG = "CameraView.takePhoto"
+private const val TAG = "CameraView.takeSnapshot"
 
 @SuppressLint("UnsafeOptInUsageError")
 suspend fun CameraView.takePhoto(optionsMap: ReadableMap): WritableMap {
   val options = optionsMap.toHashMap()
-  Log.i(TAG, "Taking photo... Options: $options")
+  Log.i(TAG, "Taking snapshot... Options: $options")
+  val bitmap = previewView.getBitmap() ?: throw Error()
 
-  val qualityPrioritization = options["qualityPrioritization"] as? String ?: "balanced"
+  val file = FileUtils.createTempFile(context, "png");
-  val flash = options["flash"] as? String ?: "off"
-  val enableAutoStabilization = options["enableAutoStabilization"] == true
-  val enableShutterSound = options["enableShutterSound"] as? Boolean ?: true
-  val enablePrecapture = options["enablePrecapture"] as? Boolean ?: false
 
-  // TODO: Implement Red Eye Reduction
+  // Write snapshot to .jpg file
-  options["enableAutoRedEyeReduction"]
+  FileUtils.writeBitmapTofile(bitmap, file, 100)
 
-  val flashMode = Flash.fromUnionValue(flash)
+  Log.i(TAG, "Successfully saved snapshot to file!")
-  val qualityPrioritizationMode = QualityPrioritization.fromUnionValue(qualityPrioritization)
 
-  val photo = cameraSession.takePhoto(
+  // Parse output data
-    qualityPrioritizationMode,
+  val map = Arguments.createMap()
-    flashMode,
+  map.putString("path", file.absolutePath)
-    enableShutterSound,
+  map.putInt("width", bitmap.width)
-    enableAutoStabilization,
+  map.putInt("height", bitmap.height)
-    enablePrecapture,
+  map.putBoolean("isMirrored", false)
-    orientation
+  return map
-  )
-
-  photo.use {
-    Log.i(TAG, "Successfully captured ${photo.image.width} x ${photo.image.height} photo!")
-
-    val cameraCharacteristics = cameraManager.getCameraCharacteristics(cameraId!!)
-
-    val path = try {
-      savePhotoToFile(context, cameraCharacteristics, photo)
-    } catch (e: IOException) {
-      if (e.message?.contains("no space left", true) == true) {
-        throw InsufficientStorageError()
-      } else {
-        throw e
-      }
-    }
-
-    Log.i(TAG, "Successfully saved photo to file! $path")
-
-    val map = Arguments.createMap()
-    map.putString("path", path)
-    map.putInt("width", photo.image.width)
-    map.putInt("height", photo.image.height)
-    map.putString("orientation", photo.orientation.unionValue)
-    map.putBoolean("isRawPhoto", photo.format == ImageFormat.RAW_SENSOR)
-    map.putBoolean("isMirrored", photo.isMirrored)
-
-    return map
-  }
 }
 
 private fun writePhotoToFile(photo: CameraSession.CapturedPhoto, file: File) {

package/android/src/main/java/com/mrousavy/camera/CameraView.kt

@@ -72,6 +72,10 @@ class CameraView(context: Context) :
   var zoom: Float = 1f // in "factor"
   var exposure: Double = 1.0
   var orientation: Orientation = Orientation.PORTRAIT
+      set(value) {
+        field = value
+        previewView.orientation = value
+      }
   var enableZoomGesture = false
     set(value) {
       field = value
@@ -98,7 +102,7 @@ class CameraView(context: Context) :
 
   // session
   internal val cameraSession: CameraSession
-  private val previewView: PreviewView
+  val previewView: PreviewView
   private var currentConfigureCall: Long = System.currentTimeMillis()
   internal var frameProcessor: FrameProcessor? = null
 

package/android/src/main/java/com/mrousavy/camera/CameraViewManager.kt

@@ -10,6 +10,7 @@ import com.mrousavy.camera.types.CodeScannerOptions
 import com.mrousavy.camera.types.Orientation
 import com.mrousavy.camera.types.PixelFormat
 import com.mrousavy.camera.types.ResizeMode
+import android.util.Log
 import com.mrousavy.camera.types.Torch
 import com.mrousavy.camera.types.VideoStabilizationMode
 
@@ -182,6 +183,7 @@ class CameraViewManager : ViewGroupManager<CameraView>() {
   fun setOrientation(view: CameraView, orientation: String?) {
     if (orientation != null) {
       val newMode = Orientation.fromUnionValue(orientation)
+      Log.i(TAG, "Orientation set to: $newMode")
       view.orientation = newMode
     } else {
       view.orientation = Orientation.PORTRAIT

package/android/src/main/java/com/mrousavy/camera/core/CameraSession.kt

@@ -312,7 +312,7 @@ class CameraSession(private val context: Context, private val cameraManager: Cam
         enableHdr
       )
       outputs.add(output)
-      // Size is usually landscape, so we flip it here
+
       previewView?.setSurfaceSize(size.width, size.height, deviceDetails.sensorOrientation)
     }
 

package/android/src/main/java/com/mrousavy/camera/core/PreviewView.kt

@@ -2,9 +2,13 @@ package com.mrousavy.camera.core
 
 import android.annotation.SuppressLint
 import android.content.Context
+import android.content.res.Configuration
 import android.graphics.Point
+import android.os.Handler
+import android.os.Looper
 import android.util.Log
 import android.util.Size
+import android.view.PixelCopy
 import android.view.SurfaceHolder
 import android.view.SurfaceView
 import com.facebook.react.bridge.UiThreadUtil
@@ -12,9 +16,69 @@ import com.mrousavy.camera.extensions.resize
 import com.mrousavy.camera.extensions.rotatedBy
 import com.mrousavy.camera.types.Orientation
 import com.mrousavy.camera.types.ResizeMode
+import kotlin.coroutines.resume
+import kotlin.coroutines.resumeWithException
 import kotlin.math.roundToInt
 import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.suspendCancellableCoroutine
 import kotlinx.coroutines.withContext
+import android.graphics.Bitmap
+import android.graphics.Matrix
+
+fun rotateBitmap90CounterClockwise(source: Bitmap): Bitmap {
+    val width = source.width
+    val height = source.height
+
+    // Create a new Bitmap with swapped width and height
+    val rotatedBitmap = Bitmap.createBitmap(height, width, source.config ?: Bitmap.Config.ARGB_8888)
+
+    for (y in 0 until height) {
+        for (x in 0 until width) {
+            // Set the pixel in the new position
+            rotatedBitmap.setPixel(y, width - 1 - x, source.getPixel(x, y))
+        }
+    }
+
+    return rotatedBitmap
+}
+
+
+fun Bitmap.transformBitmap(orientation: Orientation): Bitmap {
+    return when (orientation) {
+        Orientation.PORTRAIT -> this // No transformation needed
+        Orientation.LANDSCAPE_LEFT -> {
+            // Transpose (swap width and height)
+            val transposedBitmap = Bitmap.createBitmap(height, width, config ?: Bitmap.Config.ARGB_8888)
+            for (y in 0 until height) {
+                for (x in 0 until width) {
+                    transposedBitmap.setPixel(y, width - 1 - x, getPixel(x, y))
+                }
+            }
+            transposedBitmap
+        }
+        Orientation.PORTRAIT_UPSIDE_DOWN -> {
+            // Invert vertically and horizontally (180-degree rotation)
+            val invertedBitmap = Bitmap.createBitmap(width, height, config ?: Bitmap.Config.ARGB_8888)
+            for (y in 0 until height) {
+                for (x in 0 until width) {
+                    invertedBitmap.setPixel(width - 1 - x, height - 1 - y, getPixel(x, y))
+                }
+            }
+            invertedBitmap
+        }
+        Orientation.LANDSCAPE_RIGHT -> {
+            // Transpose (swap width and height) and invert vertically
+            val transposedBitmap = Bitmap.createBitmap(height, width, config ?: Bitmap.Config.ARGB_8888)
+            for (y in 0 until height) {
+                for (x in 0 until width) {
+                    transposedBitmap.setPixel(height - 1 - y, x, getPixel(x, y))
+                }
+            }
+            transposedBitmap
+        }
+    }
+}
+
 
 @SuppressLint("ViewConstructor")
 class PreviewView(context: Context, callback: SurfaceHolder.Callback) :
@@ -36,6 +100,13 @@ class PreviewView(context: Context, callback: SurfaceHolder.Callback) :
         updateLayout()
       }
     }
+  var orientation: Orientation = Orientation.PORTRAIT
+      set(value) {
+        if (field != value) {
+          Log.i(TAG, "View Orientation changed: $field -> $value")
+          field = value
+        }
+      }
   private var inputOrientation: Orientation = Orientation.LANDSCAPE_LEFT
     set(value) {
       if (field != value) {
@@ -73,6 +144,34 @@ class PreviewView(context: Context, callback: SurfaceHolder.Callback) :
     }
   }
 
+  suspend fun getBitmap(): Bitmap? = withContext(Dispatchers.Main) {
+    val frame = holder.getSurfaceFrame()
+
+    val width = frame.width()
+    val height = frame.height()
+
+    val bitmap = Bitmap.createBitmap(height, width, Bitmap.Config.ARGB_8888)
+
+    // Use a coroutine to suspend until the PixelCopy request is complete
+    suspendCancellableCoroutine<Bitmap?> { continuation ->
+    PixelCopy.request(
+        holder.surface,
+        bitmap,
+        { copyResult ->
+          if (copyResult == PixelCopy.SUCCESS) {
+            continuation.resume(rotateBitmap90CounterClockwise(bitmap))
+          } else {
+            continuation.resumeWithException(
+                RuntimeException("PixelCopy failed with error code $copyResult")
+            )
+          }
+        },
+        Handler(Looper.getMainLooper())
+    )
+    }
+  }
+
+
   fun convertLayerPointToCameraCoordinates(point: Point, cameraDeviceDetails: CameraDeviceDetails): Point {
     val sensorOrientation = cameraDeviceDetails.sensorOrientation
     val cameraSize = Size(cameraDeviceDetails.activeSize.width(), cameraDeviceDetails.activeSize.height())
@@ -90,17 +189,14 @@ class PreviewView(context: Context, callback: SurfaceHolder.Callback) :
     }
   }
 
-  override fun requestLayout() {
-    super.requestLayout()
-    // Manually trigger measure & layout, as RN on Android skips those.
-    // See this issue: https://github.com/facebook/react-native/issues/17968#issuecomment-721958427
-    post {
-      measure(MeasureSpec.makeMeasureSpec(width, MeasureSpec.EXACTLY), MeasureSpec.makeMeasureSpec(height, MeasureSpec.EXACTLY))
-      layout(left, top, right, bottom)
-    }
-  }
-
   private fun getSize(contentSize: Size, containerSize: Size, resizeMode: ResizeMode): Size {
+    var contentSize = contentSize
+    var androidOrientation = context.getResources().getConfiguration().orientation;
+
+    if (androidOrientation == Configuration.ORIENTATION_LANDSCAPE) {
+      contentSize = Size(contentSize.height, contentSize.width)
+    }
+
     val contentAspectRatio = contentSize.width.toDouble() / contentSize.height
     val containerAspectRatio = containerSize.width.toDouble() / containerSize.height
     if (!(contentAspectRatio > 0 && containerAspectRatio > 0)) {
@@ -128,11 +224,11 @@ class PreviewView(context: Context, callback: SurfaceHolder.Callback) :
   override fun onMeasure(widthMeasureSpec: Int, heightMeasureSpec: Int) {
     super.onMeasure(widthMeasureSpec, heightMeasureSpec)
 
-    val viewSize = Size(MeasureSpec.getSize(widthMeasureSpec), MeasureSpec.getSize(heightMeasureSpec))
+    val measuredViewSize = Size(MeasureSpec.getSize(widthMeasureSpec), MeasureSpec.getSize(heightMeasureSpec))
     val surfaceSize = size.rotatedBy(inputOrientation)
-    val fittedSize = getSize(surfaceSize, viewSize, resizeMode)
+    val fittedSize = getSize(surfaceSize, measuredViewSize, resizeMode)
 
-    Log.i(TAG, "PreviewView is $viewSize, rendering $surfaceSize content ($inputOrientation). Resizing to: $fittedSize ($resizeMode)")
+    Log.i(TAG, "PreviewView is $measuredViewSize rendering $surfaceSize orientation ($orientation). Resizing to: $fittedSize ($resizeMode)")
     setMeasuredDimension(fittedSize.width, fittedSize.height)
   }
 

package/android/src/main/java/com/mrousavy/camera/frameprocessor/VisionCameraProxy.kt

@@ -1,3 +1,5 @@
+@file:Suppress("DEPRECATION")
+
 package com.mrousavy.camera.frameprocessor
 
 import android.util.Log
@@ -7,7 +9,7 @@ import com.facebook.jni.HybridData
 import com.facebook.proguard.annotations.DoNotStrip
 import com.facebook.react.bridge.ReactApplicationContext
 import com.facebook.react.bridge.UiThreadUtil
-import com.facebook.react.turbomodule.core.CallInvokerHolderImpl
+// import com.facebook.react.turbomodule.core.CallInvokerHolderImpl // Commented out due to RN 0.79+ compatibility
 import com.facebook.react.uimanager.UIManagerHelper
 import com.mrousavy.camera.CameraView
 import com.mrousavy.camera.core.ViewNotFoundError
@@ -21,19 +23,26 @@ class VisionCameraProxy(private val reactContext: ReactApplicationContext) {
 
   @DoNotStrip
   @Keep
-  private var mHybridData: HybridData
+  private var mHybridData: HybridData?
   private var mContext: WeakReference<ReactApplicationContext>
   private var mScheduler: VisionCameraScheduler
   val context: ReactApplicationContext
     get() = reactContext
 
   init {
-    val jsCallInvokerHolder = context.catalystInstance.jsCallInvokerHolder as CallInvokerHolderImpl
+    // TODO: Fix for React Native 0.79+ - these APIs are now framework-only
-    val jsRuntimeHolder =
+    // Since Frame Processors are disabled anyway (react-native-worklets-core not found),
-      context.javaScriptContextHolder?.get() ?: throw Error("JSI Runtime is null! VisionCamera does not yet support bridgeless mode..")
+    // we'll disable this functionality to allow the build to complete
+    Log.w(TAG, "Frame Processor initialization disabled due to React Native 0.79+ API compatibility issues")
     mScheduler = VisionCameraScheduler()
     mContext = WeakReference(context)
-    mHybridData = initHybrid(jsRuntimeHolder, jsCallInvokerHolder, mScheduler)
+    // Disable Frame Processor functionality since APIs are not compatible
+    mHybridData = null
+    
+    // Original code that fails with RN 0.79+:
+    // val jsCallInvokerHolder = context.catalystInstance.jsCallInvokerHolder as CallInvokerHolderImpl
+    // val jsRuntimeHolder = context.javaScriptContextHolder?.get() ?: throw Error("JSI Runtime is null!")
+    // mHybridData = initHybrid(jsRuntimeHolder, jsCallInvokerHolder, mScheduler)
   }
 
   @UiThread
@@ -69,5 +78,6 @@ class VisionCameraProxy(private val reactContext: ReactApplicationContext) {
     FrameProcessorPluginRegistry.getPlugin(name, this, options)
 
   // private C++ funcs
-  private external fun initHybrid(jsContext: Long, jsCallInvokerHolder: CallInvokerHolderImpl, scheduler: VisionCameraScheduler): HybridData
+  // Commented out due to React Native 0.79+ API compatibility issues
+  // private external fun initHybrid(jsContext: Long, jsCallInvokerHolder: CallInvokerHolderImpl, scheduler: VisionCameraScheduler): HybridData
 }

package/android/src/main/java/com/mrousavy/camera/utils/FileUtils.kt

@@ -1,13 +1,33 @@
 package com.mrousavy.camera.utils
 
 import android.content.Context
+import android.graphics.Bitmap
+import android.graphics.BitmapFactory
+import android.util.Size
 import java.io.File
+import java.io.FileOutputStream
 
 class FileUtils {
   companion object {
-    fun createTempFile(context: Context, extension: String): File =
+    fun writeBitmapTofile(bitmap: Bitmap, file: File, quality: Int) {
-      File.createTempFile("mrousavy", extension, context.cacheDir).also {
+      FileOutputStream(file).use { stream ->
-        it.deleteOnExit()
+        bitmap.compress(Bitmap.CompressFormat.JPEG, 50, stream)
       }
+    }
+
+    fun getImageSize(imagePath: String): Size {
+      val bitmapOptions = BitmapFactory.Options().also {
+        it.inJustDecodeBounds = true
+      }
+      BitmapFactory.decodeFile(imagePath, bitmapOptions)
+      val width = bitmapOptions.outWidth
+      val height = bitmapOptions.outHeight
+      return Size(width, height)
+    }
+
+    fun createTempFile(context: Context, extension: String): File =
+        File.createTempFile("mrousavy", extension, context.cacheDir).also {
+      it.deleteOnExit()
+    }
   }
 }

package/example/package.json

@@ -17,8 +17,8 @@
     "@react-native-community/blur": "^4.3.2",
     "@react-navigation/native": "^6.1.7",
     "@react-navigation/native-stack": "^6.9.13",
-    "react": "^18.2.0",
+    "react": "^19.1.1",
-    "react-native": "^0.72.3",
+    "react-native": "^0.81.0",
     "react-native-fast-image": "^8.6.3",
     "react-native-gesture-handler": "^2.12.1",
     "react-native-mmkv": "^2.10.2",
@@ -42,7 +42,7 @@
     "@types/react-native-vector-icons": "^6.4.13",
     "@types/react-native-video": "^5.0.15",
     "babel-plugin-module-resolver": "^5.0.0",
-    "eslint": "^8.46.0",
+    "eslint": "^9.33.0",
     "eslint-plugin-prettier": "^5.0.0",
     "metro-react-native-babel-preset": "^0.77.0",
     "prettier": "^3.2.4",

package/example/src/capture-button.tsx

@@ -47,7 +47,7 @@ export const RecordingButton: React.FC<RecordingButtonProps> = ({ style, camera,
           onMediaCaptured(video, 'video')
           onStoppedRecording()
         },
-      })
+      }, 'video.mp4')
       console.log('called startRecording()!')
       isRecording.current = true
       setRecordingState(true)
@@ -93,4 +93,4 @@ const styles = StyleSheet.create({
   },
 })
 
-export default RecordingButton
+export default RecordingButton

package/flake.lock

@@ -1,189 +0,0 @@
-{
-  "nodes": {
-    "android-nixpkgs": {
-      "inputs": {
-        "devshell": "devshell",
-        "flake-utils": "flake-utils",
-        "nixpkgs": "nixpkgs"
-      },
-      "locked": {
-        "lastModified": 1701980274,
-        "narHash": "sha256-uKJIFvsahbWw52TsIht7g2iosXBgJDRMSMoCE1fvEAk=",
-        "owner": "tadfisher",
-        "repo": "android-nixpkgs",
-        "rev": "bce9d437ed54ee1425b66442a12814fee4cdbd51",
-        "type": "github"
-      },
-      "original": {
-        "owner": "tadfisher",
-        "repo": "android-nixpkgs",
-        "type": "github"
-      }
-    },
-    "devshell": {
-      "inputs": {
-        "nixpkgs": [
-          "android-nixpkgs",
-          "nixpkgs"
-        ],
-        "systems": "systems"
-      },
-      "locked": {
-        "lastModified": 1701787589,
-        "narHash": "sha256-ce+oQR4Zq9VOsLoh9bZT8Ip9PaMLcjjBUHVPzW5d7Cw=",
-        "owner": "numtide",
-        "repo": "devshell",
-        "rev": "44ddedcbcfc2d52a76b64fb6122f209881bd3e1e",
-        "type": "github"
-      },
-      "original": {
-        "owner": "numtide",
-        "repo": "devshell",
-        "type": "github"
-      }
-    },
-    "flake-utils": {
-      "inputs": {
-        "systems": "systems_2"
-      },
-      "locked": {
-        "lastModified": 1701680307,
-        "narHash": "sha256-kAuep2h5ajznlPMD9rnQyffWG8EM/C73lejGofXvdM8=",
-        "owner": "numtide",
-        "repo": "flake-utils",
-        "rev": "4022d587cbbfd70fe950c1e2083a02621806a725",
-        "type": "github"
-      },
-      "original": {
-        "owner": "numtide",
-        "repo": "flake-utils",
-        "type": "github"
-      }
-    },
-    "flake-utils_2": {
-      "inputs": {
-        "systems": "systems_3"
-      },
-      "locked": {
-        "lastModified": 1701680307,
-        "narHash": "sha256-kAuep2h5ajznlPMD9rnQyffWG8EM/C73lejGofXvdM8=",
-        "owner": "numtide",
-        "repo": "flake-utils",
-        "rev": "4022d587cbbfd70fe950c1e2083a02621806a725",
-        "type": "github"
-      },
-      "original": {
-        "owner": "numtide",
-        "repo": "flake-utils",
-        "type": "github"
-      }
-    },
-    "gitignore": {
-      "inputs": {
-        "nixpkgs": [
-          "nixpkgs"
-        ]
-      },
-      "locked": {
-        "lastModified": 1694102001,
-        "narHash": "sha256-vky6VPK1n1od6vXbqzOXnekrQpTL4hbPAwUhT5J9c9E=",
-        "owner": "hercules-ci",
-        "repo": "gitignore.nix",
-        "rev": "9e21c80adf67ebcb077d75bd5e7d724d21eeafd6",
-        "type": "github"
-      },
-      "original": {
-        "owner": "hercules-ci",
-        "repo": "gitignore.nix",
-        "type": "github"
-      }
-    },
-    "nixpkgs": {
-      "locked": {
-        "lastModified": 1701718080,
-        "narHash": "sha256-6ovz0pG76dE0P170pmmZex1wWcQoeiomUZGggfH9XPs=",
-        "owner": "NixOS",
-        "repo": "nixpkgs",
-        "rev": "2c7f3c0fb7c08a0814627611d9d7d45ab6d75335",
-        "type": "github"
-      },
-      "original": {
-        "owner": "NixOS",
-        "ref": "nixos-unstable",
-        "repo": "nixpkgs",
-        "type": "github"
-      }
-    },
-    "nixpkgs_2": {
-      "locked": {
-        "lastModified": 1702312524,
-        "narHash": "sha256-gkZJRDBUCpTPBvQk25G0B7vfbpEYM5s5OZqghkjZsnE=",
-        "owner": "nixos",
-        "repo": "nixpkgs",
-        "rev": "a9bf124c46ef298113270b1f84a164865987a91c",
-        "type": "github"
-      },
-      "original": {
-        "owner": "nixos",
-        "ref": "nixos-unstable",
-        "repo": "nixpkgs",
-        "type": "github"
-      }
-    },
-    "root": {
-      "inputs": {
-        "android-nixpkgs": "android-nixpkgs",
-        "flake-utils": "flake-utils_2",
-        "gitignore": "gitignore",
-        "nixpkgs": "nixpkgs_2"
-      }
-    },
-    "systems": {
-      "locked": {
-        "lastModified": 1681028828,
-        "narHash": "sha256-Vy1rq5AaRuLzOxct8nz4T6wlgyUR7zLU309k9mBC768=",
-        "owner": "nix-systems",
-        "repo": "default",
-        "rev": "da67096a3b9bf56a91d16901293e51ba5b49a27e",
-        "type": "github"
-      },
-      "original": {
-        "owner": "nix-systems",
-        "repo": "default",
-        "type": "github"
-      }
-    },
-    "systems_2": {
-      "locked": {
-        "lastModified": 1681028828,
-        "narHash": "sha256-Vy1rq5AaRuLzOxct8nz4T6wlgyUR7zLU309k9mBC768=",
-        "owner": "nix-systems",
-        "repo": "default",
-        "rev": "da67096a3b9bf56a91d16901293e51ba5b49a27e",
-        "type": "github"
-      },
-      "original": {
-        "owner": "nix-systems",
-        "repo": "default",
-        "type": "github"
-      }
-    },
-    "systems_3": {
-      "locked": {
-        "lastModified": 1681028828,
-        "narHash": "sha256-Vy1rq5AaRuLzOxct8nz4T6wlgyUR7zLU309k9mBC768=",
-        "owner": "nix-systems",
-        "repo": "default",
-        "rev": "da67096a3b9bf56a91d16901293e51ba5b49a27e",
-        "type": "github"
-      },
-      "original": {
-        "owner": "nix-systems",
-        "repo": "default",
-        "type": "github"
-      }
-    }
-  },
-  "root": "root",
-  "version": 7
-}

package/flake.nix

@@ -1,77 +0,0 @@
-{
-  description = "Sample Nix ts-node build";
-  inputs = {
-    nixpkgs.url = "github:nixos/nixpkgs/nixos-unstable";
-    flake-utils.url = "github:numtide/flake-utils";
-    gitignore = {
-      url = "github:hercules-ci/gitignore.nix";
-      inputs.nixpkgs.follows = "nixpkgs";
-    };
-    android-nixpkgs = {
-      url = "github:tadfisher/android-nixpkgs";
-    };
-  };
-  outputs = {
-    self,
-    nixpkgs,
-    flake-utils,
-    gitignore,
-    android-nixpkgs,
-    ...
-  }:
-    flake-utils.lib.eachDefaultSystem (system: let
-      pkgs = import nixpkgs {inherit system;};
-      nodejs = pkgs.nodejs-18_x;
-      # NOTE: this does not work
-      appBuild = pkgs.stdenv.mkDerivation {
-        name = "example-ts-node";
-        version = "0.1.0";
-        src = gitignore.lib.gitignoreSource ./.; # uses the gitignore in the repo to only copy files git would see
-        buildInputs = [nodejs];
-        # https://nixos.org/manual/nixpkgs/stable/#sec-stdenv-phases
-        buildPhase = ''
-          # each phase has pre/postHooks. When you make your own phase be sure to still call the hooks
-          runHook preBuild
-          npm ci
-          npm run build
-          runHook postBuild
-        '';
-        installPhase = ''
-          runHook preInstall
-          cp -r node_modules $out/node_modules
-          cp package.json $out/package.json
-          cp -r dist $out/dist
-          runHook postInstall
-        '';
-      };
-      android-sdk = android-nixpkgs.sdk.${system} (sdkPkgs:
-        with sdkPkgs; [
-          cmdline-tools-latest
-          build-tools-30-0-3
-          build-tools-33-0-0
-          build-tools-33-0-1
-          build-tools-34-0-0
-          platform-tools
-          platforms-android-33
-          platforms-android-34
-          emulator
-          ndk-23-1-7779620
-          cmake-3-22-1
-          system-images-android-33-google-apis-x86-64
-          system-images-android-34-google-apis-x86-64
-        ]);
-    in
-      with pkgs; {
-        defaultPackage = appBuild;
-        devShell = mkShell {
-          buildInputs = [nodejs yarn watchman gradle_7 alejandra nodePackages.prettier ktlint kotlin-language-server];
-          ANDROID_SDK_BIN = android-sdk;
-          shellHook = ''
-            export JAVA_HOME=${pkgs.jdk17.home}
-            source ${android-sdk.out}/nix-support/setup-hook
-            export PATH=${android-sdk}/bin:$PATH
-            ORG_GRADLE_PROJECT_ANDROID_HOME="$ANDROID_HOME"
-          '';
-        };
-      });
-}

package/ios/CameraView+RecordVideo.swift

@@ -50,4 +50,12 @@ extension CameraView: AVCaptureVideoDataOutputSampleBufferDelegate, AVCaptureAud
   func resumeRecording(promise: Promise) {
     cameraSession.resumeRecording(promise: promise)
   }
+  
+  func lockExposure(promise: Promise) {
+    cameraSession.lockCurrentExposure(promise: promise)
+  }
+  
+  func unlockExposure(promise: Promise) {
+    cameraSession.unlockCurrentExposure(promise: promise)
+  }
 }

package/ios/CameraView.swift

@@ -303,6 +303,15 @@ public final class CameraView: UIView, CameraSessionDelegate {
     }
     onInitialized([:])
   }
+  
+  func onCameraConfigurationChanged(_ configuration: CameraConfiguration?, _ difference: CameraConfiguration.Difference?) {
+    guard let configuration, let difference else { return }
+    
+    if difference.orientationChanged, let connection = previewView.videoPreviewLayer.connection {
+      let videoPreviewLayer = previewView.videoPreviewLayer
+      connection.setOrientation(configuration.orientation)
+    }
+  }
 
   func onCameraStarted() {
     ReactLogger.log(level: .info, message: "Camera started!")

package/ios/CameraViewManager.m

@@ -86,5 +86,13 @@ RCT_EXTERN_METHOD(focus
                   : (NSDictionary*)point resolve
                   : (RCTPromiseResolveBlock)resolve reject
                   : (RCTPromiseRejectBlock)reject);
+RCT_EXTERN_METHOD(lockCurrentExposure
+                  : (nonnull NSNumber*)node resolve
+                  : (RCTPromiseResolveBlock)resolve reject
+                  : (RCTPromiseRejectBlock)reject);
+RCT_EXTERN_METHOD(unlockCurrentExposure
+                  : (nonnull NSNumber*)node resolve
+                  : (RCTPromiseResolveBlock)resolve reject
+                  : (RCTPromiseRejectBlock)reject);
 
 @end

package/ios/CameraViewManager.swift

@@ -110,6 +110,18 @@ final class CameraViewManager: RCTViewManager {
       resolve(result.descriptor)
     }
   }
+  
+  @objc
+  final func lockCurrentExposure(_ node: NSNumber, resolve: @escaping RCTPromiseResolveBlock, reject: @escaping RCTPromiseRejectBlock) {
+    let component = getCameraView(withTag: node)
+    component.lockExposure(promise: Promise(resolver: resolve, rejecter: reject))
+  }
+  
+  @objc
+  final func unlockCurrentExposure(_ node: NSNumber, resolve: @escaping RCTPromiseResolveBlock, reject: @escaping RCTPromiseRejectBlock) {
+    let component = getCameraView(withTag: node)
+    component.unlockExposure(promise: Promise(resolver: resolve, rejecter: reject))
+  }
 
   // MARK: Private
 

package/ios/Core/CameraSession+Video.swift

@@ -34,7 +34,7 @@ extension CameraSession {
       }
 
       let enableAudio = self.configuration?.audio != .disabled
-      
+
       // Callback for when new chunks are ready
       let onChunkReady: (ChunkedRecorder.Chunk) -> Void = { chunk in
         guard let delegate = self.delegate else {
@@ -191,4 +191,68 @@ extension CameraSession {
       }
     }
   }
+
+  func lockCurrentExposure(promise: Promise) {
+    CameraQueues.cameraQueue.async {
+      withPromise(promise) {
+        guard let captureDevice = AVCaptureDevice.default(for: .video) else {
+          print("No capture device available")
+          return
+        }
+
+        guard captureDevice.isExposureModeSupported(.custom) else {
+          ReactLogger.log(level: .info, message: "Custom exposure mode not supported")
+          return
+        }
+        do {
+          // Lock the device for configuration
+          try captureDevice.lockForConfiguration()
+
+          // Get the current exposure duration and ISO
+          let currentExposureDuration = captureDevice.exposureDuration
+          let currentISO = captureDevice.iso
+
+          // Check if the device supports custom exposure settings
+          if captureDevice.isExposureModeSupported(.custom) {
+            // Lock the current exposure and ISO by setting custom exposure mode
+            captureDevice.setExposureModeCustom(duration: currentExposureDuration, iso: currentISO, completionHandler: nil)
+            ReactLogger.log(level: .info, message: "Exposure and ISO locked at current values")
+          } else {
+            ReactLogger.log(level: .info, message:"Custom exposure mode not supported")
+          }
+
+          // Unlock the device after configuration
+          captureDevice.unlockForConfiguration()
+
+        } catch {
+          ReactLogger.log(level: .warning, message:"Error locking exposure: \(error)")
+        }
+
+        return nil
+      }
+    }
+  }
+
+  func unlockCurrentExposure(promise: Promise) {
+    CameraQueues.cameraQueue.async {
+      withPromise(promise) {
+        guard let captureDevice = AVCaptureDevice.default(for: .video) else {
+          print("No capture device available")
+          return
+        }
+
+        do {
+          if captureDevice.isExposureModeSupported(.autoExpose) {
+            try captureDevice.lockForConfiguration()
+            captureDevice.exposureMode = .continuousAutoExposure
+            captureDevice.unlockForConfiguration()
+          }
+        } catch {
+          ReactLogger.log(level: .warning, message:"Error unlocking exposure: \(error)")
+        }
+
+        return nil
+      }
+    }
+  }
 }

package/ios/Core/CameraSession.swift

@@ -195,6 +195,7 @@ class CameraSession: NSObject, AVCaptureVideoDataOutputSampleBufferDelegate, AVC
           self.delegate?.onSessionInitialized()
         }
 
+        self.delegate?.onCameraConfigurationChanged(config, difference)
         // After configuring, set this to the new configuration.
         self.configuration = config
       } catch {

package/ios/Core/CameraSessionDelegate.swift

@@ -21,6 +21,8 @@ protocol CameraSessionDelegate: AnyObject {
    Called when the [CameraSession] successfully initializes
    */
   func onSessionInitialized()
+  
+  func onCameraConfigurationChanged(_ configuration: CameraConfiguration?, _ difference: CameraConfiguration.Difference?)
   /**
    Called when the [CameraSession] starts streaming frames. (isActive=true)
    */

package/ios/Core/ChunkedRecorder.swift

@@ -11,7 +11,7 @@ import AVFoundation
 
 
 class ChunkedRecorder: NSObject {
-  
+
   enum ChunkType {
     case initialization
     case data(index: UInt64, duration: CMTime?)
@@ -21,12 +21,12 @@ class ChunkedRecorder: NSObject {
     let url: URL
     let type: ChunkType
   }
-  
+
   let outputURL: URL
   let onChunkReady: ((Chunk) -> Void)
-  
+
   private var chunkIndex: UInt64 = 0
-  
+
   init(outputURL: URL, onChunkReady: @escaping ((Chunk) -> Void)) throws {
     self.outputURL = outputURL
     self.onChunkReady = onChunkReady
@@ -34,16 +34,16 @@ class ChunkedRecorder: NSObject {
       throw CameraError.unknown(message: "output directory does not exist at: \(outputURL.path)", cause: nil)
     }
   }
-  
+
 }
 
 extension ChunkedRecorder: AVAssetWriterDelegate {
-  
+
-  func assetWriter(_ writer: AVAssetWriter, 
+  func assetWriter(_ writer: AVAssetWriter,
                    didOutputSegmentData segmentData: Data,
                    segmentType: AVAssetSegmentType,
                    segmentReport: AVAssetSegmentReport?) {
-    
+
     switch segmentType {
     case .initialization:
       saveInitSegment(segmentData)
@@ -53,13 +53,13 @@ extension ChunkedRecorder: AVAssetWriterDelegate {
       fatalError("Unknown AVAssetSegmentType!")
     }
   }
-  
+
   private func saveInitSegment(_ data: Data) {
     let url = outputURL.appendingPathComponent("init.mp4")
     save(data: data, url: url)
     onChunkReady(url: url, type: .initialization)
   }
-  
+
   private func saveSegment(_ data: Data, report: AVAssetSegmentReport?) {
     let name = "\(chunkIndex).mp4"
     let url = outputURL.appendingPathComponent(name)
@@ -72,7 +72,7 @@ extension ChunkedRecorder: AVAssetWriterDelegate {
     onChunkReady(url: url, type: .data(index: chunkIndex, duration: duration))
     chunkIndex += 1
   }
-  
+
   private func save(data: Data, url: URL) {
     do {
       try data.write(to: url)
@@ -80,9 +80,9 @@ extension ChunkedRecorder: AVAssetWriterDelegate {
       ReactLogger.log(level: .error, message: "Unable to write \(url): \(error.localizedDescription)")
     }
   }
-  
+
   private func onChunkReady(url: URL, type: ChunkType) {
     onChunkReady(Chunk(url: url, type: type))
   }
-  
+
 }

package/ios/Core/RecordingSession.swift

@@ -84,7 +84,7 @@ class RecordingSession {
       assetWriter.shouldOptimizeForNetworkUse = false
       assetWriter.outputFileTypeProfile = .mpeg4AppleHLS
       assetWriter.preferredOutputSegmentInterval = CMTime(seconds: 6, preferredTimescale: 1)
-      
+
       /*
         Apple HLS fMP4 does not have an Edit List Box ('elst') in an initialization segment to remove
         audio priming duration which advanced audio formats like AAC have, since the sample tables
@@ -95,7 +95,7 @@ class RecordingSession {
       */
       let startTimeOffset = CMTime(value: 10, timescale: 1)
       assetWriter.initialSegmentStartTime = startTimeOffset
-      
+
       assetWriter.delegate = recorder
     } catch let error as NSError {
       throw CameraError.capture(.createRecorderError(message: error.description))

package/ios/Extensions/AVCaptureOutput+mirror.swift

@@ -32,28 +32,36 @@ extension AVCaptureOutput {
   func setOrientation(_ orientation: Orientation) {
     // Set orientation for each connection
     for connection in connections {
-      #if swift(>=5.9)
+      connection.setOrientation(orientation)
-        if #available(iOS 17.0, *) {
-          // Camera Sensors are always in landscape rotation (90deg).
-          // We are setting the target rotation here, so we need to rotate by landscape once.
-          let cameraOrientation = orientation.rotateBy(orientation: .landscapeLeft)
-          let degrees = cameraOrientation.toDegrees()
-
-          // TODO: Don't rotate the video output because it adds overhead. Instead just use EXIF flags for the .mp4 file if recording.
-          //       Does that work when we flip the camera?
-          if connection.isVideoRotationAngleSupported(degrees) {
-            connection.videoRotationAngle = degrees
-          }
-        } else {
-          if connection.isVideoOrientationSupported {
-            connection.videoOrientation = orientation.toAVCaptureVideoOrientation()
-          }
-        }
-      #else
-        if connection.isVideoOrientationSupported {
-          connection.videoOrientation = orientation.toAVCaptureVideoOrientation()
-        }
-      #endif
     }
   }
 }
+
+
+
+extension AVCaptureConnection {
+  func setOrientation(_ orientation: Orientation) {
+    #if swift(>=5.9)
+      if #available(iOS 17.0, *) {
+        // Camera Sensors are always in landscape rotation (90deg).
+        // We are setting the target rotation here, so we need to rotate by landscape once.
+        let cameraOrientation = orientation.rotateBy(orientation: .landscapeLeft)
+        let degrees = cameraOrientation.toDegrees()
+
+        // TODO: Don't rotate the video output because it adds overhead. Instead just use EXIF flags for the .mp4 file if recording.
+        //       Does that work when we flip the camera?
+        if isVideoRotationAngleSupported(degrees) {
+          videoRotationAngle = degrees
+        }
+      } else {
+        if isVideoOrientationSupported {
+          videoOrientation = orientation.toAVCaptureVideoOrientation()
+        }
+      }
+    #else
+      if isVideoOrientationSupported {
+        videoOrientation = orientation.toAVCaptureVideoOrientation()
+      }
+    #endif
+  }
+}

package/ios/TestRecorder/ViewController.swift

@@ -113,5 +113,19 @@ class ViewController: UIViewController {
     }
   }
   
+  override func viewWillTransition(to size: CGSize, with coordinator: any UIViewControllerTransitionCoordinator) {
+    switch UIDevice.current.orientation {
+    case .landscapeLeft:
+      cameraView.orientation = "landscape-right"
+    case .landscapeRight:
+      cameraView.orientation = "landscape-left"
+    default:
+      cameraView.orientation = "portrait"
+    }
+    
+    cameraView.didSetProps([])
+    super.viewWillTransition(to: size, with: coordinator)
+  }
+  
 }
 

package/package.json

@@ -87,16 +87,15 @@
   "devDependencies": {
     "@expo/config-plugins": "^7.2.5",
     "@jamesacarr/eslint-formatter-github-actions": "^0.2.0",
-    "@react-native/eslint-config": "^0.72.2",
+    "@react-native/eslint-config": "^0.81.0",
-    "@react-native/typescript-config": "^0.74.0",
+    "@react-native/typescript-config": "^0.81.0",
     "@release-it/conventional-changelog": "^7.0.0",
     "@types/react": "^18.2.19",
-    "@types/react-native": "^0.72.2",
     "eslint": "^8.46.0",
     "eslint-plugin-prettier": "^5.0.0",
     "prettier": "^3.0.1",
-    "react": "^18.2.0",
+    "react": "^19.1.1",
-    "react-native": "^0.72.3",
+    "react-native": "^0.81.0",
     "react-native-builder-bob": "^0.21.3",
     "react-native-worklets-core": "^0.3.0",
     "release-it": "^16.1.3",

package/src/Camera.tsx

@@ -319,6 +319,22 @@ export class Camera extends React.PureComponent<CameraProps, CameraState> {
       throw tryParseNativeCameraError(e)
     }
   }
+
+  public async lockCurrentExposure(): Promise<void> {
+    try {
+      return await CameraModule.lockCurrentExposure(this.handle)
+    } catch (e) {
+      throw tryParseNativeCameraError(e)
+    }
+  }
+
+  public async unlockCurrentExposure(): Promise<void> {
+    try {
+      return await CameraModule.unlockCurrentExposure(this.handle)
+    } catch (e) {
+      throw tryParseNativeCameraError(e)
+    }
+  }
   //#endregion
 
   //#region Static Functions (NativeModule)