capacitor-community-multilens-camerapreview 7.1.1 → 7.1.3

package/ios/Plugin/CameraController.swift

@@ -23,6 +23,10 @@ class CameraController: NSObject {
     var rearCamera: AVCaptureDevice?
     var rearCameraInput: AVCaptureDeviceInput?
 
+    var ultraWideCamera: AVCaptureDevice?
+    var wideAngleCamera: AVCaptureDevice?
+    var telephotoCamera: AVCaptureDevice?
+
     var previewLayer: AVCaptureVideoPreviewLayer?
 
     var flashMode = AVCaptureDevice.FlashMode.off
@@ -38,21 +42,14 @@ class CameraController: NSObject {
     var zoomFactor: CGFloat = 1.0
 }
 extension CameraController {
-    func prepare(cameraPosition: String, zoomFactor: String, disableAudio: Bool, completionHandler: @escaping (Error?) -> Void) {
+    func prepare(cameraPosition: String, disableAudio: Bool, completionHandler: @escaping (Error?) -> Void) {
         
         func createCaptureSession() {
             self.captureSession = AVCaptureSession()
         }
 
         func configureCaptureDevices() throws {
-            var session = AVCaptureDevice.DiscoverySession(deviceTypes: [.builtInWideAngleCamera,.builtInUltraWideCamera,.builtInTelephotoCamera], mediaType: AVMediaType.video, position: .unspecified)
-            if(zoomFactor == "ultra"){
-                session = AVCaptureDevice.DiscoverySession(deviceTypes: [.builtInWideAngleCamera,.builtInUltraWideCamera], mediaType: AVMediaType.video, position: .unspecified)
-            } else if(zoomFactor == "wide"){
-                session = AVCaptureDevice.DiscoverySession(deviceTypes: [.builtInWideAngleCamera], mediaType: AVMediaType.video, position: .unspecified)
-            } else if(zoomFactor == "tele"){
-                session = AVCaptureDevice.DiscoverySession(deviceTypes: [.builtInWideAngleCamera,.builtInTelephotoCamera], mediaType: AVMediaType.video, position: .unspecified)
-            }
+            let session = AVCaptureDevice.DiscoverySession(deviceTypes: [.builtInWideAngleCamera, .builtInUltraWideCamera, .builtInTelephotoCamera], mediaType: AVMediaType.video, position: .unspecified)
             let cameras = session.devices.compactMap { $0 }
             guard !cameras.isEmpty else { throw CameraControllerError.noCamerasAvailable }
 
@@ -62,11 +59,21 @@ extension CameraController {
                 }
 
                 if camera.position == .back {
-                    self.rearCamera = camera
+                    switch camera.deviceType {
+                    case .builtInWideAngleCamera:
+                        self.wideAngleCamera = camera
+                    case .builtInUltraWideCamera:
+                        self.ultraWideCamera = camera
+                    case .builtInTelephotoCamera:
+                        self.telephotoCamera = camera
+                    default:
+                        break
+                    }
+                    self.rearCamera = camera // Keep a general rear camera reference
 
                     try camera.lockForConfiguration()
                     if camera.isFocusModeSupported(.continuousAutoFocus){
-                    camera.focusMode = .continuousAutoFocus
+                        camera.focusMode = .continuousAutoFocus
                     }
                     camera.unlockForConfiguration()
                 }
@@ -80,8 +87,8 @@ extension CameraController {
             guard let captureSession = self.captureSession else { throw CameraControllerError.captureSessionIsMissing }
 
             if cameraPosition == "rear" {
-                if let rearCamera = self.rearCamera {
-                    self.rearCameraInput = try AVCaptureDeviceInput(device: rearCamera)
+                if let wideAngleCamera = self.wideAngleCamera {
+                    self.rearCameraInput = try AVCaptureDeviceInput(device: wideAngleCamera)
 
                     if captureSession.canAddInput(self.rearCameraInput!) { captureSession.addInput(self.rearCameraInput!) }
 
@@ -145,7 +152,6 @@ extension CameraController {
                 try configureDeviceInputs()
                 try configurePhotoOutput()
                 try configureDataOutput()
-                // try configureVideoOutput()
             } catch {
                 DispatchQueue.main.async {
                     completionHandler(error)
@@ -285,105 +291,89 @@ extension CameraController {
 
         captureSession.commitConfiguration()
         
-        // Restart the capture session
         captureSession.startRunning()
+
+        DispatchQueue.main.async {
+            self.updateVideoOrientation()
+        }
     }
-    func setZoom(lens: String) throws {
-        print(lens)
+    func setCameraLens(lens: String) throws {
         guard let captureSession = self.captureSession, captureSession.isRunning else {
             throw CameraControllerError.captureSessionIsMissing
         }
-        
-        // Stop the capture session
+
+        guard self.currentCameraPosition == .rear else {
+            throw CameraControllerError.invalidOperation // Only allow lens switching for rear camera
+        }
+
         captureSession.stopRunning()
-        
         captureSession.beginConfiguration()
 
-        guard let rearCameraInput = self.rearCameraInput, captureSession.inputs.contains(rearCameraInput) else {
-            captureSession.startRunning() // Restart before throwing
-            throw CameraControllerError.invalidOperation
+        // Remove existing rear camera input
+        if let currentRearInput = self.rearCameraInput {
+            captureSession.removeInput(currentRearInput)
+            self.rearCameraInput = nil
         }
 
-        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
-            )
+        var newRearCamera: AVCaptureDevice?
+        switch lens {
+        case "ultra":
+            newRearCamera = self.ultraWideCamera
+        case "wide":
+            newRearCamera = self.wideAngleCamera
+        case "tele":
+            newRearCamera = self.telephotoCamera
+        default:
+            newRearCamera = self.wideAngleCamera // Default to wide if unknown lens
         }
-        
-        let cameras = session.devices.compactMap { $0 }
-        guard !cameras.isEmpty else {
-            captureSession.startRunning() // Restart before throwing
+
+        guard let camera = newRearCamera else {
+            captureSession.startRunning()
             throw CameraControllerError.noCamerasAvailable
         }
 
-        for camera in cameras {
-            if camera.position == .front {
-                self.frontCamera = camera
-            }
+        self.rearCameraInput = try AVCaptureDeviceInput(device: camera)
+        if captureSession.canAddInput(self.rearCameraInput!) {
+            captureSession.addInput(self.rearCameraInput!)
+        } else {
+            captureSession.startRunning()
+            throw CameraControllerError.inputsAreInvalid
+        }
 
-            if camera.position == .back {
-                self.rearCamera = camera
+        captureSession.commitConfiguration()
+        captureSession.startRunning()
 
-                try camera.lockForConfiguration()
-                if camera.isFocusModeSupported(.continuousAutoFocus) {
-                    camera.focusMode = .continuousAutoFocus
-                }
-                camera.unlockForConfiguration()
-            }
-        }
-        
-        if let inputs = captureSession.inputs as? [AVCaptureDeviceInput] {
-            for input in inputs {
-                captureSession.removeInput(input)
-            }
+        DispatchQueue.main.async {
+            self.updateVideoOrientation()
         }
-        captureSession.commitConfiguration()
+    }
 
-        self.rearCameraInput = try AVCaptureDeviceInput(device: rearCamera!)
+    func setZoom(zoomFactor: CGFloat) throws {
+        guard let captureSession = self.captureSession, captureSession.isRunning else {
+            throw CameraControllerError.captureSessionIsMissing
+        }
 
-        if captureSession.canAddInput(self.rearCameraInput!) {
-            captureSession.addInput(self.rearCameraInput!)
-            self.currentCameraPosition = .rear
+        guard let device = self.currentCameraPosition == .rear ? rearCameraInput?.device : frontCameraInput?.device else {
+            throw CameraControllerError.noCamerasAvailable
         }
 
         do {
-            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
-            zoomFactor = device.videoZoomFactor
 
+            let minZoomFactor: CGFloat = 1.0
+            let maxZoomFactor = device.activeFormat.videoMaxZoomFactor
+
+            device.videoZoomFactor = max(minZoomFactor, min(zoomFactor, maxZoomFactor))
+            self.zoomFactor = device.videoZoomFactor
         } catch {
             debugPrint(error)
+            throw CameraControllerError.invalidOperation
+        }
+
+        DispatchQueue.main.async {
+            self.updateVideoOrientation()
         }
-        
-        // Restart the capture session
-        captureSession.startRunning()
     }
 
     func captureImage(completion: @escaping (UIImage?, Error?) -> Void) {

package/ios/Plugin/Plugin.swift

@@ -22,7 +22,6 @@ public class CameraPreviewMultiLens: CAPPlugin {
     var enableZoom: Bool?
     var highResolutionOutput: Bool = false
     var disableAudio: Bool = false
-    var zoomFactor = String()
 
     private func currentInterfaceOrientation() -> UIInterfaceOrientation? {
         if let window = self.webView?.window ?? self.bridge?.viewController?.view.window {
@@ -69,7 +68,7 @@ public class CameraPreviewMultiLens: CAPPlugin {
 
     @objc func start(_ call: CAPPluginCall) {
         self.cameraPosition = call.getString("position") ?? "rear"
-        self.zoomFactor = call.getString("zoomFactor") ?? "wide"
+        let zoomFactor = call.getString("zoomFactor") ?? "wide"
         self.highResolutionOutput = call.getBool("enableHighResolution") ?? false
         self.cameraController.highResolutionOutput = self.highResolutionOutput
 
@@ -105,13 +104,21 @@ public class CameraPreviewMultiLens: CAPPlugin {
                 if self.cameraController.captureSession?.isRunning ?? false {
                     call.reject("camera already started")
                 } else {
-                    self.cameraController.prepare(cameraPosition: self.cameraPosition, zoomFactor: self.zoomFactor, disableAudio: self.disableAudio){error in
+                    self.cameraController.prepare(cameraPosition: self.cameraPosition, disableAudio: self.disableAudio, completionHandler: {error in
                         if let error = error {
                             print(error)
                             call.reject(error.localizedDescription)
                             return
                         }
                         let height = self.paddingBottom != nil ? self.height! - self.paddingBottom!: self.height!
+                        
+                        // Set lens after camera is prepared
+                        do {
+                            try self.cameraController.setCameraLens(lens: zoomFactor)
+                        } catch {
+                            print("Failed to set initial lens: \(error)")
+                        }
+                        
                         self.previewView = UIView(frame: CGRect(x: self.x ?? 0, y: self.y ?? 0, width: self.width!, height: height))
                         self.webView?.isOpaque = false
                         self.webView?.backgroundColor = UIColor.clear
@@ -135,7 +142,7 @@ public class CameraPreviewMultiLens: CAPPlugin {
 
                         call.resolve()
 
-                    }
+                    })
                 }
             }
         })
@@ -177,7 +184,7 @@ public class CameraPreviewMultiLens: CAPPlugin {
     @objc func capture(_ call: CAPPluginCall) {
         DispatchQueue.main.async {
 
-            let quality: Int? = call.getInt("quality", 85)
+            let quality: Int = call.getInt("quality") ?? 85
 
             self.cameraController.captureImage { (image, error) in
 
@@ -193,9 +200,9 @@ public class CameraPreviewMultiLens: CAPPlugin {
                 let imageData: Data?
                 if self.cameraController.currentCameraPosition == .front {
                     let flippedImage = image.withHorizontallyFlippedOrientation()
-                    imageData = flippedImage.jpegData(compressionQuality: CGFloat(quality!/100))
+                    imageData = flippedImage.jpegData(compressionQuality: CGFloat(quality/100))
                 } else {
-                    imageData = image.jpegData(compressionQuality: CGFloat(quality!/100))
+                    imageData = image.jpegData(compressionQuality: CGFloat(quality/100))
                 }
 
                 if self.storeToFile == false {
@@ -216,7 +223,7 @@ public class CameraPreviewMultiLens: CAPPlugin {
 
     @objc func captureSample(_ call: CAPPluginCall) {
         DispatchQueue.main.async {
-            let quality: Int? = call.getInt("quality", 85)
+            let quality: Int = call.getInt("quality") ?? 85
 
             self.cameraController.captureSample { image, error in
                 guard let image = image else {
@@ -228,9 +235,9 @@ public class CameraPreviewMultiLens: CAPPlugin {
                 let imageData: Data?
                 if self.cameraController.currentCameraPosition == .front {
                     let flippedImage = image.withHorizontallyFlippedOrientation()
-                    imageData = flippedImage.jpegData(compressionQuality: CGFloat(quality!/100))
+                    imageData = flippedImage.jpegData(compressionQuality: CGFloat(quality/100))
                 } else {
-                    imageData = image.jpegData(compressionQuality: CGFloat(quality!/100))
+                    imageData = image.jpegData(compressionQuality: CGFloat(quality/100))
                 }
 
                 if self.storeToFile == false {
@@ -266,9 +273,9 @@ public class CameraPreviewMultiLens: CAPPlugin {
         }
     }
     @objc func setZoom(_ call: CAPPluginCall) {
-        self.zoomFactor = call.getString("zoomFactor") ?? "wide"
+        let zoom = call.getDouble("zoomFactor") ?? 1.0
         do {
-            try self.cameraController.setZoom(lens: self.zoomFactor)
+            try self.cameraController.setZoom(zoomFactor: CGFloat(zoom))
             call.resolve()
         } catch {
             call.reject("failed to set zoom")
@@ -307,8 +314,6 @@ public class CameraPreviewMultiLens: CAPPlugin {
     @objc func startRecordVideo(_ call: CAPPluginCall) {
         DispatchQueue.main.async {
 
-            let _ = call.getInt("quality", 85)
-
             self.cameraController.captureVideo { (image, error) in
 
                 guard let image = image else {

package/package.json

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