capacitor-community-multilens-camerapreview 7.0.1 → 7.1.0

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
         }
 
@@ -395,19 +401,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 +577,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 +721,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 +756,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.0",
   "description": "fork of capacitor community camera preview with support for switchting lenses",
   "main": "dist/plugin.cjs.js",
   "module": "dist/esm/index.js",