capacitor-community-multilens-camerapreview 7.0.1 → 7.1.1

package/ios/Plugin/CameraController.swift

@@ -3,7 +3,7 @@
 //  Plugin
 //
 //  Created by Ariel Hernandez Musa on 7/14/19.
-//  Copyright © 2019 Max Lynch. All rights reserved.
+//  Modified by Pete Kraguljac on 11/5/2025
 //
 
 import AVFoundation
@@ -192,10 +192,18 @@ extension CameraController {
     }
 
     func updateVideoOrientation() {
-        assert(Thread.isMainThread) // UIApplication.statusBarOrientation requires the main thread.
+        assert(Thread.isMainThread)
+
+        // Prefer the interfaceOrientation from the active window scene (iOS 13+)
+        let interfaceOrientation: UIInterfaceOrientation = (
+            UIApplication.shared.connectedScenes
+                .compactMap { $0 as? UIWindowScene }
+                .first(where: { $0.activationState == .foregroundActive })?
+                .interfaceOrientation
+        ) ?? UIApplication.shared.windows.first?.windowScene?.interfaceOrientation ?? .portrait
 
         let videoOrientation: AVCaptureVideoOrientation
-        switch UIApplication.shared.statusBarOrientation {
+        switch interfaceOrientation {
         case .portrait:
             videoOrientation = .portrait
         case .landscapeLeft:
@@ -204,9 +212,7 @@ extension CameraController {
             videoOrientation = .landscapeRight
         case .portraitUpsideDown:
             videoOrientation = .portraitUpsideDown
-        case .unknown:
-            fallthrough
-        @unknown default:
+        default:
             videoOrientation = .portrait
         }
 
@@ -216,14 +222,22 @@ extension CameraController {
     }
 
     func switchCameras() throws {
-        guard let currentCameraPosition = currentCameraPosition, let captureSession = self.captureSession, captureSession.isRunning else { throw CameraControllerError.captureSessionIsMissing }
+        guard let currentCameraPosition = currentCameraPosition, let captureSession = self.captureSession, captureSession.isRunning else {
+            throw CameraControllerError.captureSessionIsMissing
+        }
+
+        // Stop the capture session
+        captureSession.stopRunning()
 
         captureSession.beginConfiguration()
 
         func switchToFrontCamera() throws {
 
             guard let rearCameraInput = self.rearCameraInput, captureSession.inputs.contains(rearCameraInput),
-                  let frontCamera = self.frontCamera else { throw CameraControllerError.invalidOperation }
+                  let frontCamera = self.frontCamera else {
+                captureSession.startRunning() // Restart before throwing
+                throw CameraControllerError.invalidOperation
+            }
 
             self.frontCameraInput = try AVCaptureDeviceInput(device: frontCamera)
 
@@ -234,6 +248,7 @@ extension CameraController {
 
                 self.currentCameraPosition = .front
             } else {
+                captureSession.startRunning() // Restart before throwing
                 throw CameraControllerError.invalidOperation
             }
         }
@@ -241,7 +256,10 @@ extension CameraController {
         func switchToRearCamera() throws {
 
             guard let frontCameraInput = self.frontCameraInput, captureSession.inputs.contains(frontCameraInput),
-                  let rearCamera = self.rearCamera else { throw CameraControllerError.invalidOperation }
+                  let rearCamera = self.rearCamera else {
+                captureSession.startRunning() // Restart before throwing
+                throw CameraControllerError.invalidOperation
+            }
 
             self.rearCameraInput = try AVCaptureDeviceInput(device: rearCamera)
 
@@ -251,7 +269,10 @@ extension CameraController {
                 captureSession.addInput(self.rearCameraInput!)
 
                 self.currentCameraPosition = .rear
-            } else { throw CameraControllerError.invalidOperation }
+            } else {
+                captureSession.startRunning() // Restart before throwing
+                throw CameraControllerError.invalidOperation
+            }
         }
 
         switch currentCameraPosition {
@@ -263,41 +284,73 @@ extension CameraController {
         }
 
         captureSession.commitConfiguration()
+        
+        // Restart the capture session
+        captureSession.startRunning()
     }
     func setZoom(lens: String) throws {
         print(lens)
-        guard let captureSession = self.captureSession, captureSession.isRunning else { throw CameraControllerError.captureSessionIsMissing }
+        guard let captureSession = self.captureSession, captureSession.isRunning else {
+            throw CameraControllerError.captureSessionIsMissing
+        }
+        
+        // Stop the capture session
+        captureSession.stopRunning()
         
         captureSession.beginConfiguration()
 
-        guard let rearCameraInput = self.rearCameraInput, captureSession.inputs.contains(rearCameraInput) else { throw CameraControllerError.invalidOperation }
+        guard let rearCameraInput = self.rearCameraInput, captureSession.inputs.contains(rearCameraInput) else {
+            captureSession.startRunning() // Restart before throwing
+            throw CameraControllerError.invalidOperation
+        }
 
-        var session = AVCaptureDevice.DiscoverySession(deviceTypes: [.builtInWideAngleCamera,.builtInUltraWideCamera,.builtInTelephotoCamera], mediaType: AVMediaType.video, position: .unspecified)
-            if(lens == "ultra"){
-                session = AVCaptureDevice.DiscoverySession(deviceTypes: [.builtInWideAngleCamera,.builtInUltraWideCamera], mediaType: AVMediaType.video, position: .unspecified)
-            } else if(lens == "wide"){
-                session = AVCaptureDevice.DiscoverySession(deviceTypes: [.builtInWideAngleCamera], mediaType: AVMediaType.video, position: .unspecified)
-            } else if(lens == "tele"){
-                session = AVCaptureDevice.DiscoverySession(deviceTypes: [.builtInWideAngleCamera,.builtInTelephotoCamera], mediaType: AVMediaType.video, position: .unspecified)
-            }
-            let cameras = session.devices.compactMap { $0 }
-            guard !cameras.isEmpty else { throw CameraControllerError.noCamerasAvailable }
+        var session = AVCaptureDevice.DiscoverySession(
+            deviceTypes: [.builtInWideAngleCamera, .builtInUltraWideCamera, .builtInTelephotoCamera],
+            mediaType: AVMediaType.video,
+            position: .unspecified
+        )
+        
+        if lens == "ultra" {
+            session = AVCaptureDevice.DiscoverySession(
+                deviceTypes: [.builtInWideAngleCamera, .builtInUltraWideCamera],
+                mediaType: AVMediaType.video,
+                position: .unspecified
+            )
+        } else if lens == "wide" {
+            session = AVCaptureDevice.DiscoverySession(
+                deviceTypes: [.builtInWideAngleCamera],
+                mediaType: AVMediaType.video,
+                position: .unspecified
+            )
+        } else if lens == "tele" {
+            session = AVCaptureDevice.DiscoverySession(
+                deviceTypes: [.builtInWideAngleCamera, .builtInTelephotoCamera],
+                mediaType: AVMediaType.video,
+                position: .unspecified
+            )
+        }
+        
+        let cameras = session.devices.compactMap { $0 }
+        guard !cameras.isEmpty else {
+            captureSession.startRunning() // Restart before throwing
+            throw CameraControllerError.noCamerasAvailable
+        }
 
-            for camera in cameras {
-                if camera.position == .front {
-                    self.frontCamera = camera
-                }
+        for camera in cameras {
+            if camera.position == .front {
+                self.frontCamera = camera
+            }
 
-                if camera.position == .back {
-                    self.rearCamera = camera
+            if camera.position == .back {
+                self.rearCamera = camera
 
-                    try camera.lockForConfiguration()
-                    if camera.isFocusModeSupported(.continuousAutoFocus){
-                        camera.focusMode = .continuousAutoFocus
-                    }
-                    camera.unlockForConfiguration()
+                try camera.lockForConfiguration()
+                if camera.isFocusModeSupported(.continuousAutoFocus) {
+                    camera.focusMode = .continuousAutoFocus
                 }
+                camera.unlockForConfiguration()
             }
+        }
         
         if let inputs = captureSession.inputs as? [AVCaptureDeviceInput] {
             for input in inputs {
@@ -308,25 +361,29 @@ extension CameraController {
 
         self.rearCameraInput = try AVCaptureDeviceInput(device: rearCamera!)
 
-        //captureSession.removeInput(frontCameraInput)
-
         if captureSession.canAddInput(self.rearCameraInput!) {
             captureSession.addInput(self.rearCameraInput!)
             self.currentCameraPosition = .rear
         }
 
         do {
-            guard let device = self.currentCameraPosition == .rear ? rearCamera : frontCamera else { return }
+            guard let device = self.currentCameraPosition == .rear ? rearCamera : frontCamera else {
+                captureSession.startRunning() // Restart before returning
+                return
+            }
 
             try device.lockForConfiguration()
             defer { device.unlockForConfiguration() }
             
-            device.videoZoomFactor = 1.0            
+            device.videoZoomFactor = 1.0
             zoomFactor = device.videoZoomFactor
 
         } catch {
             debugPrint(error)
         }
+        
+        // Restart the capture session
+        captureSession.startRunning()
     }
 
     func captureImage(completion: @escaping (UIImage?, Error?) -> Void) {
@@ -395,19 +452,22 @@ extension CameraController {
 
     }
     func getSupportedCameras() throws -> [String] {
-        var supportedCameras: [String] = [];
-        if let device = AVCaptureDevice.default(.builtInUltraWideCamera, for: AVMediaType.video, position: .back) {
+        var supportedCameras: [String] = []
+
+        if AVCaptureDevice.default(.builtInUltraWideCamera, for: .video, position: .back) != nil {
             supportedCameras.append("ultra")
         }
-        if let device = AVCaptureDevice.default(.builtInWideAngleCamera, for: AVMediaType.video, position: .back) {
+        if AVCaptureDevice.default(.builtInWideAngleCamera, for: .video, position: .back) != nil {
             supportedCameras.append("wide")
         }
-        if let device = AVCaptureDevice.default(.builtInTelephotoCamera, for: AVMediaType.video, position: .back) {
+        if AVCaptureDevice.default(.builtInTelephotoCamera, for: .video, position: .back) != nil {
             supportedCameras.append("tele")
         }
-        return supportedCameras;
+
+        return supportedCameras
     }
 
+
     func setFlashMode(flashMode: AVCaptureDevice.FlashMode) throws {
         var currentCamera: AVCaptureDevice?
         switch currentCameraPosition {
@@ -568,17 +628,32 @@ extension CameraController: UIGestureRecognizerDelegate {
 }
 
 extension CameraController: AVCapturePhotoCaptureDelegate {
-    public func photoOutput(_ captureOutput: AVCapturePhotoOutput, didFinishProcessingPhoto photoSampleBuffer: CMSampleBuffer?, previewPhoto previewPhotoSampleBuffer: CMSampleBuffer?,
-                            resolvedSettings: AVCaptureResolvedPhotoSettings, bracketSettings: AVCaptureBracketedStillImageSettings?, error: Swift.Error?) {
-        if let error = error { self.photoCaptureCompletionBlock?(nil, error) } else if let buffer = photoSampleBuffer, let data = AVCapturePhotoOutput.jpegPhotoDataRepresentation(forJPEGSampleBuffer: buffer, previewPhotoSampleBuffer: nil),
-                                                                                       let image = UIImage(data: data) {
+
+    public func photoOutput(_ output: AVCapturePhotoOutput, didFinishProcessingPhoto photo: AVCapturePhoto, error: Error?) {
+        if let error = error {
+            self.photoCaptureCompletionBlock?(nil, error)
+            return
+        }
+
+        // Prefer modern data extraction
+        if let data = photo.fileDataRepresentation(),
+           let image = UIImage(data: data) {
             self.photoCaptureCompletionBlock?(image.fixedOrientation(), nil)
-        } else {
-            self.photoCaptureCompletionBlock?(nil, CameraControllerError.unknown)
+            return
         }
+
+        // Fallback to cgImageRepresentation if available
+        if let cgImage = photo.cgImageRepresentation() {
+            let image = UIImage(cgImage: cgImage)
+            self.photoCaptureCompletionBlock?(image.fixedOrientation(), nil)
+            return
+        }
+
+        self.photoCaptureCompletionBlock?(nil, CameraControllerError.unknown)
     }
 }
 
+
 extension CameraController: AVCaptureVideoDataOutputSampleBufferDelegate {
     func captureOutput(_ output: AVCaptureOutput, didOutput sampleBuffer: CMSampleBuffer, from connection: AVCaptureConnection) {
         guard let completion = sampleBufferCaptureCompletionBlock else { return }
@@ -697,12 +772,14 @@ extension UIImage {
         // Flip image one more time if needed to, this is to prevent flipped image
         switch imageOrientation {
         case .upMirrored, .downMirrored:
-            transform.translatedBy(x: size.width, y: 0)
-            transform.scaledBy(x: -1, y: 1)
+            transform = transform.translatedBy(x: size.width, y: 0)
+            transform = transform.scaledBy(x: -1, y: 1)
+            transform = transform.scaledBy(x: -1, y: 1)
             break
         case .leftMirrored, .rightMirrored:
-            transform.translatedBy(x: size.height, y: 0)
-            transform.scaledBy(x: -1, y: 1)
+            transform = transform.translatedBy(x: size.height, y: 0)
+            transform = transform.scaledBy(x: -1, y: 1)
+            transform = transform.scaledBy(x: -1, y: 1)
         case .up, .down, .left, .right:
             break
         }
@@ -730,3 +807,4 @@ extension CameraController: AVCaptureFileOutputRecordingDelegate {
          }*/
     }
 }
+

package/ios/Plugin/Plugin.swift

@@ -24,15 +24,40 @@ public class CameraPreviewMultiLens: CAPPlugin {
     var disableAudio: Bool = false
     var zoomFactor = String()
 
+    private func currentInterfaceOrientation() -> UIInterfaceOrientation? {
+        if let window = self.webView?.window ?? self.bridge?.viewController?.view.window {
+            return window.windowScene?.interfaceOrientation
+        }
+        // Fallback to device orientation mapping
+        let deviceOrientation = UIDevice.current.orientation
+        switch deviceOrientation {
+        case .landscapeLeft: return .landscapeRight // device vs interface are mirrored
+        case .landscapeRight: return .landscapeLeft
+        case .portrait: return .portrait
+        case .portraitUpsideDown: return .portraitUpsideDown
+        default: return nil
+        }
+    }
+
     @objc func rotated() {
         let height = self.paddingBottom != nil ? self.height! - self.paddingBottom!: self.height!
 
-        if UIApplication.shared.statusBarOrientation.isLandscape {
+        // Determine orientation without using deprecated statusBarOrientation and without relying on missing viewController
+        let orientation = self.currentInterfaceOrientation()
+        let isLandscape: Bool
+        if let orientation = orientation {
+            isLandscape = orientation.isLandscape
+        } else {
+            // Default to portrait when unknown
+            isLandscape = false
+        }
+
+        if isLandscape {
             self.previewView.frame = CGRect(x: self.y!, y: self.x!, width: max(height, self.width!), height: min(height, self.width!))
             self.cameraController.previewLayer?.frame = self.previewView.frame
         }
 
-        if UIApplication.shared.statusBarOrientation.isPortrait {
+        if !isLandscape {
             if self.previewView != nil && self.x != nil && self.y != nil && self.width != nil && self.height != nil {
                 self.previewView.frame = CGRect(x: self.x!, y: self.y!, width: min(height, self.width!), height: max(height, self.width!))
             }
@@ -102,6 +127,10 @@ public class CameraPreviewMultiLens: CAPPlugin {
 
                         if self.rotateWhenOrientationChanged == true {
                             NotificationCenter.default.addObserver(self, selector: #selector(CameraPreviewMultiLens.rotated), name: UIDevice.orientationDidChangeNotification, object: nil)
+                            if let scene = self.webView?.window?.windowScene ?? self.bridge?.viewController?.view.window?.windowScene {
+                                NotificationCenter.default.addObserver(self, selector: #selector(CameraPreviewMultiLens.rotated), name: UIWindowScene.willEnterForegroundNotification, object: scene)
+                                NotificationCenter.default.addObserver(self, selector: #selector(CameraPreviewMultiLens.rotated), name: UIWindowScene.didActivateNotification, object: scene)
+                            }
                         }
 
                         call.resolve()
@@ -197,7 +226,7 @@ public class CameraPreviewMultiLens: CAPPlugin {
                 }
 
                 let imageData: Data?
-                if self.cameraPosition == "front" {
+                if self.cameraController.currentCameraPosition == .front {
                     let flippedImage = image.withHorizontallyFlippedOrientation()
                     imageData = flippedImage.jpegData(compressionQuality: CGFloat(quality!/100))
                 } else {
@@ -278,7 +307,7 @@ public class CameraPreviewMultiLens: CAPPlugin {
     @objc func startRecordVideo(_ call: CAPPluginCall) {
         DispatchQueue.main.async {
 
-            let quality: Int? = call.getInt("quality", 85)
+            let _ = call.getInt("quality", 85)
 
             self.cameraController.captureVideo { (image, error) in
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "capacitor-community-multilens-camerapreview",
-  "version": "7.0.1",
+  "version": "7.1.1",
   "description": "fork of capacitor community camera preview with support for switchting lenses",
   "main": "dist/plugin.cjs.js",
   "module": "dist/esm/index.js",