capacitor-camera-view 2.0.1 → 2.1.0

package/ios/Sources/CameraViewPlugin/CameraViewPlugin.swift

@@ -5,24 +5,24 @@ import Foundation
 /// Please read the Capacitor iOS Plugin Development Guide
 /// here: https://capacitorjs.com/docs/plugins/ios
 @objc(CameraViewPlugin)
-public class CameraViewPlugin: CAPPlugin, CAPBridgedPlugin {
+public class CameraViewPlugin: CAPPlugin, CAPBridgedPlugin, CameraEventDelegate {
     public let identifier = "CameraViewPlugin"
     public let jsName = "CameraView"
-
+    
     /// Maps string flash mode values to AVCaptureDevice.FlashMode enum values.
     private let strToFlashModeMap: [String: AVCaptureDevice.FlashMode] = [
         "off": .off,
         "on": .on,
         "auto": .auto
     ]
-
+    
     /// Maps AVCaptureDevice.FlashMode enum values to string values.
     private let flashModeToStrMap: [AVCaptureDevice.FlashMode: String] = [
         .off: "off",
         .on: "on",
         .auto: "auto"
     ]
-
+    
     public let pluginMethods: [CAPPluginMethod] = [
         CAPPluginMethod(name: "start", returnType: CAPPluginReturnPromise),
         CAPPluginMethod(name: "stop", returnType: CAPPluginReturnPromise),
@@ -42,45 +42,29 @@ public class CameraViewPlugin: CAPPlugin, CAPBridgedPlugin {
         CAPPluginMethod(name: "checkPermissions", returnType: CAPPluginReturnPromise),
         CAPPluginMethod(name: "requestPermissions", returnType: CAPPluginReturnPromise)
     ]
-
+    
     private let implementation = CameraViewManager()
-    private var notificationObserver: NSObjectProtocol?
-
+    
     override public func load() {
-        // Add observer for barcode detection events
-        notificationObserver = NotificationCenter.default.addObserver(
-            forName: Notification.Name("barcodeDetected"),
-            object: nil,
-            queue: .main
-        ) { [weak self] notification in
-            guard let self = self,
-                  let barcodeData = notification.userInfo as? [String: Any] else {
-                return
-            }
-
-            // Emit event to JS
-            self.notifyListeners("barcodeDetected", data: barcodeData)
-        }
+        implementation.eventEmitter.delegate = self
     }
-
-    deinit {
-        if let observer = notificationObserver {
-            NotificationCenter.default.removeObserver(observer)
-        }
+    
+    public func cameraDidDetectBarcode(_ event: BarcodeDetectedEvent) {
+        notifyListeners("barcodeDetected", data: event.toDictionary())
     }
-
+    
     @objc func start(_ call: CAPPluginCall) {
         guard let webView = self.webView else {
             call.reject("Cannot find web view")
             return
         }
-
+        
         maybeRequestCameraAccess { [weak self] granted in
             guard granted else {
                 call.reject("Camera access denied")
                 return
             }
-
+            
             self?.implementation.startSession(
                 configuration: sessionConfigFromPluginCall(call),
                 webView: webView,
@@ -93,55 +77,69 @@ public class CameraViewPlugin: CAPPlugin, CAPBridgedPlugin {
                 })
         }
     }
-
+    
     @objc func stop(_ call: CAPPluginCall) {
         implementation.stopSession {
             call.resolve()
         }
     }
-
+    
     @objc func isRunning(_ call: CAPPluginCall) {
         call.resolve([
             "isRunning": implementation.isRunning()
         ])
     }
-
+    
     @objc func capture(_ call: CAPPluginCall) {
         let quality = call.getDouble("quality", 90.0)
         let saveToFile = call.getBool("saveToFile", false)
-
+        
         guard quality >= 0.0 && quality <= 100.0 else {
             call.reject("Quality must be between 0 and 100")
             return
         }
-
-        implementation.capturePhoto(completion: { (image, error) in
+        
+        // Use optimized Data-based capture to avoid double JPEG encoding
+        implementation.capturePhotoData(completion: { [weak self] (data, error) in
             if let error = error {
                 call.reject("Failed to capture image", nil, error)
                 return
             }
-
-            guard let image = image else {
+            
+            guard let originalData = data else {
                 call.reject("No image data")
                 return
             }
-
-            guard let imageData = image.jpegData(compressionQuality: quality / 100.0) else {
-                call.reject("Failed to compress image")
-                return
+            
+            // Determine final image data based on quality setting
+            // For quality >= 90%, use original camera JPEG data to avoid re-encoding
+            // For lower quality, re-encode to reduce file size
+            let imageData: Data
+            if quality >= 90.0 {
+                // Use original JPEG data from camera (avoids quality loss and CPU overhead)
+                imageData = originalData
+            } else {
+                // Re-encode at lower quality for smaller file size
+                guard let image = UIImage(data: originalData),
+                      let compressedData = image.jpegData(compressionQuality: quality / 100.0) else {
+                    call.reject("Failed to compress image")
+                    return
+                }
+                imageData = compressedData
             }
-
+            
             if saveToFile {
+                // Use TempFileManager for tracked temp files with automatic cleanup
+                let tempFileURL = TempFileManager.shared.createTempImageFile()
                 do {
-                    let tempFileURL = try createTempImageFile()
                     try imageData.write(to: tempFileURL)
-
+                    
                     // Convert file URL to webView-accessible path using Capacitor bridge
-                    guard let webPath = self.bridge?.portablePath(fromLocalURL: tempFileURL)?.absoluteString else {
+                    guard let webPath = self?.bridge?.portablePath(fromLocalURL: tempFileURL)?.absoluteString else {
                         call.reject("Failed to create web-accessible path")
                         return
                     }
-
+                    
                     call.resolve(["webPath": webPath])
                 } catch {
                     call.reject("Failed to save image to file", nil, error)
@@ -154,43 +152,44 @@ public class CameraViewPlugin: CAPPlugin, CAPBridgedPlugin {
             }
         })
     }
-
+    
     @objc func captureSample(_ call: CAPPluginCall) {
         let quality = call.getDouble("quality", 90.0)
         let saveToFile = call.getBool("saveToFile", false)
-
+        
         guard quality >= 0.0 && quality <= 100.0 else {
             call.reject("Quality must be between 0 and 100")
             return
         }
-
-        implementation.captureSnapshot { (image, error) in
+        
+        implementation.captureSnapshot { [weak self] (image, error) in
             if let error = error {
                 call.reject("Failed to capture frame", nil, error)
                 return
             }
-
+            
             guard let image = image else {
                 call.reject("No frame data")
                 return
             }
-
+            
             guard let imageData = image.jpegData(compressionQuality: quality / 100.0) else {
                 call.reject("Failed to compress image")
                 return
             }
-
+            
             if saveToFile {
+                // Use TempFileManager for tracked temp files with automatic cleanup
+                let tempFileURL = TempFileManager.shared.createTempImageFile()
                 do {
-                    let tempFileURL = try createTempImageFile()
                     try imageData.write(to: tempFileURL)
-
+                    
                     // Convert file URL to webView-accessible path using Capacitor bridge
-                    guard let webPath = self.bridge?.portablePath(fromLocalURL: tempFileURL)?.absoluteString else {
+                    guard let webPath = self?.bridge?.portablePath(fromLocalURL: tempFileURL)?.absoluteString else {
                         call.reject("Failed to create web-accessible path")
                         return
                     }
-
+                    
                     call.resolve(["webPath": webPath])
                 } catch {
                     call.reject("Failed to save sample to file", nil, error)
@@ -203,10 +202,10 @@ public class CameraViewPlugin: CAPPlugin, CAPBridgedPlugin {
             }
         }
     }
-
+    
     @objc func getAvailableDevices(_ call: CAPPluginCall) {
         let devices = implementation.getAvailableDevices()
-
+        
         var result = JSArray()
         for device in devices {
             var deviceInfo = JSObject()
@@ -216,12 +215,12 @@ public class CameraViewPlugin: CAPPlugin, CAPBridgedPlugin {
             deviceInfo["deviceType"] = convertToStringCameraType(device.deviceType)
             result.append(deviceInfo)
         }
-
+        
         call.resolve([
             "devices": result
         ])
     }
-
+    
     @objc func flipCamera(_ call: CAPPluginCall) {
         do {
             try implementation.flipCamera()
@@ -231,25 +230,25 @@ public class CameraViewPlugin: CAPPlugin, CAPBridgedPlugin {
             return
         }
     }
-
+    
     @objc func getZoom(_ call: CAPPluginCall) {
         let zoom = implementation.getSupportedZoomFactors()
-
+        
         call.resolve([
             "min": zoom.min,
             "max": zoom.max,
             "current": zoom.current
         ])
     }
-
+    
     @objc func setZoom(_ call: CAPPluginCall) {
         guard let level = call.getDouble("level") else {
             call.reject("Zoom level must be provided")
             return
         }
-
+        
         let ramp = call.getBool("ramp") ?? false
-
+        
         do {
             try implementation.setZoomFactor(level, ramp: ramp)
             call.resolve()
@@ -258,35 +257,35 @@ public class CameraViewPlugin: CAPPlugin, CAPBridgedPlugin {
             return
         }
     }
-
+    
     @objc func getFlashMode(_ call: CAPPluginCall) {
         let flashMode = implementation.getFlashMode()
-
+        
         call.resolve([
             "flashMode": flashModeToStrMap[flashMode] ?? "off"
         ])
     }
-
+    
     @objc func getSupportedFlashModes(_ call: CAPPluginCall) {
         let supportedFlashModes = implementation.getSupportedFlashModes()
         let supportedFlashModeStrArr = supportedFlashModes.map { flashModeToStrMap[$0] }
-
+        
         call.resolve([
             "flashModes": supportedFlashModeStrArr
         ])
     }
-
+    
     @objc func setFlashMode(_ call: CAPPluginCall) {
         guard let mode = call.getString("mode") else {
             call.reject("Flash mode must be provided")
             return
         }
-
+        
         guard let flashMode = strToFlashModeMap[mode] else {
             call.reject("Invalid flash mode")
             return
         }
-
+        
         do {
             try implementation.setFlashMode(flashMode)
             call.resolve()
@@ -294,14 +293,14 @@ public class CameraViewPlugin: CAPPlugin, CAPBridgedPlugin {
             call.reject("Failed to set flash mode", nil, error)
         }
     }
-
+    
     @objc func isTorchAvailable(_ call: CAPPluginCall) {
         let available = implementation.isTorchAvailable()
         call.resolve([
             "available": available
         ])
     }
-
+    
     @objc func getTorchMode(_ call: CAPPluginCall) {
         let torchState = implementation.getTorchMode()
         call.resolve([
@@ -309,20 +308,20 @@ public class CameraViewPlugin: CAPPlugin, CAPBridgedPlugin {
             "level": torchState.level
         ])
     }
-
+    
     @objc func setTorchMode(_ call: CAPPluginCall) {
         guard let enabled = call.getBool("enabled") else {
             call.reject("Enabled parameter is required")
             return
         }
-
+        
         let level = call.getFloat("level") ?? 1.0
-
+        
         guard level >= 0.0 && level <= 1.0 else {
             call.reject("Level must be between 0.0 and 1.0")
             return
         }
-
+        
         do {
             try implementation.setTorchMode(enabled: enabled, level: level)
             call.resolve()
@@ -330,10 +329,10 @@ public class CameraViewPlugin: CAPPlugin, CAPBridgedPlugin {
             call.reject("Failed to set torch mode", nil, error)
         }
     }
-
+    
     @objc override public func checkPermissions(_ call: CAPPluginCall) {
         let cameraState: String
-
+        
         switch AVCaptureDevice.authorizationStatus(for: .video) {
         case .notDetermined:
             cameraState = "prompt"
@@ -344,18 +343,18 @@ public class CameraViewPlugin: CAPPlugin, CAPBridgedPlugin {
         @unknown default:
             cameraState = "prompt"
         }
-
+        
         call.resolve([
             "camera": cameraState
         ])
     }
-
+    
     @objc override public func requestPermissions(_ call: CAPPluginCall) {
         AVCaptureDevice.requestAccess(for: .video) { [weak self] _ in
             self?.checkPermissions(call)
         }
     }
-
+    
     private func maybeRequestCameraAccess(completion: @escaping (Bool) -> Void) {
         let status = AVCaptureDevice.authorizationStatus(for: .video)
         if status == .authorized {

package/ios/Sources/CameraViewPlugin/TempFileManager.swift

@@ -0,0 +1,181 @@
+import Foundation
+import UIKit
+
+/// Manages temporary files created during camera capture operations.
+/// Provides automatic cleanup to prevent disk space leaks.
+///
+/// This singleton tracks all temporary files created by the camera plugin
+/// and provides cleanup at various lifecycle points:
+/// - On app activation (cleans up stale files older than 30 minutes)
+/// - On app termination (cleans up all tracked files)
+public final class TempFileManager: @unchecked Sendable {
+    /// Shared singleton instance
+    public static let shared = TempFileManager()
+    
+    /// Serial queue for thread-safe file tracking
+    private let queue = DispatchQueue(label: "com.michaelwolz.capacitorcameraview.tempFileManager")
+    
+    /// Set of tracked temporary file URLs
+    private var trackedFiles = Set<URL>()
+    
+    /// Directory prefix used to identify camera capture temp files
+    private let tempFilePrefix = "camera_capture_"
+    
+    /// Stale file threshold in seconds (30 minutes)
+    private let staleThresholdSeconds: TimeInterval = 1800
+    
+    private init() {
+        setupAppLifecycleObservers()
+    }
+    
+    deinit {
+        NotificationCenter.default.removeObserver(self)
+    }
+    
+    // MARK: - Public API
+    
+    /// Creates a temporary file URL for storing captured images and tracks it for cleanup.
+    ///
+    /// - Returns: A URL pointing to the temporary file location
+    /// - Throws: Never throws, always returns a valid temp directory URL
+    public func createTempImageFile() -> URL {
+        let timestamp = Int(Date().timeIntervalSince1970 * 1000)
+        let fileName = "\(tempFilePrefix)\(timestamp).jpg"
+        let tempDir = FileManager.default.temporaryDirectory
+        let fileURL = tempDir.appendingPathComponent(fileName)
+        
+        queue.sync {
+            trackedFiles.insert(fileURL)
+        }
+        
+        return fileURL
+    }
+    
+    /// Cleans up all tracked temporary files.
+    /// Call this when the camera session stops.
+    public func cleanupSessionFiles() {
+        queue.async { [weak self] in
+            guard let self = self else { return }
+            
+            let filesToDelete = self.trackedFiles
+            self.trackedFiles.removeAll()
+            
+            for fileURL in filesToDelete {
+                self.deleteFile(at: fileURL)
+            }
+        }
+    }
+    
+    /// Cleans up stale temporary files that are older than the threshold.
+    /// This helps recover from cases where cleanup was missed.
+    public func cleanupStaleFiles() {
+        queue.async { [weak self] in
+            guard let self = self else { return }
+            
+            let fileManager = FileManager.default
+            let tempDir = fileManager.temporaryDirectory
+            
+            guard let contents = try? fileManager.contentsOfDirectory(
+                at: tempDir,
+                includingPropertiesForKeys: [.creationDateKey],
+                options: .skipsHiddenFiles
+            ) else { return }
+            
+            let staleDate = Date().addingTimeInterval(-self.staleThresholdSeconds)
+            
+            for fileURL in contents {
+                // Only process our camera capture files
+                guard fileURL.lastPathComponent.hasPrefix(self.tempFilePrefix) else { continue }
+                
+                // Check file age
+                if let attributes = try? fileManager.attributesOfItem(atPath: fileURL.path),
+                   let creationDate = attributes[.creationDate] as? Date,
+                   creationDate < staleDate {
+                    self.deleteFile(at: fileURL)
+                    self.trackedFiles.remove(fileURL)
+                }
+            }
+        }
+    }
+    
+    /// Cleans up all camera capture temporary files in the temp directory.
+    /// Use this for aggressive cleanup on app termination.
+    public func cleanupAllCaptureFiles() {
+        queue.async { [weak self] in
+            guard let self = self else { return }
+            
+            let fileManager = FileManager.default
+            let tempDir = fileManager.temporaryDirectory
+            
+            guard let contents = try? fileManager.contentsOfDirectory(
+                at: tempDir,
+                includingPropertiesForKeys: nil,
+                options: .skipsHiddenFiles
+            ) else { return }
+            
+            for fileURL in contents {
+                if fileURL.lastPathComponent.hasPrefix(self.tempFilePrefix) {
+                    self.deleteFile(at: fileURL)
+                }
+            }
+            
+            self.trackedFiles.removeAll()
+        }
+    }
+    
+    // MARK: - Private Methods
+    
+    private func deleteFile(at url: URL) {
+        do {
+            try FileManager.default.removeItem(at: url)
+        } catch {
+            // Silently ignore - file may already be deleted or inaccessible
+        }
+    }
+    
+    private func setupAppLifecycleObservers() {
+        NotificationCenter.default.addObserver(
+            self,
+            selector: #selector(handleAppDidBecomeActive),
+            name: UIApplication.didBecomeActiveNotification,
+            object: nil
+        )
+        
+        NotificationCenter.default.addObserver(
+            self,
+            selector: #selector(handleAppWillTerminate),
+            name: UIApplication.willTerminateNotification,
+            object: nil
+        )
+    }
+    
+    @objc private func handleAppDidBecomeActive() {
+        // Clean up any stale files when app becomes active
+        cleanupStaleFiles()
+    }
+    
+    @objc private func handleAppWillTerminate() {
+        // Clean up all capture files on termination
+        // Note: This is synchronous to ensure cleanup happens before termination
+        queue.sync { [weak self] in
+            guard let self = self else { return }
+            
+            let fileManager = FileManager.default
+            let tempDir = fileManager.temporaryDirectory
+            
+            if let contents = try? fileManager.contentsOfDirectory(
+                at: tempDir,
+                includingPropertiesForKeys: nil,
+                options: .skipsHiddenFiles
+            ) {
+                for fileURL in contents {
+                    if fileURL.lastPathComponent.hasPrefix(self.tempFilePrefix) {
+                        try? fileManager.removeItem(at: fileURL)
+                    }
+                }
+            }
+            
+            self.trackedFiles.removeAll()
+        }
+    }
+}