capacitor-camera-module 0.0.44 → 0.0.46

package/ios/Sources/CameraModulePlugin/CameraModulePlugin.swift

@@ -2,58 +2,68 @@ import Capacitor
 import AVFoundation
 import Vision
 import UIKit
-
+import Photos
 
 @objc(CameraModule)
 public class CameraModulePlugin: CAPPlugin,
-    AVCaptureVideoDataOutputSampleBufferDelegate {
+                                AVCaptureVideoDataOutputSampleBufferDelegate {
+
+    // MARK: - Camera
 
     private var previewView: UIView?
     private var captureSession: AVCaptureSession?
     private var videoPreviewLayer: AVCaptureVideoPreviewLayer?
+    private let photoOutput = AVCapturePhotoOutput()
+    private var photoDelegate: PhotoDelegate?
+
+    // MARK: - Barcode
 
-    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
+    private let scanDebounceInterval: TimeInterval = 0.5
 
+    // MARK: - Gallery
 
-    // MARK: - Lifecycle
+    private var galleryCall: CAPPluginCall?
 
-    public override func load() {
-        bridge?.webView?.isOpaque = false
-        bridge?.webView?.backgroundColor = .clear
+    // MARK: - Capacitor Bridge
 
-        CAP_PLUGIN_METHOD(checkPermission, CAPPluginReturnPromise)
-        CAP_PLUGIN_METHOD(requestPermission, CAPPluginReturnPromise)
+    public let pluginMethods: [CAPPluginMethod] = [
+        CAPPluginMethod(name: "checkPermission", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "requestPermission", returnType: CAPPluginReturnPromise),
 
-        CAP_PLUGIN_METHOD(startPreview, CAPPluginReturnPromise)
-        CAP_PLUGIN_METHOD(stopPreview, CAPPluginReturnPromise)
+        CAPPluginMethod(name: "checkGalleryPermission", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "requestGalleryPermission", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "checkAndRequestGalleryPermission", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "pickImageBase64", returnType: CAPPluginReturnPromise),
 
-        CAP_PLUGIN_METHOD(toggleFlash, CAPPluginReturnPromise)
-        CAP_PLUGIN_METHOD(hasFlash, CAPPluginReturnPromise)
+        CAPPluginMethod(name: "startPreview", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "stopPreview", returnType: CAPPluginReturnPromise),
 
-        CAP_PLUGIN_METHOD(takePhotoBase64, CAPPluginReturnPromise)
+        CAPPluginMethod(name: "toggleFlash", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "hasFlash", returnType: CAPPluginReturnPromise),
 
-        CAP_PLUGIN_METHOD(startBarcodeScan, CAPPluginReturnPromise)
-        CAP_PLUGIN_METHOD(stopBarcodeScan, CAPPluginReturnPromise)
-    }
+        CAPPluginMethod(name: "takePhotoBase64", returnType: CAPPluginReturnPromise),
+
+        CAPPluginMethod(name: "startBarcodeScan", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "stopBarcodeScan", returnType: CAPPluginReturnPromise)
+    ]
+
+    // MARK: - Lifecycle
 
+    public override func load() {
+        bridge?.webView?.isOpaque = false
+        bridge?.webView?.backgroundColor = .clear
+    }
 
-    // MARK: - Permissions
+    // MARK: - Camera Permission
 
     @objc func checkPermission(_ call: CAPPluginCall) {
         let status = AVCaptureDevice.authorizationStatus(for: .video)
-
         call.resolve([
             "granted": status == .authorized,
             "status": status == .authorized ? "granted" : "prompt"
@@ -71,11 +81,71 @@ public class CameraModulePlugin: CAPPlugin,
         }
     }
 
+    // MARK: - Gallery Permission
+
+    @objc func checkGalleryPermission(_ call: CAPPluginCall) {
+        let status = PHPhotoLibrary.authorizationStatus(for: .readWrite)
+
+        switch status {
+        case .authorized, .limited:
+            call.resolve(["granted": true, "status": "granted"])
+        case .notDetermined:
+            call.resolve(["granted": false, "status": "prompt"])
+        default:
+            call.resolve(["granted": false, "status": "denied"])
+        }
+    }
+
+    @objc func requestGalleryPermission(_ call: CAPPluginCall) {
+        PHPhotoLibrary.requestAuthorization(for: .readWrite) { status in
+            DispatchQueue.main.async {
+                let granted = (status == .authorized || status == .limited)
+                call.resolve([
+                    "granted": granted,
+                    "status": granted ? "granted" : "denied"
+                ])
+            }
+        }
+    }
+
+    @objc func checkAndRequestGalleryPermission(_ call: CAPPluginCall) {
+        let status = PHPhotoLibrary.authorizationStatus(for: .readWrite)
+        if status == .authorized || status == .limited {
+            call.resolve(["granted": true, "status": "granted"])
+        } else {
+            requestGalleryPermission(call)
+        }
+    }
+
+    // MARK: - Pick Image
+
+    @objc func pickImageBase64(_ call: CAPPluginCall) {
+        let status = PHPhotoLibrary.authorizationStatus(for: .readWrite)
+        guard status == .authorized || status == .limited else {
+            call.reject("Gallery permission not granted")
+            return
+        }
+
+        guard galleryCall == nil else {
+            call.reject("Gallery already open")
+            return
+        }
+
+        galleryCall = call
+
+        DispatchQueue.main.async {
+            let picker = UIImagePickerController()
+            picker.sourceType = .photoLibrary
+            picker.delegate = self
+            picker.modalPresentationStyle = .fullScreen
+            self.bridge?.viewController?.present(picker, animated: true)
+        }
+    }
+
     // MARK: - Camera Preview
 
     @objc func startPreview(_ call: CAPPluginCall) {
         DispatchQueue.main.async {
-
             if self.previewView != nil {
                 call.resolve()
                 return
@@ -84,11 +154,8 @@ public class CameraModulePlugin: CAPPlugin,
             let session = AVCaptureSession()
             session.sessionPreset = .photo
 
-            guard let camera = AVCaptureDevice.default(.builtInWideAngleCamera,
-                                                       for: .video,
-                                                       position: .back),
-                  let input = try? AVCaptureDeviceInput(device: camera)
-            else {
+            guard let device = AVCaptureDevice.default(.builtInWideAngleCamera, for: .video, position: .back),
+                  let input = try? AVCaptureDeviceInput(device: device) else {
                 call.reject("Camera not available")
                 return
             }
@@ -97,16 +164,15 @@ public class CameraModulePlugin: CAPPlugin,
             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)
+            let layer = AVCaptureVideoPreviewLayer(session: session)
+            layer.videoGravity = .resizeAspectFill
+            layer.frame = view.bounds
 
+            view.layer.addSublayer(layer)
             self.bridge?.viewController?.view.insertSubview(view, at: 0)
 
             self.previewView = view
-            self.videoPreviewLayer = previewLayer
+            self.videoPreviewLayer = layer
             self.captureSession = session
 
             session.startRunning()
@@ -116,16 +182,12 @@ public class CameraModulePlugin: CAPPlugin,
 
     @objc func stopPreview(_ call: CAPPluginCall) {
         DispatchQueue.main.async {
-
             self.captureSession?.stopRunning()
             self.captureSession = nil
-
             self.videoPreviewLayer?.removeFromSuperlayer()
-            self.videoPreviewLayer = nil
-
             self.previewView?.removeFromSuperview()
+            self.videoPreviewLayer = nil
             self.previewView = nil
-
             call.resolve()
         }
     }
@@ -133,14 +195,9 @@ public class CameraModulePlugin: CAPPlugin,
     // 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 {
+        guard let enable = call.getBool("enable"),
+              let device = AVCaptureDevice.default(for: .video),
+              device.hasTorch else {
             call.reject("Flash not available")
             return
         }
@@ -156,14 +213,14 @@ public class CameraModulePlugin: CAPPlugin,
     }
 
     @objc func hasFlash(_ call: CAPPluginCall) {
-        let hasFlash = AVCaptureDevice.default(for: .video)?.hasTorch ?? false
-        call.resolve(["hasFlash": hasFlash])
+        call.resolve([
+            "hasFlash": AVCaptureDevice.default(for: .video)?.hasTorch ?? false
+        ])
     }
 
     // MARK: - Photo Capture
 
     @objc func takePhotoBase64(_ call: CAPPluginCall) {
-
         guard captureSession?.isRunning == true else {
             call.reject("Camera not started")
             return
@@ -172,26 +229,20 @@ public class CameraModulePlugin: CAPPlugin,
         let settings = AVCapturePhotoSettings()
         settings.flashMode = .off
 
-        self.photoDelegate = PhotoDelegate { [weak self] base64 in
+        photoDelegate = PhotoDelegate { [weak self] base64 in
             call.resolve([
                 "base64": base64,
                 "mimeType": "image/jpeg"
             ])
-
             self?.photoDelegate = nil
         }
 
-        self.photoOutput.capturePhoto(
-            with: settings,
-            delegate: self.photoDelegate!
-        )
+        photoOutput.capturePhoto(with: settings, delegate: photoDelegate!)
     }
 
-
     // MARK: - Barcode Scan
 
     @objc func startBarcodeScan(_ call: CAPPluginCall) {
-
         guard let session = captureSession else {
             call.reject("Preview not started")
             return
@@ -207,23 +258,20 @@ public class CameraModulePlugin: CAPPlugin,
         call.keepAlive = true
 
         barcodeRequest = VNDetectBarcodesRequest { request, _ in
-            guard let results = request.results as? [VNBarcodeObservation],
-                  let barcode = results.first,
-                  let value = barcode.payloadStringValue
-            else { return }
+            guard let barcode = (request.results as? [VNBarcodeObservation])?.first,
+                  let value = barcode.payloadStringValue else { return }
 
-            // Debounce
             let now = Date()
-            if let last = self.lastScannedValue,
+            if self.lastScannedValue == value,
                let lastTime = self.lastScanTime,
-               last == value && now.timeIntervalSince(lastTime) < self.scanDebounceInterval {
+               now.timeIntervalSince(lastTime) < self.scanDebounceInterval {
                 return
             }
 
             self.lastScannedValue = value
             self.lastScanTime = now
-
             self.isScanning = false
+
             self.scanCall?.resolve([
                 "rawValue": value,
                 "format": barcode.symbology.rawValue
@@ -232,7 +280,6 @@ public class CameraModulePlugin: CAPPlugin,
             self.scanCall = nil
         }
 
-
         if videoDataOutput == nil {
             let output = AVCaptureVideoDataOutput()
             output.setSampleBufferDelegate(self, queue: DispatchQueue(label: "barcode.queue"))
@@ -242,59 +289,78 @@ public class CameraModulePlugin: CAPPlugin,
     }
 
     @objc func stopBarcodeScan(_ call: CAPPluginCall) {
-
         isScanning = false
-
-        if let output = videoDataOutput,
-           let session = captureSession {
+        if let output = videoDataOutput, let session = captureSession {
             session.removeOutput(output)
-            videoDataOutput = nil
         }
-
+        videoDataOutput = nil
         scanCall?.keepAlive = false
         scanCall = nil
-
-        lastScannedValue = nil
-        lastScanTime = nil
-
         call.resolve()
     }
 
-
-    public func captureOutput(
-        _ output: AVCaptureOutput,
-        didOutput sampleBuffer: CMSampleBuffer,
-        from connection: AVCaptureConnection
-    ) {
+    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 request = barcodeRequest,
+              let pixelBuffer = CMSampleBufferGetImageBuffer(sampleBuffer) else { return }
 
         let handler = VNImageRequestHandler(
             cvPixelBuffer: pixelBuffer,
-            orientation: cgOrientation(from: UIDevice.current.orientation),
+            orientation: .right,
             options: [:]
         )
 
-        do {
-            try handler.perform([request])
-        } catch {
+        try? handler.perform([request])
+    }
+}
+
+// MARK: - UIImagePicker Delegate
 
+extension CameraModulePlugin: UIImagePickerControllerDelegate, UINavigationControllerDelegate {
+
+    public func imagePickerController(_ picker: UIImagePickerController,
+                                      didFinishPickingMediaWithInfo info: [UIImagePickerController.InfoKey : Any]) {
+
+        picker.dismiss(animated: true)
+
+        guard let image = info[.originalImage] as? UIImage,
+              let resized = image.resized(maxSize: 1024),
+              let jpeg = resized.jpegData(compressionQuality: 0.8) else {
+            galleryCall?.reject("Unable to process image")
+            galleryCall = nil
+            return
         }
+
+        galleryCall?.resolve([
+            "base64": jpeg.base64EncodedString(),
+            "mimeType": "image/jpeg"
+        ])
+        galleryCall = nil
     }
 
-    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
-        }
+    public func imagePickerControllerDidCancel(_ picker: UIImagePickerController) {
+        picker.dismiss(animated: true)
+        galleryCall?.reject("Image selection canceled")
+        galleryCall = nil
     }
+}
+
+// MARK: - UIImage Resize
 
+extension UIImage {
+    func resized(maxSize: CGFloat) -> UIImage? {
+        let maxSide = max(size.width, size.height)
+        if maxSide <= maxSize { return self }
+
+        let scale = maxSize / maxSide
+        let newSize = CGSize(width: size.width * scale, height: size.height * scale)
+
+        UIGraphicsBeginImageContextWithOptions(newSize, false, 1)
+        draw(in: CGRect(origin: .zero, size: newSize))
+        let img = UIGraphicsGetImageFromCurrentImageContext()
+        UIGraphicsEndImageContext()
+        return img
+    }
 }

package/package.json

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