Ensure custom exposure mode is supported

package/ios/CameraView+RecordVideo.swift

@@ -50,12 +50,4 @@ 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/CameraViewManager.m

@@ -86,13 +86,5 @@ 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,18 +110,6 @@ 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

@@ -18,6 +18,8 @@ extension CameraSession {
                       filePath: String,
                       onVideoRecorded: @escaping (_ video: Video) -> Void,
                       onError: @escaping (_ error: CameraError) -> Void) {
+
+    lockCurrentExposure(for: captureSession)
     // Run on Camera Queue
     CameraQueues.cameraQueue.async {
       let start = DispatchTime.now()
@@ -192,19 +194,18 @@ extension CameraSession {
     }
   }
 
-  func lockCurrentExposure(promise: Promise) {
+  func lockCurrentExposure(for session: AVCaptureSession) {
-    CameraQueues.cameraQueue.async {
+      guard let captureDevice = AVCaptureDevice.default(for: .video) else {
-      withPromise(promise) {
-        guard let captureDevice = AVCaptureDevice.default(for: .video) else {
           print("No capture device available")
           return
+      }
 
-        }
+      guard captureDevice.isExposureModeSupported(.custom) else {
-        guard captureDevice.isExposureModeSupported(.custom) else {
+        ReactLogger.log(level: .info, message: "Custom exposure mode not supported")
-          ReactLogger.log(level: .info, message: "Custom exposure mode not supported")
+        return
-          return
+      }
-        }
+
-        do {
+      do {
           // Lock the device for configuration
           try captureDevice.lockForConfiguration()
 
@@ -214,45 +215,18 @@ extension CameraSession {
 
           // Check if the device supports custom exposure settings
           if captureDevice.isExposureModeSupported(.custom) {
-            // Lock the current exposure and ISO by setting custom exposure mode
+              // Lock the current exposure and ISO by setting custom exposure mode
-            captureDevice.setExposureModeCustom(duration: currentExposureDuration, iso: currentISO, completionHandler: nil)
+              captureDevice.setExposureModeCustom(duration: currentExposureDuration, iso: currentISO, completionHandler: nil)
-            ReactLogger.log(level: .info, message: "Exposure and ISO locked at current values")
+              ReactLogger.log(level: .info, message: "Exposure and ISO locked at current values")
           } else {
-            ReactLogger.log(level: .info, message:"Custom exposure mode not supported")
+              ReactLogger.log(level: .info, message:"Custom exposure mode not supported")
           }
 
           // Unlock the device after configuration
           captureDevice.unlockForConfiguration()
 
-        } catch {
+      } catch {
-          ReactLogger.log(level: .warning, message:"Error locking exposure: \(error)")
+        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/src/Camera.tsx

@@ -319,22 +319,6 @@ 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)