@biso_gmbh/capacitor-plugin-ml-kit-barcode-scanner 1.0.8

package/ios/Plugin/BarcodesAnalyzer.swift

@@ -0,0 +1,79 @@
+import MLKitBarcodeScanning
+import MLKitVision
+
+protocol BarcodesListener: NSObjectProtocol {
+    func onBarcodesFound(_ barcodes: [DetectedBarcode])
+}
+
+class BarcodeAnalyzer {
+    private var scanner: BarcodeScanner
+    private var cameraOverlay: CameraOverlay
+    private var barcodesListener: BarcodesListener
+    private var settings: ScannerSettings
+    
+    private var lastBarcodes: [DetectedBarcode] = []
+    private var stableCounter: Int = 0
+    
+    init(settings: ScannerSettings, barcodesListener: BarcodesListener, cameraOverlay:CameraOverlay) {
+        let barcodeFormats = MLKitBarcodeScanning.BarcodeFormat(rawValue: settings.barcodeFormats)
+        scanner = BarcodeScanner.barcodeScanner(options: BarcodeScannerOptions(formats: barcodeFormats))
+        self.cameraOverlay = cameraOverlay
+        self.barcodesListener = barcodesListener
+        self.settings = settings
+    }
+    
+    func analyze(in image: VisionImage, width: CGFloat, height: CGFloat) {
+        var barcodes: [Barcode] = []
+        do {
+            barcodes = try scanner.results(in: image)
+        } catch let error {
+            print(error.localizedDescription)
+        }
+        
+        var detectedBarcodes: [DetectedBarcode] = []
+        for barcode in barcodes {
+            let normalizedRect = CGRect(
+                x: barcode.frame.origin.x / width,
+                y: barcode.frame.origin.y / height,
+                width: barcode.frame.size.width / width,
+                height: barcode.frame.size.height / height
+            )
+            let convertedRect = cameraOverlay.previewLayer.layerRectConverted(fromMetadataOutputRect: normalizedRect)
+            
+            detectedBarcodes.append(DetectedBarcode(barcode: barcode, bounds: convertedRect, centerX: cameraOverlay.previewLayer.bounds.midX, centerY: cameraOverlay.previewLayer.bounds.midY))
+        }
+        
+        if (settings.debugOverlay) {
+            cameraOverlay.drawDebugOverlay(barcodes: detectedBarcodes)
+        }
+        
+        if (areBarcodesStable(barcodes: detectedBarcodes) && stableCounter >= settings.stableThreshold) {
+            var barcodesInScanArea: [DetectedBarcode] = []
+            for barcode in detectedBarcodes {
+                if (barcode.isInScanArea(scanArea: cameraOverlay.scanArea, ignoreRotated: settings.ignoreRotatedBarcodes)) {
+                    barcodesInScanArea.append(barcode)
+                }
+            }
+            barcodesInScanArea.sort {
+                $0.distanceToCenter < $1.distanceToCenter
+            }
+            if (!barcodesInScanArea.isEmpty) {
+                barcodesListener.onBarcodesFound(barcodesInScanArea)
+            }
+        }
+    }
+    
+    private func areBarcodesStable(barcodes: [DetectedBarcode]) -> Bool {
+        let barcodesSet = Set(barcodes)
+        let lastBarcodesSet = Set(lastBarcodes)
+        let differences = barcodesSet.subtracting(lastBarcodesSet)
+        if (!barcodes.isEmpty && differences.isEmpty) {
+            stableCounter += 1
+            print("barcodes stable for \(stableCounter)/\(settings.stableThreshold)")
+            return true
+        }
+        stableCounter = 0
+        lastBarcodes = barcodes
+        return false
+    }
+}

package/ios/Plugin/CameraOverlay.swift

@@ -0,0 +1,119 @@
+import AVFoundation
+import CoreVideo
+import UIKit
+
+class CameraOverlay: UIView {
+    private var lastFrame: CMSampleBuffer?
+    public private(set) var scanArea: CGRect
+    private var settings: ScannerSettings
+    public private(set) var previewLayer: AVCaptureVideoPreviewLayer!
+    
+    init(settings: ScannerSettings, parentView: UIView) {
+        
+        self.scanArea = Utils.calculateCGRect(height: parentView.bounds.height, width: parentView.bounds.width, scaleFactor: settings.detectorSize, aspectRatio: settings.aspectRatioF)
+        self.settings = settings
+        
+        super.init(frame: .zero)
+        
+        parentView.addSubview(self)
+        NSLayoutConstraint.activate([
+            self.topAnchor.constraint(equalTo: parentView.topAnchor),
+            self.leadingAnchor.constraint(equalTo: parentView.leadingAnchor),
+            self.trailingAnchor.constraint(equalTo: parentView.trailingAnchor),
+            self.bottomAnchor.constraint(equalTo: parentView.bottomAnchor),
+        ])
+        
+        self.translatesAutoresizingMaskIntoConstraints = false
+        self.contentMode = UIView.ContentMode.scaleAspectFill
+        self.isOpaque = false
+        self.backgroundColor = UIColor.clear
+    }
+    
+    required init?(coder: NSCoder) {
+        fatalError("init(coder:) has not been implemented")
+    }
+    
+    override func layoutSubviews() {
+        super.layoutSubviews()
+        self.setNeedsDisplay()
+    }
+    
+    override func draw(_ rect: CGRect) {
+        super.draw(rect)
+        self.scanArea = Utils.calculateCGRect(height: bounds.height, width: bounds.width, scaleFactor: settings.detectorSize, aspectRatio: settings.aspectRatioF)
+        if let context = UIGraphicsGetCurrentContext() {
+            drawScanArea(context: context)
+        }
+    }
+    
+    public func setPreviewLayer(_ previewLayer: AVCaptureVideoPreviewLayer) {
+        self.previewLayer = previewLayer
+    }
+    
+    public func drawDebugOverlay(barcodes: [DetectedBarcode]) {
+        weak var weakSelf = self
+        DispatchQueue.main.sync {
+            guard weakSelf != nil else {
+                return
+            }
+            for annotationView in self.subviews {
+                annotationView.removeFromSuperview()
+            }
+            for barcode in barcodes {
+                let rectangleView = UIView(frame: barcode.bounds)
+                rectangleView.layer.borderColor = UIColor.blue.cgColor
+                rectangleView.layer.borderWidth = 2
+                addSubview(rectangleView)
+                
+                let lineView = UIView(frame: barcode.getCenterLine())
+                
+                lineView.layer.borderColor = UIColor.red.cgColor
+                lineView.layer.borderWidth = 2
+                addSubview(lineView)
+            }
+        }
+    }
+    
+    private func drawScanArea(context: CGContext) {
+        if (settings.drawFocusBackground){
+            drawFocusBackground(context: context, color: settings.focusBackgroundUIColor, radius: settings.focusRectBorderRadius)
+        }
+        if (settings.drawFocusLine) {
+            drawFocusLine(context: context, color: settings.focusLineUIColor, thickness: settings.focusLineThickness)
+        }
+        if (settings.drawFocusRect) {
+            drawScanAreaOutline(context: context, color: settings.focusRectUIColor, thickness: settings.focusRectBorderThickness, radius: settings.focusRectBorderRadius)
+        }
+    }
+    
+    private func drawFocusLine(context: CGContext, color: UIColor, thickness: Int) {
+        context.setLineWidth(CGFloat(thickness))
+        context.setStrokeColor(color.cgColor)
+        context.beginPath()
+        context.move(to: CGPointMake(scanArea.minX, CGFloat(bounds.height/2)))
+        context.addLine(to: CGPointMake(scanArea.maxX, CGFloat(bounds.height/2)))
+        context.strokePath()
+        context.saveGState()
+    }
+    
+    private func drawScanAreaOutline(context: CGContext, color: UIColor, thickness: Int, radius: Int) {
+        let rounded = UIBezierPath(roundedRect: scanArea, cornerRadius: CGFloat(radius))
+        context.addPath(rounded.cgPath)
+        context.setLineWidth(CGFloat(thickness))
+        context.setStrokeColor(color.cgColor)
+        context.strokePath()
+        context.saveGState()
+    }
+    
+    private func drawFocusBackground(context: CGContext, color: UIColor, radius: Int) {
+        let rounded = UIBezierPath(roundedRect: scanArea, cornerRadius: CGFloat(radius))
+        color.setFill()
+        context.fill(bounds)
+        context.saveGState()
+        context.setBlendMode(.destinationOut)
+        context.addPath(rounded.cgPath)
+        context.fillPath()
+        context.saveGState()
+        context.setBlendMode(.normal)
+    }
+}

package/ios/Plugin/CameraViewController.swift

@@ -0,0 +1,301 @@
+import UIKit
+import SwiftUI
+import AVFoundation
+import MLImage
+import MLKitVision
+
+protocol CameraViewControllerDelegate: NSObjectProtocol {
+    func onComplete(_ result: [DetectedBarcode])
+    func onError(_ error: String)
+}
+
+class CameraViewController: UIViewController, BarcodesListener {
+    weak var delegate: CameraViewControllerDelegate?
+    private let captureSession = AVCaptureSession()
+    private let sessionQueue = DispatchQueue(label: "sessionQueue")
+    private var previewLayer = AVCaptureVideoPreviewLayer()
+    private var settings: ScannerSettings
+    private var cameraOverlay: CameraOverlay!
+    private var barcodeAnalyzer : BarcodeAnalyzer!
+    private var torchButton: UIButton?
+    private var finishedAlready: Bool = false // ensure we only actually finish once
+    
+    func onBarcodesFound(_ barcodes: [DetectedBarcode]) {
+        finishWithResult(barcodes)
+    }
+    
+    init(settings: ScannerSettings) {
+        self.settings = settings
+        super.init(nibName: nil, bundle: nil)
+    }
+    
+    required init?(coder: NSCoder) {
+        self.settings = ScannerSettings()
+        super.init(coder: coder)
+    }
+    
+    override func viewDidLoad() {
+        cameraOverlay = CameraOverlay(settings: settings, parentView: view)
+        barcodeAnalyzer = BarcodeAnalyzer(settings: settings, barcodesListener: self, cameraOverlay: cameraOverlay)
+        
+        if AVCaptureDevice.authorizationStatus(for: .video) == .authorized {
+            setupCaptureSession()
+            setupUI()
+            setOrientation()
+        } else {
+            AVCaptureDevice.requestAccess(for: .video, completionHandler: { (authorized) in
+                DispatchQueue.main.async {
+                    if authorized {
+                        self.setupCaptureSession()
+                        self.setupUI()
+                        self.setOrientation()
+                    } else {
+                        self.finishWithError("NO_CAMERA_PERMISSION")
+                    }
+                }
+            })
+        }
+    }
+    
+    override func viewWillAppear(_ animated: Bool) {
+        startSession()
+        // slight delay so the camera has time to load before we show the modal
+        while (!captureSession.isRunning) {
+            usleep(100)
+        }
+        usleep(150000)
+    }
+    
+    override func viewDidDisappear(_ animated: Bool) {
+        stopSession()
+    }
+    
+    override func viewWillTransition(to size: CGSize, with coordinator: UIViewControllerTransitionCoordinator) {
+        super.viewWillTransition(to: size, with: coordinator)
+        setOrientation()
+    }
+    
+    private func setOrientation() {
+        previewLayer.frame = CGRect(x: 0, y: 0, width: UIScreen.main.bounds.width, height: UIScreen.main.bounds.height)
+        
+        if #available(iOS 17.0, *) {
+            switch UIDevice.current.orientation {
+            case UIDeviceOrientation.portraitUpsideDown:
+                previewLayer.connection?.videoRotationAngle = 270
+            case UIDeviceOrientation.landscapeLeft:
+                previewLayer.connection?.videoRotationAngle = 0
+            case UIDeviceOrientation.landscapeRight:
+                previewLayer.connection?.videoRotationAngle = 180
+            case UIDeviceOrientation.portrait:
+                previewLayer.connection?.videoRotationAngle = 90
+            default:
+                break
+            }
+        } else {
+            switch UIDevice.current.orientation {
+            case UIDeviceOrientation.portraitUpsideDown:
+                previewLayer.connection?.videoOrientation = .portraitUpsideDown
+            case UIDeviceOrientation.landscapeLeft:
+                previewLayer.connection?.videoOrientation = .landscapeRight
+            case UIDeviceOrientation.landscapeRight:
+                previewLayer.connection?.videoOrientation = .landscapeLeft
+            case UIDeviceOrientation.portrait:
+                previewLayer.connection?.videoOrientation = .portrait
+            default:
+                break
+            }
+        }
+    }
+    
+    private func setupCaptureSession() {
+        guard let videoDevice = captureDevice() else {
+            finishWithError("NO_CAMERA")
+            return
+            
+        }
+        guard let videoDeviceInput = try? AVCaptureDeviceInput(device: videoDevice) else {
+            finishWithError("NO_CAMERA")
+            return
+            
+        }
+        guard captureSession.canAddInput(videoDeviceInput) else { return }
+        
+        captureSession.addInput(videoDeviceInput)
+        
+        previewLayer = AVCaptureVideoPreviewLayer(session: captureSession)
+        previewLayer.backgroundColor = UIColor.black.cgColor
+        previewLayer.frame = view.bounds
+        previewLayer.videoGravity = AVLayerVideoGravity.resizeAspectFill
+        
+        if #available(iOS 17.0, *) {
+            previewLayer.connection?.videoRotationAngle = 90
+        } else {
+            previewLayer.connection?.videoOrientation = .portrait
+        }
+        
+        let output = AVCaptureVideoDataOutput()
+        output.alwaysDiscardsLateVideoFrames = true
+        output.setSampleBufferDelegate(self, queue: DispatchQueue(label: "sampleQueue"))
+        
+        captureSession.addOutput(output)
+    }
+    
+    private func setupUI() {
+        view.layer.addSublayer(previewLayer)
+        cameraOverlay.setPreviewLayer(previewLayer)
+        view.bringSubviewToFront(cameraOverlay)
+        
+        torchButton = createTorchButton()
+    }
+    
+    private func createTorchButton() -> UIButton? {
+        if let device = AVCaptureDevice.default(for: AVMediaType.video) {
+            if device.hasTorch {
+                var conf = UIButton.Configuration.filled()
+                conf.contentInsets = NSDirectionalEdgeInsets(top: 10, leading: 10, bottom: 10, trailing: 10)
+                conf.background.cornerRadius = 25
+                conf.baseForegroundColor = UIColor.black
+                conf.baseBackgroundColor = UIColor.white
+                
+                if let image = UIImage(named: "flashlight")
+                {
+                    conf.image = image.scalePreservingAspectRatio(targetSize: CGSize(width: 30, height: 30))
+                }
+                let torchButton = UIButton(configuration: conf)
+                torchButton.alpha = 0.5
+                torchButton.addTarget(self, action: #selector(toggleFlash), for: UIControl.Event.touchUpInside)
+
+                view.addSubview(torchButton)
+                torchButton.translatesAutoresizingMaskIntoConstraints = false
+                NSLayoutConstraint.activate([
+                    torchButton.bottomAnchor.constraint(equalTo: self.view.safeAreaLayoutGuide.bottomAnchor, constant: -20),
+                    torchButton.trailingAnchor.constraint(equalTo: self.view.trailingAnchor, constant: -20),
+                    torchButton.widthAnchor.constraint(equalToConstant: 50),
+                    torchButton.heightAnchor.constraint(equalToConstant: 50)
+                ])
+                return torchButton
+            }
+        }
+        return nil
+    }
+    
+    @objc
+    private func toggleFlash() {
+        guard let device = AVCaptureDevice.default(for: AVMediaType.video) else { return }
+        guard device.hasTorch else { print("Torch isn't available"); return }
+        
+        do {
+            try device.lockForConfiguration()
+            
+            if (device.torchMode == AVCaptureDevice.TorchMode.on) {
+                device.torchMode = AVCaptureDevice.TorchMode.off
+                torchButton?.alpha = 0.5
+            } else {
+                do {
+                    try device.setTorchModeOn(level: 1.0)
+                    torchButton?.alpha = 1
+                } catch {
+                    print(error)
+                }
+            }
+            
+            device.unlockForConfiguration()
+        } catch {
+            print(error)
+        }
+    }
+    
+    private func captureDevice() -> AVCaptureDevice? {
+        let discoverySession = AVCaptureDevice.DiscoverySession(
+            deviceTypes: [.builtInWideAngleCamera],
+            mediaType: .video,
+            position: .unspecified
+        )
+        return discoverySession.devices.first { $0.position == .back }
+    }
+    
+    private func startSession() {
+        weak var weakSelf = self
+        sessionQueue.async {
+            guard let strongSelf = weakSelf else {return}
+            strongSelf.captureSession.startRunning()
+        }
+    }
+    
+    private func stopSession() {
+        weak var weakSelf = self
+        sessionQueue.async {
+            guard let strongSelf = weakSelf else {return}
+            strongSelf.captureSession.stopRunning()
+        }
+    }
+    
+    private func finishWithError(_ error: String) {
+        if (!finishedAlready) {
+            finishedAlready = true
+            delegate?.onError(error)
+        }
+    }
+    
+    private func finishWithResult(_ result: [DetectedBarcode]){
+        if (!finishedAlready) {
+            finishedAlready = true
+            delegate?.onComplete(result)
+        }
+    }
+}
+
+extension UIImage {
+    func scalePreservingAspectRatio(targetSize: CGSize) -> UIImage {
+        // Determine the scale factor that preserves aspect ratio
+        let widthRatio = targetSize.width / size.width
+        let heightRatio = targetSize.height / size.height
+        
+        let scaleFactor = min(widthRatio, heightRatio)
+        
+        // Compute the new image size that preserves aspect ratio
+        let scaledImageSize = CGSize(
+            width: size.width * scaleFactor,
+            height: size.height * scaleFactor
+        )
+
+        // Draw and return the resized UIImage
+        let renderer = UIGraphicsImageRenderer(
+            size: scaledImageSize
+        )
+
+        let scaledImage = renderer.image { _ in
+            self.draw(in: CGRect(
+                origin: .zero,
+                size: scaledImageSize
+            ))
+        }
+        return scaledImage
+    }
+}
+
+extension CameraViewController: AVCaptureVideoDataOutputSampleBufferDelegate {
+    
+    func captureOutput(_ output: AVCaptureOutput,didOutput sampleBuffer: CMSampleBuffer,from connection: AVCaptureConnection) {
+        guard let imageBuffer = CMSampleBufferGetImageBuffer(sampleBuffer) else {
+            print("Failed to get image buffer from sample buffer.")
+            return
+        }
+        
+        let visionImage = VisionImage(buffer: sampleBuffer)
+        let orientation = Utils.imageOrientation(fromDevicePosition: .back)
+        
+        visionImage.orientation = orientation
+        
+        guard let inputImage = MLImage(sampleBuffer: sampleBuffer) else {
+            print("Failed to create MLImage from sample buffer.")
+            return
+        }
+        inputImage.orientation = orientation
+        
+        let imageWidth = CGFloat(CVPixelBufferGetWidth(imageBuffer))
+        let imageHeight = CGFloat(CVPixelBufferGetHeight(imageBuffer))
+        
+        barcodeAnalyzer.analyze(in: visionImage, width: imageWidth, height: imageHeight)
+    }
+}

package/ios/Plugin/DetectedBarcode.swift

@@ -0,0 +1,70 @@
+import MLKitBarcodeScanning
+
+class DetectedBarcode: Hashable, Equatable, CustomDebugStringConvertible {
+    
+    var debugDescription: String {
+        var des: String = "\(type(of: self)) {"
+        for child in Mirror(reflecting: self).children {
+            if let propName = child.label {
+                des += "\n\t\(propName): \(child.value)"
+            }
+        }
+        
+        return des + "\n}"
+    }
+    
+    func hash(into hasher: inout Hasher) {
+        hasher.combine(value)
+        hasher.combine(barcodeType)
+        hasher.combine(format)
+        let _ = hasher.finalize()
+    }
+    
+    static func == (lhs: DetectedBarcode, rhs: DetectedBarcode) -> Bool {
+        return lhs.value.elementsEqual(rhs.value) && lhs.barcodeType == rhs.barcodeType && lhs.format == rhs.format
+    }
+    
+    public private(set) var bounds: CGRect
+    public private(set) var value: String
+    public private(set) var format: Int
+    public private(set) var barcodeType: Int
+    public private(set) var distanceToCenter: CGFloat
+    public private(set) var isPortrait: Bool
+    
+    init(barcode: Barcode, bounds: CGRect, centerX: CGFloat, centerY: CGFloat) {
+        format = barcode.format.rawValue
+        barcodeType = barcode.valueType.rawValue
+        self.bounds = bounds
+        if let rawValue = barcode.rawValue {
+            value = rawValue
+        } else {
+            value = String(data: barcode.rawData!, encoding: .ascii)!;
+        }
+        self.isPortrait = bounds.height > bounds.width
+        distanceToCenter = hypot((centerX - bounds.midX), (centerY - bounds.midY));
+    }
+    
+    public func isInScanArea(scanArea: CGRect, ignoreRotated: Bool) -> Bool {
+        if (ignoreRotated && isPortrait) {
+            return false
+        }
+        
+        return scanArea.contains(getCenterLine(forceScreenOrientation: ignoreRotated))
+    }
+    
+    public func getCenterLine(forceScreenOrientation: Bool = false) -> CGRect {
+        if (!forceScreenOrientation && isPortrait) {
+            return CGRect(x: bounds.midX, y: bounds.minY, width: 1, height: bounds.height)
+        }
+        return CGRect(x: bounds.minX, y: bounds.midY, width: bounds.width, height: 1)
+    }
+    
+    public func outputAsDictionary() -> [String: Any] {
+        return [
+            "value": value,
+            "type": BarcodeType.getFromInt(intValue: barcodeType)!.rawValue,
+            "format": BarcodeFormat.getFromInt(intValue: format)!.rawValue,
+            "distanceToCenter": round(distanceToCenter*100)/100.0
+        ]
+    }
+}

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/MlKitBarcodeScannerPlugin.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>
+

package/ios/Plugin/MlKitBarcodeScannerPlugin.m

@@ -0,0 +1,8 @@
+#import <Foundation/Foundation.h>
+#import <Capacitor/Capacitor.h>
+
+// Define the plugin using the CAP_PLUGIN Macro, and
+// each method the plugin supports using the CAP_PLUGIN_METHOD macro.
+CAP_PLUGIN(MlKitBarcodeScannerPlugin, "MlKitBarcodeScanner",
+           CAP_PLUGIN_METHOD(scan, CAPPluginReturnPromise);
+)

package/ios/Plugin/MlKitBarcodeScannerPlugin.swift

@@ -0,0 +1,69 @@
+import Foundation
+import Capacitor
+import AVFoundation
+
+@objc(MlKitBarcodeScannerPlugin)
+public class MlKitBarcodeScannerPlugin: CAPPlugin, CameraViewControllerDelegate {
+    private var call: CAPPluginCall?
+    private var settings: ScannerSettings!
+    private var player: AVAudioPlayer?
+    
+    @objc func scan(_ call: CAPPluginCall) {
+        let options = call.jsObjectRepresentation
+        self.call = call
+        settings = ScannerSettings(options: options)
+        
+        DispatchQueue.main.async {
+            let cameraViewController = CameraViewController(settings: self.settings)
+            cameraViewController.delegate = self
+            self.bridge!.viewController!.present(cameraViewController, animated: true)
+        }
+    }
+    
+    func onComplete(_ result: [DetectedBarcode]) {
+        weak var weakSelf = self
+        DispatchQueue.main.sync {
+            guard weakSelf != nil else {
+                return
+            }
+            self.bridge!.viewController!.dismiss(animated: true)
+        }
+        if (result.isEmpty) {
+            self.call!.reject("NO_BARCODE")
+            return
+        }
+        if (settings.vibrateOnSuccess) {
+            AudioServicesPlayAlertSoundWithCompletion(SystemSoundID(kSystemSoundID_Vibrate)) { }
+        }
+        if (settings.beepOnSuccess) {
+            if let audioData = NSDataAsset(name: "beep")?.data {
+                do {
+                    try AVAudioSession.sharedInstance().setCategory(.playback, mode: .default)
+                    try AVAudioSession.sharedInstance().setActive(true)
+                    
+                    player = try AVAudioPlayer(data: audioData)
+                    
+                    if let unwrappedPlayer = player {
+                        unwrappedPlayer.play()
+                    }
+                } catch let error {
+                    print(error.localizedDescription)
+                }
+            }
+        }
+        var resultBarcodes: [[String: Any]] = []
+        for detectedBarcode in result {
+            resultBarcodes.append(detectedBarcode.outputAsDictionary())
+        }
+        var output = JSObject()
+        output.updateValue(resultBarcodes, forKey: "barcodes")
+        self.call!.resolve(output)
+    }
+    
+    func onError(_ error: String) {
+        print("error occurred")
+        self.bridge!.viewController!.dismiss(animated: false)
+        print("controller dismissed")
+        self.call!.reject(error)
+    }
+}