capacitor-community-multilens-camerapreview 0.0.1

package/ios/Plugin/CameraController.swift

@@ -0,0 +1,667 @@
+//
+//  CameraController.swift
+//  Plugin
+//
+//  Created by Ariel Hernandez Musa on 7/14/19.
+//  Copyright © 2019 Max Lynch. All rights reserved.
+//
+
+import AVFoundation
+import UIKit
+
+class CameraController: NSObject {
+    var captureSession: AVCaptureSession?
+
+    var currentCameraPosition: CameraPosition?
+
+    var frontCamera: AVCaptureDevice?
+    var frontCameraInput: AVCaptureDeviceInput?
+
+    var dataOutput: AVCaptureVideoDataOutput?
+    var photoOutput: AVCapturePhotoOutput?
+
+    var rearCamera: AVCaptureDevice?
+    var rearCameraInput: AVCaptureDeviceInput?
+
+    var previewLayer: AVCaptureVideoPreviewLayer?
+
+    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 {
+    func prepare(cameraPosition: String, zoomFactor: 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 cameras = session.devices.compactMap { $0 }
+            guard !cameras.isEmpty else { throw CameraControllerError.noCamerasAvailable }
+
+            for camera in cameras {
+                if camera.position == .front {
+                    self.frontCamera = camera
+                }
+
+                if camera.position == .back {
+                    self.rearCamera = camera
+
+                    try camera.lockForConfiguration()
+                    camera.focusMode = .continuousAutoFocus
+                    camera.unlockForConfiguration()
+                }
+            }
+            if disableAudio == false {
+                self.audioDevice = AVCaptureDevice.default(for: AVMediaType.audio)
+            }
+        }
+
+        func configureDeviceInputs() throws {
+            guard let captureSession = self.captureSession else { throw CameraControllerError.captureSessionIsMissing }
+
+            if cameraPosition == "rear" {
+                if let rearCamera = self.rearCamera {
+                    self.rearCameraInput = try AVCaptureDeviceInput(device: rearCamera)
+
+                    if captureSession.canAddInput(self.rearCameraInput!) { captureSession.addInput(self.rearCameraInput!) }
+
+                    self.currentCameraPosition = .rear
+                }
+            } else if cameraPosition == "front" {
+                if let frontCamera = self.frontCamera {
+                    self.frontCameraInput = try AVCaptureDeviceInput(device: frontCamera)
+
+                    if captureSession.canAddInput(self.frontCameraInput!) { captureSession.addInput(self.frontCameraInput!) } else { throw CameraControllerError.inputsAreInvalid }
+
+                    self.currentCameraPosition = .front
+                }
+            } else { throw CameraControllerError.noCamerasAvailable }
+
+            // Add audio input
+            if disableAudio == false {
+                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 {
+            guard let captureSession = self.captureSession else { throw CameraControllerError.captureSessionIsMissing }
+
+            self.photoOutput = AVCapturePhotoOutput()
+            self.photoOutput!.setPreparedPhotoSettingsArray([AVCapturePhotoSettings(format: [AVVideoCodecKey: AVVideoCodecType.jpeg])], completionHandler: nil)
+            self.photoOutput?.isHighResolutionCaptureEnabled = self.highResolutionOutput
+            if captureSession.canAddOutput(self.photoOutput!) { captureSession.addOutput(self.photoOutput!) }
+            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 {
+                DispatchQueue.main.async {
+                    completionHandler(error)
+                }
+
+                return
+            }
+
+            DispatchQueue.main.async {
+                completionHandler(nil)
+            }
+        }
+    }
+
+    func displayPreview(on view: UIView) throws {
+        guard let captureSession = self.captureSession, captureSession.isRunning else { throw CameraControllerError.captureSessionIsMissing }
+
+        self.previewLayer = AVCaptureVideoPreviewLayer(session: captureSession)
+        self.previewLayer?.videoGravity = AVLayerVideoGravity.resizeAspectFill
+
+        view.layer.insertSublayer(self.previewLayer!, at: 0)
+        self.previewLayer?.frame = view.frame
+
+        updateVideoOrientation()
+    }
+
+    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 UIApplication.shared.statusBarOrientation {
+        case .portrait:
+            videoOrientation = .portrait
+        case .landscapeLeft:
+            videoOrientation = .landscapeLeft
+        case .landscapeRight:
+            videoOrientation = .landscapeRight
+        case .portraitUpsideDown:
+            videoOrientation = .portraitUpsideDown
+        case .unknown:
+            fallthrough
+        @unknown default:
+            videoOrientation = .portrait
+        }
+
+        previewLayer?.connection?.videoOrientation = videoOrientation
+        dataOutput?.connections.forEach { $0.videoOrientation = videoOrientation }
+        photoOutput?.connections.forEach { $0.videoOrientation = videoOrientation }
+    }
+    
+
+    func switchCameras() throws {
+        guard let currentCameraPosition = currentCameraPosition, let captureSession = self.captureSession, captureSession.isRunning else { throw CameraControllerError.captureSessionIsMissing }
+
+        captureSession.beginConfiguration()
+
+        func switchToFrontCamera() throws {
+
+            guard let rearCameraInput = self.rearCameraInput, captureSession.inputs.contains(rearCameraInput),
+                  let frontCamera = self.frontCamera else { throw CameraControllerError.invalidOperation }
+
+            self.frontCameraInput = try AVCaptureDeviceInput(device: frontCamera)
+
+            captureSession.removeInput(rearCameraInput)
+
+            if captureSession.canAddInput(self.frontCameraInput!) {
+                captureSession.addInput(self.frontCameraInput!)
+
+                self.currentCameraPosition = .front
+            } else {
+                throw CameraControllerError.invalidOperation
+            }
+        }
+
+        func switchToRearCamera() throws {
+
+            guard let frontCameraInput = self.frontCameraInput, captureSession.inputs.contains(frontCameraInput),
+                  let rearCamera = self.rearCamera else { throw CameraControllerError.invalidOperation }
+
+            self.rearCameraInput = try AVCaptureDeviceInput(device: rearCamera)
+
+            captureSession.removeInput(frontCameraInput)
+
+            if captureSession.canAddInput(self.rearCameraInput!) {
+                captureSession.addInput(self.rearCameraInput!)
+
+                self.currentCameraPosition = .rear
+            } else { throw CameraControllerError.invalidOperation }
+        }
+
+        switch currentCameraPosition {
+        case .front:
+            try switchToRearCamera()
+
+        case .rear:
+            try switchToFrontCamera()
+        }
+
+        captureSession.commitConfiguration()
+    }
+
+    func captureImage(completion: @escaping (UIImage?, Error?) -> Void) {
+        guard let captureSession = captureSession, captureSession.isRunning else { completion(nil, CameraControllerError.captureSessionIsMissing); return }
+        let settings = AVCapturePhotoSettings()
+
+        settings.flashMode = self.flashMode
+        settings.isHighResolutionPhotoEnabled = self.highResolutionOutput
+
+        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?
+        switch currentCameraPosition {
+        case .front:
+            currentCamera = self.frontCamera!
+        case .rear:
+            currentCamera = self.rearCamera!
+        default: break
+        }
+
+        guard
+            let device = currentCamera
+        else {
+            throw CameraControllerError.noCamerasAvailable
+        }
+
+        var supportedFlashModesAsStrings: [String] = []
+        if device.hasFlash {
+            guard let supportedFlashModes: [AVCaptureDevice.FlashMode] = self.photoOutput?.supportedFlashModes else {
+                throw CameraControllerError.noCamerasAvailable
+            }
+
+            for flashMode in supportedFlashModes {
+                var flashModeValue: String?
+                switch flashMode {
+                case AVCaptureDevice.FlashMode.off:
+                    flashModeValue = "off"
+                case AVCaptureDevice.FlashMode.on:
+                    flashModeValue = "on"
+                case AVCaptureDevice.FlashMode.auto:
+                    flashModeValue = "auto"
+                default: break
+                }
+                if flashModeValue != nil {
+                    supportedFlashModesAsStrings.append(flashModeValue!)
+                }
+            }
+        }
+        if device.hasTorch {
+            supportedFlashModesAsStrings.append("torch")
+        }
+        return supportedFlashModesAsStrings
+
+    }
+    func getSupportedCameras() throws -> [String] {
+        var supportedCameras: [String] = [];
+        if let device = AVCaptureDevice.default(.builtInUltraWideCamera, for: AVMediaType.video, position: .back) {
+            supportedCameras.append("ultra")
+        }
+        if let device = AVCaptureDevice.default(.builtInWideAngleCamera, for: AVMediaType.video, position: .back) {
+            supportedCameras.append("wide")
+        }
+        if let device = AVCaptureDevice.default(.builtInTelephotoCamera, for: AVMediaType.video, position: .back) {
+            supportedCameras.append("tele")
+        }
+        return supportedCameras;
+    }
+    
+    func setFlashMode(flashMode: AVCaptureDevice.FlashMode) throws {
+        var currentCamera: AVCaptureDevice?
+        switch currentCameraPosition {
+        case .front:
+            currentCamera = self.frontCamera!
+        case .rear:
+            currentCamera = self.rearCamera!
+        default: break
+        }
+
+        guard let device = currentCamera else {
+            throw CameraControllerError.noCamerasAvailable
+        }
+
+        guard let supportedFlashModes: [AVCaptureDevice.FlashMode] = self.photoOutput?.supportedFlashModes else {
+            throw CameraControllerError.invalidOperation
+        }
+        if supportedFlashModes.contains(flashMode) {
+            do {
+                try device.lockForConfiguration()
+
+                if device.hasTorch && device.isTorchAvailable && device.torchMode == AVCaptureDevice.TorchMode.on {
+                    device.torchMode = AVCaptureDevice.TorchMode.off
+                }
+                self.flashMode = flashMode
+                let photoSettings = AVCapturePhotoSettings()
+                photoSettings.flashMode = flashMode
+                self.photoOutput?.photoSettingsForSceneMonitoring = photoSettings
+
+                device.unlockForConfiguration()
+            } catch {
+                throw CameraControllerError.invalidOperation
+            }
+        } else {
+            throw CameraControllerError.invalidOperation
+        }
+    }
+
+    func setTorchMode() throws {
+        var currentCamera: AVCaptureDevice?
+        switch currentCameraPosition {
+        case .front:
+            currentCamera = self.frontCamera!
+        case .rear:
+            currentCamera = self.rearCamera!
+        default: break
+        }
+
+        guard
+            let device = currentCamera,
+            device.hasTorch,
+            device.isTorchAvailable
+        else {
+            throw CameraControllerError.invalidOperation
+        }
+
+        do {
+            try device.lockForConfiguration()
+            if device.isTorchModeSupported(AVCaptureDevice.TorchMode.on) {
+                device.torchMode = AVCaptureDevice.TorchMode.on
+            } else if device.isTorchModeSupported(AVCaptureDevice.TorchMode.auto) {
+                device.torchMode = AVCaptureDevice.TorchMode.auto
+            } else {
+                device.torchMode = AVCaptureDevice.TorchMode.off
+            }
+            device.unlockForConfiguration()
+        } catch {
+            throw CameraControllerError.invalidOperation
+        }
+
+    }
+
+    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 {
+    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) {
+            self.photoCaptureCompletionBlock?(image.fixedOrientation(), nil)
+        } else {
+            self.photoCaptureCompletionBlock?(nil, CameraControllerError.unknown)
+        }
+    }
+}
+
+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
+    }
+}
+
+enum CameraControllerError: Swift.Error {
+    case captureSessionAlreadyRunning
+    case captureSessionIsMissing
+    case inputsAreInvalid
+    case invalidOperation
+    case noCamerasAvailable
+    case unknown
+}
+
+public enum CameraPosition {
+    case front
+    case rear
+}
+
+extension CameraControllerError: LocalizedError {
+    public var errorDescription: String? {
+        switch self {
+        case .captureSessionAlreadyRunning:
+            return NSLocalizedString("Capture Session is Already Running", comment: "Capture Session Already Running")
+        case .captureSessionIsMissing:
+            return NSLocalizedString("Capture Session is Missing", comment: "Capture Session Missing")
+        case .inputsAreInvalid:
+            return NSLocalizedString("Inputs Are Invalid", comment: "Inputs Are Invalid")
+        case .invalidOperation:
+            return NSLocalizedString("Invalid Operation", comment: "invalid Operation")
+        case .noCamerasAvailable:
+            return NSLocalizedString("Failed to access device camera(s)", comment: "No Cameras Available")
+        case .unknown:
+            return NSLocalizedString("Unknown", comment: "Unknown")
+
+        }
+    }
+}
+
+extension UIImage {
+
+    func fixedOrientation() -> UIImage? {
+
+        guard imageOrientation != UIImage.Orientation.up else {
+            // This is default orientation, don't need to do anything
+            return self.copy() as? UIImage
+        }
+
+        guard let cgImage = self.cgImage else {
+            // CGImage is not available
+            return nil
+        }
+
+        guard let colorSpace = cgImage.colorSpace, let ctx = CGContext(data: nil, width: Int(size.width), height: Int(size.height), bitsPerComponent: cgImage.bitsPerComponent, bytesPerRow: 0, space: colorSpace, bitmapInfo: CGImageAlphaInfo.premultipliedLast.rawValue) else {
+            return nil // Not able to create CGContext
+        }
+
+        var transform: CGAffineTransform = CGAffineTransform.identity
+        switch imageOrientation {
+        case .down, .downMirrored:
+            transform = transform.translatedBy(x: size.width, y: size.height)
+            transform = transform.rotated(by: CGFloat.pi)
+            print("down")
+            break
+        case .left, .leftMirrored:
+            transform = transform.translatedBy(x: size.width, y: 0)
+            transform = transform.rotated(by: CGFloat.pi / 2.0)
+            print("left")
+            break
+        case .right, .rightMirrored:
+            transform = transform.translatedBy(x: 0, y: size.height)
+            transform = transform.rotated(by: CGFloat.pi / -2.0)
+            print("right")
+            break
+        case .up, .upMirrored:
+            break
+        }
+
+        // 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)
+            break
+        case .leftMirrored, .rightMirrored:
+            transform.translatedBy(x: size.height, y: 0)
+            transform.scaledBy(x: -1, y: 1)
+        case .up, .down, .left, .right:
+            break
+        }
+
+        ctx.concatenate(transform)
+
+        switch imageOrientation {
+        case .left, .leftMirrored, .right, .rightMirrored:
+            ctx.draw(self.cgImage!, in: CGRect(x: 0, y: 0, width: size.height, height: size.width))
+        default:
+            ctx.draw(self.cgImage!, in: CGRect(x: 0, y: 0, width: size.width, height: size.height))
+            break
+        }
+        guard let newCGImage = ctx.makeImage() else { return nil }
+        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/Info.plist

@@ -0,0 +1,24 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+	<key>CFBundleDevelopmentRegion</key>
+	<string>$(DEVELOPMENT_LANGUAGE)</string>
+	<key>CFBundleExecutable</key>
+	<string>$(EXECUTABLE_NAME)</string>
+	<key>CFBundleIdentifier</key>
+	<string>$(PRODUCT_BUNDLE_IDENTIFIER)</string>
+	<key>CFBundleInfoDictionaryVersion</key>
+	<string>6.0</string>
+	<key>CFBundleName</key>
+	<string>$(PRODUCT_NAME)</string>
+	<key>CFBundlePackageType</key>
+	<string>FMWK</string>
+	<key>CFBundleShortVersionString</key>
+	<string>1.0</string>
+	<key>CFBundleVersion</key>
+	<string>$(CURRENT_PROJECT_VERSION)</string>
+	<key>NSPrincipalClass</key>
+	<string></string>
+</dict>
+</plist>

package/ios/Plugin/Plugin.h

@@ -0,0 +1,10 @@
+#import <UIKit/UIKit.h>
+
+//! Project version number for Plugin.
+FOUNDATION_EXPORT double PluginVersionNumber;
+
+//! Project version string for Plugin.
+FOUNDATION_EXPORT const unsigned char PluginVersionString[];
+
+// In this header, you should import all the public headers of your framework using statements like #import <Plugin/PublicHeader.h>
+