@aigens/aigens-sdk-core 0.0.1 → 0.0.5

package/ios/Plugin/CorePlugin.swift

@@ -1,18 +1,732 @@
 import Foundation
 import Capacitor
+import AVFoundation
+import UIKit
 
 /**
  * Please read the Capacitor iOS Plugin Development Guide
  * here: https://capacitorjs.com/docs/plugins/ios
  */
 @objc(CorePlugin)
-public class CorePlugin: CAPPlugin {
+public class CorePlugin: CAPPlugin, AVCaptureMetadataOutputObjectsDelegate {
+    
     private let implementation = Core()
-
+    public static var member: Dictionary<String, Any>?
+    
     @objc func echo(_ call: CAPPluginCall) {
+
         let value = call.getString("value") ?? ""
         call.resolve([
             "value": implementation.echo(value)
         ])
+        
+       
+    }
+
+    @objc func getMember(_ call: CAPPluginCall) {
+
+        call.resolve([
+            "member": CorePlugin.member!
+        ])
+    }
+
+    @objc func finish(_ call: CAPPluginCall) {
+
+        DispatchQueue.main.async {
+            self.bridge?.viewController?.dismiss(animated: true);
+        }
+
+
+        //let value = call.getString("value") ?? ""
+        call.resolve([
+            "success": true
+            //"value": implementation.echo(value)
+        ])
     }
+
+    @objc func scan(_ call: CAPPluginCall) {
+
+        let cancelButton = call.getString("cancelButton")
+        if(cancelButton != nil){
+            self.cancelText = cancelButton!
+        }else{
+            self.cancelText = "Cancel"
+        }
+
+        DispatchQueue.main.async {
+            self.loadScan()
+            self.startScan(call)
+        }
+    }
+
+
+    @objc func openBrowser(_ call: CAPPluginCall) {
+
+        let url = call.getString("url")
+
+
+        if(url == nil){
+            return
+        }
+        
+        let member = call.getObject("member")
+        
+        DispatchQueue.main.async {
+
+            let bridgeVC = WebContainerViewController()
+
+            var options = [String: AnyObject]()
+            options["url"] = url as AnyObject;
+            
+            if(member != nil){
+                options["member"] = member as AnyObject;
+            }
+            
+            bridgeVC.options = options;
+
+            bridgeVC.modalPresentationStyle = .fullScreen
+            let currentVC = self.bridge?.viewController;
+            currentVC?.present(bridgeVC, animated: true);
+        }
+
+
+        call.resolve([
+            "success": true
+            //"value": implementation.echo(value)
+        ])
+    }
+
+    //SCAN PLAUGIN HERE
+
+    class CameraView: UIView {
+        var videoPreviewLayer:AVCaptureVideoPreviewLayer?
+
+        func interfaceOrientationToVideoOrientation(_ orientation : UIInterfaceOrientation) -> AVCaptureVideoOrientation {
+            switch (orientation) {
+            case UIInterfaceOrientation.portrait:
+                return AVCaptureVideoOrientation.portrait
+            case UIInterfaceOrientation.portraitUpsideDown:
+                return AVCaptureVideoOrientation.portraitUpsideDown
+            case UIInterfaceOrientation.landscapeLeft:
+                return AVCaptureVideoOrientation.landscapeLeft
+            case UIInterfaceOrientation.landscapeRight:
+                return AVCaptureVideoOrientation.landscapeRight
+            default:
+                return AVCaptureVideoOrientation.portraitUpsideDown
+            }
+        }
+
+        override func layoutSubviews() {
+            super.layoutSubviews()
+            if let sublayers = self.layer.sublayers {
+                for layer in sublayers {
+                    layer.frame = self.bounds
+                }
+            }
+
+            self.videoPreviewLayer?.connection?.videoOrientation = interfaceOrientationToVideoOrientation(UIApplication.shared.statusBarOrientation)
+        }
+
+
+        func addPreviewLayer(_ previewLayer:AVCaptureVideoPreviewLayer?) {
+            previewLayer!.videoGravity = AVLayerVideoGravity.resizeAspectFill
+            previewLayer!.frame = self.bounds
+            self.layer.addSublayer(previewLayer!)
+            self.videoPreviewLayer = previewLayer
+        }
+
+        func removePreviewLayer() {
+            if self.videoPreviewLayer != nil {
+                self.videoPreviewLayer!.removeFromSuperlayer()
+                self.videoPreviewLayer = nil
+            }
+        }
+    }
+
+    var cameraView: CameraView!
+    var cancelButton: UIButton!
+    var captureSession:AVCaptureSession?
+    var captureVideoPreviewLayer:AVCaptureVideoPreviewLayer?
+    var metaOutput: AVCaptureMetadataOutput?
+
+    var currentCamera: Int = 0
+    var frontCamera: AVCaptureDevice?
+    var backCamera: AVCaptureDevice?
+
+    var cancelText: String = "Cancel"
+    var isScanning: Bool = false
+    var shouldRunScan: Bool = false
+    var didRunCameraSetup: Bool = false
+    var didRunCameraPrepare: Bool = false
+    var isBackgroundHidden: Bool = false
+
+    var savedCall: CAPPluginCall? = nil
+    var scanningPaused: Bool = false
+    var lastScanResult: String? = nil
+
+    enum SupportedFormat: String, CaseIterable {
+        // 1D Product
+        //!\ UPC_A is part of EAN_13 according to Apple docs
+        case UPC_E
+        //!\ UPC_EAN_EXTENSION is not supported by AVFoundation
+        case EAN_8
+        case EAN_13
+        // 1D Industrial
+        case CODE_39
+        case CODE_39_MOD_43
+        case CODE_93
+        case CODE_128
+        //!\ CODABAR is not supported by AVFoundation
+        case ITF
+        case ITF_14
+        // 2D
+        case AZTEC
+        case DATA_MATRIX
+        //!\ MAXICODE is not supported by AVFoundation
+        case PDF_417
+        case QR_CODE
+        //!\ RSS_14 is not supported by AVFoundation
+        //!\ RSS_EXPANDED is not supported by AVFoundation
+
+        var value: AVMetadataObject.ObjectType {
+            switch self {
+                // 1D Product
+                case .UPC_E: return AVMetadataObject.ObjectType.upce
+                case .EAN_8: return AVMetadataObject.ObjectType.ean8
+                case .EAN_13: return AVMetadataObject.ObjectType.ean13
+                // 1D Industrial
+                case .CODE_39: return AVMetadataObject.ObjectType.code39
+                case .CODE_39_MOD_43: return AVMetadataObject.ObjectType.code39Mod43
+                case .CODE_93: return AVMetadataObject.ObjectType.code93
+                case .CODE_128: return AVMetadataObject.ObjectType.code128
+                case .ITF: return AVMetadataObject.ObjectType.interleaved2of5
+                case .ITF_14: return AVMetadataObject.ObjectType.itf14
+                // 2D
+                case .AZTEC: return AVMetadataObject.ObjectType.aztec
+                case .DATA_MATRIX: return AVMetadataObject.ObjectType.dataMatrix
+                case .PDF_417: return AVMetadataObject.ObjectType.pdf417
+                case .QR_CODE: return AVMetadataObject.ObjectType.qr
+            }
+        }
+    }
+
+    var targetedFormats = [AVMetadataObject.ObjectType]()
+
+    enum CaptureError: Error {
+        case backCameraUnavailable
+        case frontCameraUnavailable
+        case couldNotCaptureInput(error: NSError)
+    }
+
+    @objc func buttonTapped( _ button : UIButton)
+    {
+
+        self.destroy()
+    }
+
+
+
+    private func loadScan() {
+
+        if(self.cameraView != nil){
+            return
+        }
+
+
+        self.cameraView = CameraView(frame: CGRect(x: 0, y: 0, width: UIScreen.main.bounds.width, height: UIScreen.main.bounds.height))
+        self.cameraView.autoresizingMask = [.flexibleWidth, .flexibleHeight]
+
+        let button = UIButton()
+        //button.backgroundColor = UIColor.orange
+
+        //let iconImage = UIImage(named: "search")
+        //button.setImage(iconImage, for: .normal)
+
+        button.setTitle("< " + self.cancelText, for: .normal)
+        button.contentMode = UIView.ContentMode.scaleToFill
+        button.frame = CGRect(x: 20, y: 10, width:200 , height:100)
+        button.titleLabel?.textColor = UIColor.white
+        button.contentHorizontalAlignment = .left
+
+        button.addTarget(self, action: #selector(self.buttonTapped(_:)), for: UIControl.Event.touchUpInside)
+
+        self.cancelButton = button
+
+    }
+
+    private func hasCameraPermission() -> Bool {
+        let status = AVCaptureDevice.authorizationStatus(for: AVMediaType.video)
+        if (status == AVAuthorizationStatus.authorized) {
+            return true
+        }
+        return false
+    }
+
+    private func addViews(){
+        self.webView!.superview!.insertSubview(cameraView, aboveSubview: self.webView!)
+        self.webView!.superview!.insertSubview(cancelButton, aboveSubview: cameraView)
+    }
+
+    private func removeViews(){
+
+        DispatchQueue.main.async {
+            self.cancelButton.removeFromSuperview()
+            self.cameraView.removeFromSuperview()
+        }
+
+    }
+
+    private func setupCamera(cameraDirection: String? = "back") -> Bool {
+        do {
+            var cameraDir = cameraDirection
+            cameraView.backgroundColor = UIColor.clear
+            //self.webView!.superview!.insertSubview(cameraView, belowSubview: self.webView!)
+
+            //self.webView!.superview!.insertSubview(cameraView, aboveSubview: self.webView!)
+            //self.webView!.superview!.insertSubview(cancelButton, aboveSubview: cameraView)
+            addViews()
+
+            let availableVideoDevices =  discoverCaptureDevices()
+            for device in availableVideoDevices {
+                if device.position == AVCaptureDevice.Position.back {
+                    backCamera = device
+                }
+                else if device.position == AVCaptureDevice.Position.front {
+                    frontCamera = device
+                }
+            }
+            // older iPods have no back camera
+            if (cameraDir == "back") {
+                if (backCamera == nil) {
+                    cameraDir = "front"
+                }
+            } else {
+                if (frontCamera == nil) {
+                    cameraDir = "back"
+                }
+            }
+            let input: AVCaptureDeviceInput
+            input = try self.createCaptureDeviceInput(cameraDirection: cameraDir)
+            captureSession = AVCaptureSession()
+            captureSession!.addInput(input)
+            metaOutput = AVCaptureMetadataOutput()
+            captureSession!.addOutput(metaOutput!)
+            metaOutput!.setMetadataObjectsDelegate(self, queue: DispatchQueue.main)
+            captureVideoPreviewLayer = AVCaptureVideoPreviewLayer(session: captureSession!)
+            cameraView.addPreviewLayer(captureVideoPreviewLayer)
+            self.didRunCameraSetup = true
+            return true
+        } catch CaptureError.backCameraUnavailable {
+            //
+        } catch CaptureError.frontCameraUnavailable {
+            //
+        } catch CaptureError.couldNotCaptureInput {
+            //
+        } catch {
+            //
+        }
+        return false
+    }
+
+    @available(swift, deprecated: 5.6, message: "New Xcode? Check if `AVCaptureDevice.DeviceType` has new types and add them accordingly.")
+    private func discoverCaptureDevices() -> [AVCaptureDevice] {
+        if #available(iOS 13.0, *) {
+            return AVCaptureDevice.DiscoverySession(deviceTypes: [.builtInTripleCamera, .builtInDualCamera, .builtInTelephotoCamera, .builtInTrueDepthCamera, .builtInUltraWideCamera, .builtInDualWideCamera, .builtInWideAngleCamera], mediaType: .video, position: .unspecified).devices
+        } else {
+            return AVCaptureDevice.DiscoverySession(deviceTypes: [.builtInDualCamera, .builtInWideAngleCamera, .builtInTelephotoCamera, .builtInTrueDepthCamera], mediaType: .video, position: .unspecified).devices
+        }
+    }
+
+    private func createCaptureDeviceInput(cameraDirection: String? = "back") throws -> AVCaptureDeviceInput {
+        var captureDevice: AVCaptureDevice
+        if(cameraDirection == "back"){
+            if(backCamera != nil){
+                captureDevice = backCamera!
+            } else {
+                throw CaptureError.backCameraUnavailable
+            }
+        } else {
+            if(frontCamera != nil){
+                captureDevice = frontCamera!
+            } else {
+                throw CaptureError.frontCameraUnavailable
+            }
+        }
+        let captureDeviceInput: AVCaptureDeviceInput
+        do {
+            captureDeviceInput = try AVCaptureDeviceInput(device: captureDevice)
+        } catch let error as NSError {
+            throw CaptureError.couldNotCaptureInput(error: error)
+        }
+        return captureDeviceInput
+    }
+
+    private func dismantleCamera() {
+        // opposite of setupCamera
+
+        if (self.captureSession != nil) {
+            DispatchQueue.main.async {
+                self.captureSession!.stopRunning()
+                self.cameraView.removePreviewLayer()
+                self.captureVideoPreviewLayer = nil
+                self.metaOutput = nil
+                self.captureSession = nil
+                self.frontCamera = nil
+                self.backCamera = nil
+            }
+        }
+
+        self.isScanning = false
+        self.didRunCameraSetup = false
+        self.didRunCameraPrepare = false
+
+        // If a call is saved and a scan will not run, free the saved call
+        if (self.savedCall != nil && !self.shouldRunScan) {
+            self.savedCall = nil
+        }
+    }
+
+    private func prepare(_ call: CAPPluginCall? = nil) {
+        // undo previous setup
+        // because it may be prepared with a different config
+        self.dismantleCamera()
+
+        DispatchQueue.main.async {
+            // setup camera with new config
+            if (self.setupCamera(cameraDirection: call?.getString("cameraDirection") ?? "back")) {
+                // indicate this method was run
+                self.didRunCameraPrepare = true
+
+                if (self.shouldRunScan) {
+                    self.scan()
+                }
+            } else {
+                self.shouldRunScan = false
+            }
+        }
+    }
+
+    private func destroy() {
+
+        self.removeViews()
+
+        self.showBackground()
+
+        self.dismantleCamera()
+    }
+
+    private func scan() {
+        if (!self.didRunCameraPrepare) {
+            //In iOS 14 don't identify permissions needed, so force to ask it's better than nothing. Provisional.
+            var iOS14min: Bool = false
+            if #available(iOS 14.0, *) { iOS14min = true; }
+            if (!self.hasCameraPermission() && !iOS14min) {
+                // @TODO()
+                // requestPermission()
+            } else {
+                self.shouldRunScan = true
+                self.prepare(savedCall)
+            }
+        } else {
+            self.didRunCameraPrepare = false
+
+            self.shouldRunScan = false
+
+            targetedFormats = [AVMetadataObject.ObjectType]();
+
+            if ((savedCall?.options["targetedFormats"]) != nil) {
+                let _targetedFormats = savedCall?.getArray("targetedFormats", String.self)
+
+                if (_targetedFormats != nil && _targetedFormats?.count ?? 0 > 0) {
+                    _targetedFormats?.forEach { targetedFormat in
+                        if let value = SupportedFormat(rawValue: targetedFormat)?.value {
+                            print(value)
+                            targetedFormats.append(value)
+                        }
+                    }
+                }
+
+                if (targetedFormats.count == 0) {
+                    print("The property targetedFormats was not set correctly.")
+                }
+            }
+
+            if (targetedFormats.count == 0) {
+                for supportedFormat in SupportedFormat.allCases {
+                    targetedFormats.append(supportedFormat.value)
+                }
+            }
+
+            DispatchQueue.main.async {
+                self.metaOutput!.metadataObjectTypes = self.targetedFormats
+                self.captureSession!.startRunning()
+            }
+
+            self.hideBackground()
+
+            self.isScanning = true
+        }
+    }
+
+    private func hideBackground() {
+        /*
+        DispatchQueue.main.async {
+            self.bridge?.webView!.isOpaque = false
+            self.bridge?.webView!.backgroundColor = UIColor.clear
+            self.bridge?.webView!.scrollView.backgroundColor = UIColor.clear
+
+            let javascript = "document.documentElement.style.backgroundColor = 'transparent'"
+
+            self.bridge?.webView!.evaluateJavaScript(javascript)
+        }*/
+    }
+
+    private func showBackground() {
+
+        /*
+        DispatchQueue.main.async {
+            let javascript = "document.documentElement.style.backgroundColor = ''"
+
+            self.bridge?.webView!.evaluateJavaScript(javascript) { (result, error) in
+                self.bridge?.webView!.isOpaque = true
+                self.bridge?.webView!.backgroundColor = UIColor.white
+                self.bridge?.webView!.scrollView.backgroundColor = UIColor.white
+            }
+        }*/
+    }
+
+    // This method processes metadataObjects captured by iOS.
+    public func metadataOutput(_ captureOutput: AVCaptureMetadataOutput, didOutput metadataObjects: [AVMetadataObject], from connection: AVCaptureConnection) {
+
+        if (metadataObjects.count == 0 || !self.isScanning) {
+            // while nothing is detected, or if scanning is false, do nothing.
+            return
+        }
+
+        let found = metadataObjects[0] as! AVMetadataMachineReadableCodeObject
+        if (targetedFormats.contains(found.type)) {
+            var jsObject = PluginCallResultData()
+
+            if (found.stringValue != nil) {
+                jsObject["hasContent"] = true
+                jsObject["content"] = found.stringValue
+                jsObject["format"] = formatStringFromMetadata(found.type)
+            } else {
+                jsObject["hasContent"] = false
+            }
+
+            if (savedCall != nil) {
+                if (savedCall!.keepAlive) {
+                    if (!scanningPaused && found.stringValue != lastScanResult ) {
+                        lastScanResult = found.stringValue
+                        savedCall!.resolve(jsObject)
+                    }
+                } else {
+                    savedCall!.resolve(jsObject)
+                    savedCall = nil
+                    destroy()
+                }
+            } else {
+                self.destroy()
+            }
+        }
+    }
+
+    private func formatStringFromMetadata(_ type: AVMetadataObject.ObjectType) -> String {
+            switch type {
+            case AVMetadataObject.ObjectType.upce:
+                return "UPC_E"
+            case AVMetadataObject.ObjectType.ean8:
+                return "EAN_8"
+            case AVMetadataObject.ObjectType.ean13:
+                return "EAN_13"
+            case AVMetadataObject.ObjectType.code39:
+                return "CODE_39"
+            case AVMetadataObject.ObjectType.code39Mod43:
+                return "CODE_39_MOD_43"
+            case AVMetadataObject.ObjectType.code93:
+                return "CODE_93"
+            case AVMetadataObject.ObjectType.code128:
+                return "CODE_128"
+            case AVMetadataObject.ObjectType.interleaved2of5:
+                return "ITF"
+            case AVMetadataObject.ObjectType.itf14:
+                return "ITF_14"
+            case AVMetadataObject.ObjectType.aztec:
+                return "AZTEC"
+            case AVMetadataObject.ObjectType.dataMatrix:
+                return "DATA_MATRIX"
+            case AVMetadataObject.ObjectType.pdf417:
+                return "PDF_417"
+            case AVMetadataObject.ObjectType.qr:
+                return "QR_CODE"
+            default:
+                return type.rawValue
+            }
+        }
+
+    @objc func prepare(_ call: CAPPluginCall) {
+        self.prepare()
+        call.resolve()
+    }
+
+    @objc func hideBackground(_ call: CAPPluginCall) {
+        self.hideBackground()
+        call.resolve()
+    }
+
+    @objc func showBackground(_ call: CAPPluginCall) {
+        self.showBackground()
+        call.resolve()
+    }
+
+    @objc func startScan(_ call: CAPPluginCall) {
+        self.savedCall = call
+        self.scan()
+    }
+
+    @objc func startScanning(_ call: CAPPluginCall) {
+        self.savedCall = call
+        self.savedCall?.keepAlive = true
+        scanningPaused = false
+        lastScanResult = nil
+        self.scan()
+    }
+
+    @objc func pauseScanning(_ call: CAPPluginCall) {
+        scanningPaused = true
+        call.resolve()
+    }
+
+    @objc func resumeScanning(_ call: CAPPluginCall) {
+        scanningPaused = false
+        call.resolve()
+    }
+
+    @objc func stopScan(_ call: CAPPluginCall) {
+        if ((call.getBool("resolveScan") ?? false) && self.savedCall != nil) {
+            var jsObject = PluginCallResultData()
+            jsObject["hasContent"] = false
+
+            savedCall?.resolve(jsObject)
+            savedCall = nil
+        }
+
+        self.destroy()
+        call.resolve()
+    }
+
+    @objc func checkPermission(_ call: CAPPluginCall) {
+        let force = call.getBool("force") ?? false
+
+        var savedReturnObject = PluginCallResultData()
+
+        DispatchQueue.main.async {
+            switch AVCaptureDevice.authorizationStatus(for: .video) {
+                case .authorized:
+                    savedReturnObject["granted"] = true
+                case .denied:
+                    savedReturnObject["denied"] = true
+                case .notDetermined:
+                    savedReturnObject["neverAsked"] = true
+                case .restricted:
+                    savedReturnObject["restricted"] = true
+                @unknown default:
+                    savedReturnObject["unknown"] = true
+            }
+
+            if (force && savedReturnObject["neverAsked"] != nil) {
+                savedReturnObject["asked"] = true
+
+                AVCaptureDevice.requestAccess(for: .video) { (authorized) in
+                    if (authorized) {
+                        savedReturnObject["granted"] = true
+                    } else {
+                        savedReturnObject["denied"] = true
+                    }
+                    call.resolve(savedReturnObject)
+                }
+            } else {
+                call.resolve(savedReturnObject)
+            }
+        }
+    }
+
+    /*
+    @objc func openAppSettings(_ call: CAPPluginCall) {
+      guard let settingsUrl = URL(string: UIApplication.openSettingsURLString) else {
+          return
+      }
+
+      DispatchQueue.main.async {
+          if UIApplication.shared.canOpenURL(settingsUrl) {
+              UIApplication.shared.open(settingsUrl, completionHandler: { (success) in
+                  call.resolve()
+              })
+          }
+      }
+    }
+    */
+
+    @objc func enableTorch(_ call: CAPPluginCall) {
+        guard let device = AVCaptureDevice.default(for: AVMediaType.video) else { return }
+        guard device.hasTorch else { return }
+        guard device.isTorchAvailable else { return }
+
+        do {
+            try device.lockForConfiguration()
+
+            do {
+                try device.setTorchModeOn(level: 1.0)
+            } catch {
+                print(error)
+            }
+
+            device.unlockForConfiguration()
+        } catch {
+            print(error)
+        }
+
+        call.resolve()
+    }
+
+    @objc func disableTorch(_ call: CAPPluginCall) {
+        guard let device = AVCaptureDevice.default(for: AVMediaType.video) else { return }
+        guard device.hasTorch else { return }
+        guard device.isTorchAvailable else { return }
+
+        do {
+            try device.lockForConfiguration()
+            device.torchMode = .off
+
+            device.unlockForConfiguration()
+        } catch {
+            print(error)
+        }
+
+        call.resolve()
+    }
+
+    @objc func toggleTorch(_ call: CAPPluginCall) {
+        guard let device = AVCaptureDevice.default(for: AVMediaType.video) else { return }
+        guard device.hasTorch else { return }
+        guard device.isTorchAvailable else { return }
+
+        if (device.torchMode == .on) {
+            self.disableTorch(call)
+        } else {
+            self.enableTorch(call)
+        }
+    }
+
+    @objc func getTorchState(_ call: CAPPluginCall) {
+        guard let device = AVCaptureDevice.default(for: AVMediaType.video) else { return }
+
+        var result = PluginCallResultData()
+
+        result["isEnabled"] = device.torchMode == .on
+
+        call.resolve(result)
+    }
+
 }