@capacitor-community/camera-preview 2.0.0-beta.0 → 2.1.0

package/ios/Plugin/CameraController.swift

@@ -17,6 +17,7 @@ class CameraController: NSObject {
     var frontCamera: AVCaptureDevice?
     var frontCameraInput: AVCaptureDeviceInput?
     
+    var dataOutput: AVCaptureVideoDataOutput?
     var photoOutput: AVCapturePhotoOutput?
     
     var rearCamera: AVCaptureDevice?
@@ -27,7 +28,14 @@ class CameraController: NSObject {
     var flashMode = AVCaptureDevice.FlashMode.off
     var photoCaptureCompletionBlock: ((UIImage?, Error?) -> Void)?
 
+    var sampleBufferCaptureCompletionBlock: ((UIImage?, Error?) -> Void)?
+
     var highResolutionOutput: Bool = false
+
+    var audioDevice: AVCaptureDevice?
+    var audioInput: AVCaptureDeviceInput?
+    
+    var zoomFactor: CGFloat = 1.0
 }
 
 extension CameraController {
@@ -56,6 +64,7 @@ extension CameraController {
                     camera.unlockForConfiguration()
                 }
             }
+            self.audioDevice = AVCaptureDevice.default(for: AVMediaType.audio)
         }
 
         func configureDeviceInputs() throws {
@@ -79,6 +88,16 @@ extension CameraController {
                     self.currentCameraPosition = .front
                 }
             } else { throw CameraControllerError.noCamerasAvailable }
+
+            // Add audio input
+            if let audioDevice = self.audioDevice {
+                self.audioInput = try AVCaptureDeviceInput(device: audioDevice)
+                if captureSession.canAddInput(self.audioInput!) {
+                    captureSession.addInput(self.audioInput!)
+                } else {
+                    throw CameraControllerError.inputsAreInvalid
+                }
+            }
         }
 
         func configurePhotoOutput() throws {
@@ -91,12 +110,32 @@ extension CameraController {
             captureSession.startRunning()
         }
 
+        func configureDataOutput() throws {
+            guard let captureSession = self.captureSession else { throw CameraControllerError.captureSessionIsMissing }
+
+            self.dataOutput = AVCaptureVideoDataOutput()
+            self.dataOutput?.videoSettings = [
+                (kCVPixelBufferPixelFormatTypeKey as String): NSNumber(value: kCVPixelFormatType_32BGRA as UInt32)
+            ]
+            self.dataOutput?.alwaysDiscardsLateVideoFrames = true
+            if captureSession.canAddOutput(self.dataOutput!) {
+                captureSession.addOutput(self.dataOutput!)
+            }
+
+            captureSession.commitConfiguration()
+
+            let queue = DispatchQueue(label: "DataOutput", attributes: [])
+            self.dataOutput?.setSampleBufferDelegate(self, queue: queue)
+        }
+
         DispatchQueue(label: "prepare").async {
             do {
                 createCaptureSession()
                 try configureCaptureDevices()
                 try configureDeviceInputs()
                 try configurePhotoOutput()
+                try configureDataOutput()
+                //try configureVideoOutput()
             }
 
             catch {
@@ -108,6 +147,8 @@ extension CameraController {
             }
 
             DispatchQueue.main.async {
+                self.updateVideoOrientation()
+
                 completionHandler(nil)
             }
         }
@@ -119,36 +160,63 @@ extension CameraController {
         self.previewLayer = AVCaptureVideoPreviewLayer(session: captureSession)
         self.previewLayer?.videoGravity = AVLayerVideoGravity.resizeAspectFill
 
-        let orientation: UIDeviceOrientation = UIDevice.current.orientation
-        let statusBarOrientation = UIApplication.shared.statusBarOrientation
-        switch (orientation) {
+        view.layer.insertSublayer(self.previewLayer!, at: 0)
+        self.previewLayer?.frame = view.frame
+    }
+
+    func setupGestures(target: UIView, enableZoom: Bool) {
+        setupTapGesture(target: target, selector: #selector(handleTap(_:)), delegate: self)
+        if (enableZoom) {
+            setupPinchGesture(target: target, selector: #selector(handlePinch(_:)), delegate: self)
+        }
+    }
+    
+    func setupTapGesture(target: UIView, selector: Selector, delegate: UIGestureRecognizerDelegate?) {
+        let tapGesture = UITapGestureRecognizer(target: self, action: selector)
+        tapGesture.delegate = delegate
+        target.addGestureRecognizer(tapGesture)
+    }
+    
+    func setupPinchGesture(target: UIView, selector: Selector, delegate: UIGestureRecognizerDelegate?) {
+        let pinchGesture = UIPinchGestureRecognizer(target: self, action: selector)
+        pinchGesture.delegate = delegate
+        target.addGestureRecognizer(pinchGesture)
+    }
+
+    func updateVideoOrientation() {
+        assert(Thread.isMainThread) // UIApplication.statusBarOrientation requires the main thread.
+
+        let videoOrientation: AVCaptureVideoOrientation
+        switch UIDevice.current.orientation {
         case .portrait:
-            self.previewLayer?.connection?.videoOrientation = .portrait
-        case .landscapeRight:
-           self.previewLayer?.connection?.videoOrientation = .landscapeLeft
+            videoOrientation = .portrait
         case .landscapeLeft:
-            self.previewLayer?.connection?.videoOrientation = .landscapeRight
+            videoOrientation = .landscapeRight
+        case .landscapeRight:
+            videoOrientation = .landscapeLeft
         case .portraitUpsideDown:
-            self.previewLayer?.connection?.videoOrientation = .portraitUpsideDown
-        case .faceUp, .faceDown:
-            switch (statusBarOrientation) {
+            videoOrientation = .portraitUpsideDown
+        case .faceUp, .faceDown, .unknown:
+            fallthrough
+        @unknown default:
+            switch UIApplication.shared.statusBarOrientation {
             case .portrait:
-                self.previewLayer?.connection?.videoOrientation = .portrait
-            case .landscapeRight:
-               self.previewLayer?.connection?.videoOrientation = .landscapeRight
+                videoOrientation = .portrait
             case .landscapeLeft:
-                self.previewLayer?.connection?.videoOrientation = .landscapeLeft
+                videoOrientation = .landscapeLeft
+            case .landscapeRight:
+                videoOrientation = .landscapeRight
             case .portraitUpsideDown:
-                self.previewLayer?.connection?.videoOrientation = .portraitUpsideDown
-            default:
-                self.previewLayer?.connection?.videoOrientation = .portrait
+                videoOrientation = .portraitUpsideDown
+            case .unknown:
+                fallthrough
+            @unknown default:
+                videoOrientation = .portrait
             }
-        default:
-            self.previewLayer?.connection?.videoOrientation = .portrait
         }
 
-        view.layer.insertSublayer(self.previewLayer!, at: 0)
-        self.previewLayer?.frame = view.frame
+        previewLayer?.connection?.videoOrientation = videoOrientation
+        dataOutput?.connections.forEach { $0.videoOrientation = videoOrientation }
     }
 
     func switchCameras() throws {
@@ -212,36 +280,19 @@ extension CameraController {
         settings.flashMode = self.flashMode
         settings.isHighResolutionPhotoEnabled = self.highResolutionOutput;
 
-        let currentDevice: UIDevice = .current
-        let deviceOrientation: UIDeviceOrientation = currentDevice.orientation
-        let statusBarOrientation = UIApplication.shared.statusBarOrientation
-        if deviceOrientation == .portrait {
-           self.photoOutput?.connection(with: AVMediaType.video)?.videoOrientation = AVCaptureVideoOrientation.portrait
-        }else if (deviceOrientation == .landscapeLeft){
-           self.photoOutput?.connection(with: AVMediaType.video)?.videoOrientation = AVCaptureVideoOrientation.landscapeRight
-        }else if (deviceOrientation == .landscapeRight){
-           self.photoOutput?.connection(with: AVMediaType.video)?.videoOrientation = AVCaptureVideoOrientation.landscapeLeft
-        }else if (deviceOrientation == .portraitUpsideDown){
-           self.photoOutput?.connection(with: AVMediaType.video)?.videoOrientation = AVCaptureVideoOrientation.portraitUpsideDown
-        }else if (deviceOrientation == .faceUp || deviceOrientation == .faceDown){
-            switch (statusBarOrientation) {
-            case .portrait:
-                self.photoOutput?.connection(with: AVMediaType.video)?.videoOrientation = AVCaptureVideoOrientation.portrait
-            case .landscapeRight:
-                self.photoOutput?.connection(with: AVMediaType.video)?.videoOrientation = AVCaptureVideoOrientation.landscapeRight
-            case .landscapeLeft:
-                self.photoOutput?.connection(with: AVMediaType.video)?.videoOrientation = AVCaptureVideoOrientation.landscapeLeft
-            case .portraitUpsideDown:
-                self.photoOutput?.connection(with: AVMediaType.video)?.videoOrientation = AVCaptureVideoOrientation.portraitUpsideDown
-            default:
-                self.photoOutput?.connection(with: AVMediaType.video)?.videoOrientation = AVCaptureVideoOrientation.portrait
-            }
-        }else {
-           self.photoOutput?.connection(with: AVMediaType.video)?.videoOrientation = AVCaptureVideoOrientation.portrait
-        }
         self.photoOutput?.capturePhoto(with: settings, delegate: self)
         self.photoCaptureCompletionBlock = completion
     }
+
+    func captureSample(completion: @escaping (UIImage?, Error?) -> Void) {
+        guard let captureSession = captureSession,
+              captureSession.isRunning else {
+            completion(nil, CameraControllerError.captureSessionIsMissing)
+            return
+        }
+
+        self.sampleBufferCaptureCompletionBlock = completion
+    }
     
     func getSupportedFlashModes() throws -> [String] {
         var currentCamera: AVCaptureDevice?
@@ -359,6 +410,92 @@ extension CameraController {
         }
         
     }
+
+    func captureVideo(completion: @escaping (URL?, Error?) -> Void) {
+        guard let captureSession = self.captureSession, captureSession.isRunning else {
+            completion(nil, CameraControllerError.captureSessionIsMissing)
+            return
+        }
+        let path = FileManager.default.urls(for: .cachesDirectory, in: .userDomainMask)[0]
+        let identifier = UUID()
+        let randomIdentifier = identifier.uuidString.replacingOccurrences(of: "-", with: "")
+        let finalIdentifier = String(randomIdentifier.prefix(8))
+        let fileName="cpcp_video_"+finalIdentifier+".mp4"
+
+            let fileUrl = path.appendingPathComponent(fileName)
+        try? FileManager.default.removeItem(at: fileUrl)
+        /*videoOutput!.startRecording(to: fileUrl, recordingDelegate: self)
+        self.videoRecordCompletionBlock = completion*/
+    }
+
+    func stopRecording(completion: @escaping (Error?) -> Void) {
+        guard let captureSession = self.captureSession, captureSession.isRunning else {
+            completion(CameraControllerError.captureSessionIsMissing)
+            return
+        }
+        //self.videoOutput?.stopRecording()
+    }
+}
+
+extension CameraController: UIGestureRecognizerDelegate {
+    func gestureRecognizer(_ gestureRecognizer: UIGestureRecognizer, shouldRecognizeSimultaneouslyWith otherGestureRecognizer: UIGestureRecognizer) -> Bool {
+        return true;
+    }
+    
+    @objc
+    func handleTap(_ tap: UITapGestureRecognizer) {
+        guard let device = self.currentCameraPosition == .rear ? rearCamera : frontCamera else { return }
+        
+        let point = tap.location(in: tap.view)
+        let devicePoint = self.previewLayer?.captureDevicePointConverted(fromLayerPoint: point)
+        
+        do {
+            try device.lockForConfiguration()
+            defer { device.unlockForConfiguration() }
+            
+            let focusMode = AVCaptureDevice.FocusMode.autoFocus
+            if device.isFocusPointOfInterestSupported && device.isFocusModeSupported(focusMode) {
+                device.focusPointOfInterest = CGPoint(x: CGFloat(devicePoint?.x ?? 0), y: CGFloat(devicePoint?.y ?? 0))
+                device.focusMode = focusMode
+            }
+            
+            let exposureMode = AVCaptureDevice.ExposureMode.autoExpose
+            if device.isExposurePointOfInterestSupported && device.isExposureModeSupported(exposureMode) {
+                device.exposurePointOfInterest = CGPoint(x: CGFloat(devicePoint?.x ?? 0), y: CGFloat(devicePoint?.y ?? 0))
+                device.exposureMode = exposureMode
+            }
+        } catch {
+            debugPrint(error)
+        }
+    }
+    
+    @objc
+    private func handlePinch(_ pinch: UIPinchGestureRecognizer) {
+        guard let device = self.currentCameraPosition == .rear ? rearCamera : frontCamera else { return }
+        
+        func minMaxZoom(_ factor: CGFloat) -> CGFloat { return max(1.0, min(factor, device.activeFormat.videoMaxZoomFactor)) }
+        
+        func update(scale factor: CGFloat) {
+            do {
+                try device.lockForConfiguration()
+                defer { device.unlockForConfiguration() }
+                
+                device.videoZoomFactor = factor
+            } catch {
+                debugPrint(error)
+            }
+        }
+        
+        switch pinch.state {
+        case .began: fallthrough
+        case .changed:
+            let newScaleFactor = minMaxZoom(pinch.scale * zoomFactor)
+            update(scale: newScaleFactor)
+        case .ended:
+            zoomFactor = device.videoZoomFactor
+        default: break
+        }
+    }
 }
 
 extension CameraController: AVCapturePhotoCaptureDelegate {
@@ -377,6 +514,48 @@ extension CameraController: AVCapturePhotoCaptureDelegate {
     }
 }
 
+extension CameraController: AVCaptureVideoDataOutputSampleBufferDelegate {
+    func captureOutput(_ output: AVCaptureOutput, didOutput sampleBuffer: CMSampleBuffer, from connection: AVCaptureConnection) {
+        guard let completion = sampleBufferCaptureCompletionBlock else { return }
+
+        guard let imageBuffer = CMSampleBufferGetImageBuffer(sampleBuffer) else {
+            completion(nil, CameraControllerError.unknown)
+            return
+        }
+
+        CVPixelBufferLockBaseAddress(imageBuffer, .readOnly)
+        defer { CVPixelBufferUnlockBaseAddress(imageBuffer, .readOnly) }
+
+        let baseAddress = CVPixelBufferGetBaseAddress(imageBuffer)
+        let bytesPerRow = CVPixelBufferGetBytesPerRow(imageBuffer)
+        let width = CVPixelBufferGetWidth(imageBuffer)
+        let height = CVPixelBufferGetHeight(imageBuffer)
+        let colorSpace = CGColorSpaceCreateDeviceRGB()
+        let bitmapInfo: UInt32 = CGBitmapInfo.byteOrder32Little.rawValue |
+            CGImageAlphaInfo.premultipliedFirst.rawValue
+
+        let context = CGContext(
+            data: baseAddress,
+            width: width,
+            height: height,
+            bitsPerComponent: 8,
+            bytesPerRow: bytesPerRow,
+            space: colorSpace,
+            bitmapInfo: bitmapInfo
+        )
+
+        guard let cgImage = context?.makeImage() else {
+            completion(nil, CameraControllerError.unknown)
+            return
+        }
+
+        let image = UIImage(cgImage: cgImage)
+        completion(image.fixedOrientation(), nil)
+
+        sampleBufferCaptureCompletionBlock = nil
+    }
+}
+
 
 
 
@@ -479,3 +658,13 @@ extension UIImage {
         return UIImage.init(cgImage: newCGImage, scale: 1, orientation: .up)
     }
 }
+
+extension CameraController: AVCaptureFileOutputRecordingDelegate {
+    func fileOutput(_ output: AVCaptureFileOutput, didFinishRecordingTo outputFileURL: URL, from connections: [AVCaptureConnection], error: Error?) {
+        /*if error == nil {
+            self.videoRecordCompletionBlock?(outputFileURL, nil)
+        } else {
+            self.videoRecordCompletionBlock?(nil, error)
+        }*/
+    }
+}

package/ios/Plugin/Plugin.m

@@ -7,7 +7,10 @@ CAP_PLUGIN(CameraPreview, "CameraPreview",
            CAP_PLUGIN_METHOD(start, CAPPluginReturnPromise);
            CAP_PLUGIN_METHOD(stop, CAPPluginReturnPromise);
            CAP_PLUGIN_METHOD(capture, CAPPluginReturnPromise);
+           CAP_PLUGIN_METHOD(captureSample, CAPPluginReturnPromise);
            CAP_PLUGIN_METHOD(flip, CAPPluginReturnPromise);
            CAP_PLUGIN_METHOD(getSupportedFlashModes, CAPPluginReturnPromise);
            CAP_PLUGIN_METHOD(setFlashMode, CAPPluginReturnPromise);
+           CAP_PLUGIN_METHOD(startRecordVideo, CAPPluginReturnPromise);
+           CAP_PLUGIN_METHOD(stopRecordVideo, CAPPluginReturnPromise);
 )

package/ios/Plugin/Plugin.swift

@@ -19,31 +19,40 @@ public class CameraPreview: CAPPlugin {
     var rotateWhenOrientationChanged: Bool?
     var toBack: Bool?
     var storeToFile: Bool?
+    var enableZoom: Bool?
     var highResolutionOutput: Bool = false
 
     @objc func rotated() {
 
-        let height = self.paddingBottom != nil ? self.height! - self.paddingBottom!: self.height!;
-
         if UIDevice.current.orientation.isLandscape {
-
-            self.previewView.frame = CGRect(x: self.y!, y: self.x!, width: height, height: self.width!)
-            self.cameraController.previewLayer?.frame = self.previewView.frame
-
-            if (UIDevice.current.orientation == UIDeviceOrientation.landscapeLeft) {
-                self.cameraController.previewLayer?.connection?.videoOrientation = .landscapeRight
-            }
-
-            if (UIDevice.current.orientation == UIDeviceOrientation.landscapeRight) {
-                self.cameraController.previewLayer?.connection?.videoOrientation = .landscapeLeft
+            if(self.width! > self.height!) {
+                // we started in landscape
+                let height = self.paddingBottom != nil ? self.height! - self.paddingBottom!: self.height!;
+                self.previewView.frame = CGRect(x: self.x!, y: self.y!, width: self.width!, height: height)
+            } else {
+                // we started in portrait
+                let width = self.paddingBottom != nil ? self.width! - self.paddingBottom!: self.width!;
+                self.previewView.frame = CGRect(x: self.y!, y: self.x!, width: self.height!, height: width)
             }
+            self.cameraController.previewLayer?.frame = self.previewView.frame
         }
 
         if UIDevice.current.orientation.isPortrait {
-            self.previewView.frame = CGRect(x: self.x!, y: self.y!, width: self.width!, height: self.height!)
+            if (self.previewView != nil && self.x != nil && self.y != nil && self.width != nil && self.height != nil) {
+                if(self.height! > self.width!) {
+                    // we started in portrait
+                    let height = self.paddingBottom != nil ? self.height! - self.paddingBottom!: self.height!;
+                    self.previewView.frame = CGRect(x: self.x!, y: self.y!, width: self.width!, height: height)
+                } else {
+                    // we started in landscape
+                    let width = self.paddingBottom != nil ? self.width! - self.paddingBottom!: self.width!;
+                    self.previewView.frame = CGRect(x: self.y!, y: self.x!, width: self.height!, height: width)
+                }
+            }
             self.cameraController.previewLayer?.frame = self.previewView.frame
-            self.cameraController.previewLayer?.connection?.videoOrientation = .portrait
         }
+
+        cameraController.updateVideoOrientation()
     }
 
     @objc func start(_ call: CAPPluginCall) {
@@ -67,44 +76,52 @@ public class CameraPreview: CAPPlugin {
             self.paddingBottom = CGFloat(call.getInt("paddingBottom")!)
         }
 
-        AVCaptureDevice.requestAccess(for: .video, completionHandler: { (granted: Bool) in
-            if (!granted) {
-                call.reject("permission failed");
-            }
-        });
-
         self.rotateWhenOrientationChanged = call.getBool("rotateWhenOrientationChanged") ?? true
         self.toBack = call.getBool("toBack") ?? false
         self.storeToFile = call.getBool("storeToFile") ?? false
+        self.enableZoom = call.getBool("enableZoom") ?? false
 
-        if (self.rotateWhenOrientationChanged == true) {
-            NotificationCenter.default.addObserver(self, selector: #selector(CameraPreview.rotated), name: UIDevice.orientationDidChangeNotification, object: nil)
-        }
-        
-        DispatchQueue.main.async {
-            if (self.cameraController.captureSession?.isRunning ?? false) {
-                call.reject("camera already started")
-            } else {
-                self.cameraController.prepare(cameraPosition: self.cameraPosition){error in
-                    if let error = error {
-                        print(error)
-                        call.reject(error.localizedDescription)
-                        return
-                    }
-                    self.previewView = UIView(frame: CGRect(x: self.x!, y: self.y!, width: self.width!, height: self.height!))
-                    self.webView?.isOpaque = false
-                    self.webView?.backgroundColor = UIColor.clear
-                    self.webView!.scrollView.backgroundColor = UIColor.clear
-                    self.webView?.superview?.addSubview(self.previewView)
-                    if (self.toBack!) {
-                        self.webView?.superview?.bringSubviewToFront(self.webView!)
-                    }
-                    try? self.cameraController.displayPreview(on: self.previewView)
-                    call.resolve()
+        AVCaptureDevice.requestAccess(for: .video, completionHandler: { (granted: Bool) in
+            guard granted else {
+                call.reject("permission failed");
+                return
+            }
+            
+            DispatchQueue.main.async {
+                if (self.cameraController.captureSession?.isRunning ?? false) {
+                    call.reject("camera already started")
+                } else {
+                    self.cameraController.prepare(cameraPosition: self.cameraPosition){error in
+                        if let error = error {
+                            print(error)
+                            call.reject(error.localizedDescription)
+                            return
+                        }
+                        let height = self.paddingBottom != nil ? self.height! - self.paddingBottom!: self.height!;
+                        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
+                        self.webView?.scrollView.backgroundColor = UIColor.clear
+                        self.webView?.superview?.addSubview(self.previewView)
+                        if (self.toBack!) {
+                            self.webView?.superview?.bringSubviewToFront(self.webView!)
+                        }
+                        try? self.cameraController.displayPreview(on: self.previewView)
+                        
+                        let frontView = self.toBack! ? self.webView : self.previewView;
+                        self.cameraController.setupGestures(target: frontView ?? self.previewView, enableZoom: self.enableZoom!)
+                        
+                        if (self.rotateWhenOrientationChanged == true) {
+                            NotificationCenter.default.addObserver(self, selector: #selector(CameraPreview.rotated), name: UIDevice.orientationDidChangeNotification, object: nil)
+                        }
+                        
+                        call.resolve()
 
+                    }
                 }
             }
-        }
+        });
+        
     }
 
     @objc func flip(_ call: CAPPluginCall) {
@@ -156,7 +173,7 @@ public class CameraPreview: CAPPlugin {
                 return
             }
             let imageData: Data?
-            if (self.cameraPosition == "front") {
+            if (self.cameraController.currentCameraPosition == .front) {
                 let flippedImage = image.withHorizontallyFlippedOrientation()
                 imageData = flippedImage.jpegData(compressionQuality: CGFloat(quality!/100))
             } else {
@@ -178,6 +195,41 @@ public class CameraPreview: CAPPlugin {
         }
         }
     }
+
+    @objc func captureSample(_ call: CAPPluginCall) {
+        DispatchQueue.main.async {
+            let quality: Int? = call.getInt("quality", 85)
+
+            self.cameraController.captureSample { image, error in
+                guard let image = image else {
+                    print("Image capture error: \(String(describing: error))")
+                    call.reject("Image capture error: \(String(describing: error))")
+                    return
+                }
+
+                let imageData: Data?
+                if (self.cameraPosition == "front") {
+                    let flippedImage = image.withHorizontallyFlippedOrientation()
+                    imageData = flippedImage.jpegData(compressionQuality: CGFloat(quality!/100))
+                } else {
+                    imageData = image.jpegData(compressionQuality: CGFloat(quality!/100))
+                }
+
+                if (self.storeToFile == false){
+                    let imageBase64 = imageData?.base64EncodedString()
+                    call.resolve(["value": imageBase64!])
+                } else {
+                    do {
+                        let fileUrl = self.getTempFilePath()
+                        try imageData?.write(to:fileUrl)
+                        call.resolve(["value": fileUrl.absoluteString])
+                    } catch {
+                        call.reject("Error writing image to file")
+                    }
+                }
+            }
+        }
+    }
     
     @objc func getSupportedFlashModes(_ call: CAPPluginCall) {
         do {
@@ -217,5 +269,37 @@ public class CameraPreview: CAPPlugin {
             call.reject("failed to set flash mode")
         }
     }
+
+        @objc func startRecordVideo(_ call: CAPPluginCall) {
+            DispatchQueue.main.async {
+
+            let quality: Int? = call.getInt("quality", 85)
+            
+            self.cameraController.captureVideo { (image, error) in
+
+                guard let image = image else {
+                    print(error ?? "Image capture error")
+                    guard let error = error else {
+                        call.reject("Image capture error")
+                        return
+                    }
+                    call.reject(error.localizedDescription)
+                    return
+                }
+
+                    //self.videoUrl = image
+
+                    call.resolve(["value":image.absoluteString])
+                }
+            }
+        }
+
+
+        @objc func stopRecordVideo(_ call: CAPPluginCall) {
+
+            self.cameraController.stopRecording { (error) in
+
+            }
+        }
     
 }

package/ios/Plugin.xcodeproj/project.pbxproj

@@ -14,8 +14,6 @@
 		4C2070D622DA87B100D1AD33 /* CoreImage.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = 4C2070D522DA87B100D1AD33 /* CoreImage.framework */; };
 		4C2070D822DA87C600D1AD33 /* QuartzCore.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = 4C2070D722DA87C500D1AD33 /* QuartzCore.framework */; };
 		4C2070DA22DA87CE00D1AD33 /* CoreVideo.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = 4C2070D922DA87CE00D1AD33 /* CoreVideo.framework */; };
-		4C2070DC22DA87D700D1AD33 /* GLKit.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = 4C2070DB22DA87D700D1AD33 /* GLKit.framework */; };
-		4C2070DE22DA87E700D1AD33 /* OpenGLES.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = 4C2070DD22DA87E700D1AD33 /* OpenGLES.framework */; };
 		4C2070E022DA87F500D1AD33 /* CoreGraphics.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = 4C2070DF22DA87F500D1AD33 /* CoreGraphics.framework */; };
 		4C2070E222DA87FB00D1AD33 /* AssetsLibrary.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = 4C2070E122DA87FB00D1AD33 /* AssetsLibrary.framework */; };
 		4C2070E422DA881600D1AD33 /* CoreLocation.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = 4C2070E322DA881600D1AD33 /* CoreLocation.framework */; };
@@ -77,8 +75,6 @@
 				4C2070E422DA881600D1AD33 /* CoreLocation.framework in Frameworks */,
 				4C2070E222DA87FB00D1AD33 /* AssetsLibrary.framework in Frameworks */,
 				4C2070E022DA87F500D1AD33 /* CoreGraphics.framework in Frameworks */,
-				4C2070DE22DA87E700D1AD33 /* OpenGLES.framework in Frameworks */,
-				4C2070DC22DA87D700D1AD33 /* GLKit.framework in Frameworks */,
 				4C2070D822DA87C600D1AD33 /* QuartzCore.framework in Frameworks */,
 				4C2070D622DA87B100D1AD33 /* CoreImage.framework in Frameworks */,
 				4C2070D222DA878E00D1AD33 /* ImageIO.framework in Frameworks */,
@@ -418,7 +414,7 @@
 				GCC_WARN_UNINITIALIZED_AUTOS = YES_AGGRESSIVE;
 				GCC_WARN_UNUSED_FUNCTION = YES;
 				GCC_WARN_UNUSED_VARIABLE = YES;
-				IPHONEOS_DEPLOYMENT_TARGET = 11.0;
+				IPHONEOS_DEPLOYMENT_TARGET = 12.1;
 				MTL_ENABLE_DEBUG_INFO = YES;
 				ONLY_ACTIVE_ARCH = YES;
 				SDKROOT = iphoneos;
@@ -473,7 +469,7 @@
 				GCC_WARN_UNINITIALIZED_AUTOS = YES_AGGRESSIVE;
 				GCC_WARN_UNUSED_FUNCTION = YES;
 				GCC_WARN_UNUSED_VARIABLE = YES;
-				IPHONEOS_DEPLOYMENT_TARGET = 11.0;
+				IPHONEOS_DEPLOYMENT_TARGET = 12.1;
 				MTL_ENABLE_DEBUG_INFO = NO;
 				SDKROOT = iphoneos;
 				SWIFT_OPTIMIZATION_LEVEL = "-Owholemodule";

package/ios/Podfile

@@ -1,4 +1,4 @@
-platform :ios, '11.0'
+platform :ios, '12.1'
 
 target 'Plugin' do
   # Comment the next line if you're not using Swift and don't want to use dynamic frameworks
@@ -10,4 +10,4 @@ target 'PluginTests' do
   use_frameworks!
 
   pod 'Capacitor', :path => '../node_modules/@capacitor/ios'
-end
+end