capacitor-camera-module 0.0.39 → 0.0.40

package/android/src/main/java/com/eddieagvictoria/cameramodule/CameraModulePlugin.java

@@ -700,7 +700,7 @@ public class CameraModulePlugin extends Plugin {
                 imageCapture,
                 imageAnalysis
             );
-    
+
         });
     }
 
@@ -754,6 +754,7 @@ public class CameraModulePlugin extends Plugin {
 
                     }
 
+
                     if (barcodeScanner != null) {
                             barcodeScanner.close();
                             barcodeScanner = null;

package/ios/Sources/CameraModulePlugin/CameraModulePlugin.swift

@@ -1,23 +1,284 @@
-import Foundation
 import Capacitor
+import AVFoundation
+import Vision
+import UIKit
 
-/**
- * Please read the Capacitor iOS Plugin Development Guide
- * here: https://capacitorjs.com/docs/plugins/ios
- */
 @objc(CameraModulePlugin)
-public class CameraModulePlugin: CAPPlugin, CAPBridgedPlugin {
-    public let identifier = "CameraModulePlugin"
-    public let jsName = "CameraModule"
-    public let pluginMethods: [CAPPluginMethod] = [
-        CAPPluginMethod(name: "echo", returnType: CAPPluginReturnPromise)
-    ]
-    private let implementation = CameraModule()
-
-    @objc func echo(_ call: CAPPluginCall) {
-        let value = call.getString("value") ?? ""
+public class CameraModulePlugin: CAPPlugin,
+    AVCaptureVideoDataOutputSampleBufferDelegate {
+
+    private var previewView: UIView?
+    private var captureSession: AVCaptureSession?
+    private var videoPreviewLayer: AVCaptureVideoPreviewLayer?
+
+    private var photoOutput = AVCapturePhotoOutput()
+    private var isScanning = false
+    private var scanCall: CAPPluginCall?
+
+    private var photoDelegate: PhotoDelegate?
+
+    private var barcodeRequest: VNDetectBarcodesRequest?
+
+    private var videoDataOutput: AVCaptureVideoDataOutput?
+
+    private var lastScannedValue: String?
+    private var lastScanTime: Date?
+    private let scanDebounceInterval: TimeInterval = 0.5 // medio segundo
+
+
+    // MARK: - Lifecycle
+
+    public override func load() {
+        bridge?.webView?.isOpaque = false
+        bridge?.webView?.backgroundColor = .clear
+    }
+
+    // MARK: - Permissions
+
+    @objc func checkPermission(_ call: CAPPluginCall) {
+        let status = AVCaptureDevice.authorizationStatus(for: .video)
+
         call.resolve([
-            "value": implementation.echo(value)
+            "granted": status == .authorized,
+            "status": status == .authorized ? "granted" : "prompt"
         ])
     }
+
+    @objc func requestPermission(_ call: CAPPluginCall) {
+        AVCaptureDevice.requestAccess(for: .video) { granted in
+            DispatchQueue.main.async {
+                call.resolve([
+                    "granted": granted,
+                    "status": granted ? "granted" : "denied"
+                ])
+            }
+        }
+    }
+
+    // MARK: - Camera Preview
+
+    @objc func startPreview(_ call: CAPPluginCall) {
+        DispatchQueue.main.async {
+
+            if self.previewView != nil {
+                call.resolve()
+                return
+            }
+
+            let session = AVCaptureSession()
+            session.sessionPreset = .photo
+
+            guard let camera = AVCaptureDevice.default(.builtInWideAngleCamera,
+                                                       for: .video,
+                                                       position: .back),
+                  let input = try? AVCaptureDeviceInput(device: camera)
+            else {
+                call.reject("Camera not available")
+                return
+            }
+
+            session.addInput(input)
+            session.addOutput(self.photoOutput)
+
+            let view = UIView(frame: UIScreen.main.bounds)
+            let previewLayer = AVCaptureVideoPreviewLayer(session: session)
+            previewLayer.videoGravity = .resizeAspectFill
+            previewLayer.frame = view.bounds
+
+            view.layer.addSublayer(previewLayer)
+
+            self.bridge?.viewController?.view.insertSubview(view, at: 0)
+
+            self.previewView = view
+            self.videoPreviewLayer = previewLayer
+            self.captureSession = session
+
+            session.startRunning()
+            call.resolve()
+        }
+    }
+
+    @objc func stopPreview(_ call: CAPPluginCall) {
+        DispatchQueue.main.async {
+
+            self.captureSession?.stopRunning()
+            self.captureSession = nil
+
+            self.videoPreviewLayer?.removeFromSuperlayer()
+            self.videoPreviewLayer = nil
+
+            self.previewView?.removeFromSuperview()
+            self.previewView = nil
+
+            call.resolve()
+        }
+    }
+
+    // MARK: - Flash
+
+    @objc func toggleFlash(_ call: CAPPluginCall) {
+        guard let enable = call.getBool("enable") else {
+            call.reject("enable parameter is required")
+            return
+        }
+
+        guard let device = AVCaptureDevice.default(for: .video),
+              device.hasTorch
+        else {
+            call.reject("Flash not available")
+            return
+        }
+
+        do {
+            try device.lockForConfiguration()
+            device.torchMode = enable ? .on : .off
+            device.unlockForConfiguration()
+            call.resolve()
+        } catch {
+            call.reject("Flash error")
+        }
+    }
+
+    @objc func hasFlash(_ call: CAPPluginCall) {
+        let hasFlash = AVCaptureDevice.default(for: .video)?.hasTorch ?? false
+        call.resolve(["hasFlash": hasFlash])
+    }
+
+    // MARK: - Photo Capture
+
+    @objc func takePhotoBase64(_ call: CAPPluginCall) {
+
+        guard captureSession?.isRunning == true else {
+            call.reject("Camera not started")
+            return
+        }
+
+        let settings = AVCapturePhotoSettings()
+        settings.flashMode = .off
+
+        self.photoDelegate = PhotoDelegate { [weak self] base64 in
+            call.resolve([
+                "base64": base64,
+                "mimeType": "image/jpeg"
+            ])
+
+            self?.photoDelegate = nil
+        }
+
+        self.photoOutput.capturePhoto(
+            with: settings,
+            delegate: self.photoDelegate!
+        )
+    }
+
+
+    // MARK: - Barcode Scan
+
+    @objc func startBarcodeScan(_ call: CAPPluginCall) {
+
+        guard let session = captureSession else {
+            call.reject("Preview not started")
+            return
+        }
+
+        if isScanning {
+            call.reject("Already scanning")
+            return
+        }
+
+        isScanning = true
+        scanCall = call
+        call.keepAlive = true
+
+        barcodeRequest = VNDetectBarcodesRequest { request, _ in
+            guard let results = request.results as? [VNBarcodeObservation],
+                  let barcode = results.first,
+                  let value = barcode.payloadStringValue
+            else { return }
+
+            // Debounce
+            let now = Date()
+            if let last = self.lastScannedValue,
+               let lastTime = self.lastScanTime,
+               last == value && now.timeIntervalSince(lastTime) < self.scanDebounceInterval {
+                return
+            }
+
+            self.lastScannedValue = value
+            self.lastScanTime = now
+
+            self.isScanning = false
+            self.scanCall?.resolve([
+                "rawValue": value,
+                "format": barcode.symbology.rawValue
+            ])
+            self.scanCall?.keepAlive = false
+            self.scanCall = nil
+        }
+
+
+        if videoDataOutput == nil {
+            let output = AVCaptureVideoDataOutput()
+            output.setSampleBufferDelegate(self, queue: DispatchQueue(label: "barcode.queue"))
+            session.addOutput(output)
+            videoDataOutput = output
+        }
+    }
+
+    @objc func stopBarcodeScan(_ call: CAPPluginCall) {
+
+        isScanning = false
+
+        if let output = videoDataOutput,
+           let session = captureSession {
+            session.removeOutput(output)
+            videoDataOutput = nil
+        }
+
+        scanCall?.keepAlive = false
+        scanCall = nil
+
+        lastScannedValue = nil
+        lastScanTime = nil
+
+        call.resolve()
+    }
+
+
+    public func captureOutput(
+        _ output: AVCaptureOutput,
+        didOutput sampleBuffer: CMSampleBuffer,
+        from connection: AVCaptureConnection
+    ) {
+        guard isScanning,
+              let request = barcodeRequest
+        else { return }
+
+        guard let pixelBuffer = CMSampleBufferGetImageBuffer(sampleBuffer) else {
+            return
+        }
+
+        let handler = VNImageRequestHandler(
+            cvPixelBuffer: pixelBuffer,
+            orientation: cgOrientation(from: UIDevice.current.orientation),
+            options: [:]
+        )
+
+        do {
+            try handler.perform([request])
+        } catch {
+
+        }
+    }
+
+    func cgOrientation(from deviceOrientation: UIDeviceOrientation) -> CGImagePropertyOrientation {
+        switch deviceOrientation {
+        case .portrait: return .right
+        case .portraitUpsideDown: return .left
+        case .landscapeLeft: return .up
+        case .landscapeRight: return .down
+        default: return .right
+        }
+    }
+
 }

package/ios/Sources/CameraModulePlugin/PhotoDelegate.swift

@@ -0,0 +1,25 @@
+import AVFoundation
+import UIKit
+
+class PhotoDelegate: NSObject, AVCapturePhotoCaptureDelegate {
+
+
+    private let callback: (String) -> Void
+
+    init(callback: @escaping (String) -> Void) {
+        self.callback = callback
+    }
+
+    func photoOutput(_ output: AVCapturePhotoOutput,
+                     didFinishProcessingPhoto photo: AVCapturePhoto,
+                     error: Error?) {
+
+        guard let data = photo.fileDataRepresentation(),
+              let image = UIImage(data: data),
+              let jpeg = image.jpegData(compressionQuality: 0.8)
+        else { return }
+
+        let base64 = jpeg.base64EncodedString()
+        callback(base64)
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "capacitor-camera-module",
-  "version": "0.0.39",
+  "version": "0.0.40",
   "description": "Plugin to request permissiones view camera take phots",
   "main": "dist/plugin.cjs.js",
   "module": "dist/esm/index.js",