capacitor-camera-view 2.0.2 → 2.2.0-rc.1

package/ios/Sources/CameraViewPlugin/TempFileManager.swift

@@ -0,0 +1,215 @@
+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
+    }
+
+    /// Creates a temporary file URL for storing recorded videos and tracks it for cleanup.
+    ///
+    /// - Returns: A URL pointing to the temporary video file location
+    public func createTempVideoFile() -> URL {
+        let timestamp = Int(Date().timeIntervalSince1970 * 1000)
+        let fileName = "\(tempFilePrefix)\(timestamp).mp4"
+        let tempDir = FileManager.default.temporaryDirectory
+        let fileURL = tempDir.appendingPathComponent(fileName)
+
+        queue.sync {
+            _ = trackedFiles.insert(fileURL)
+        }
+
+        return fileURL
+    }
+
+    /// Registers an externally created file for tracking.
+    ///
+    /// - Parameter url: The URL of the file to track
+    public func trackFile(_ url: URL) {
+        queue.sync {
+            _ = trackedFiles.insert(url)
+        }
+    }
+
+    /// Removes a file from tracking without deleting it.
+    ///
+    /// - Parameter url: The URL of the file to untrack
+    public func untrackFile(_ url: URL) {
+        queue.sync {
+            _ = trackedFiles.remove(url)
+        }
+    }
+
+    /// 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()
+        }
+    }
+}

package/ios/Sources/CameraViewPlugin/Utils.swift

@@ -1,5 +1,7 @@
 import AVFoundation
 
+// MARK: - Camera Type Conversion
+
 /// Converts string camera type identifiers from JavaScript to native AVCaptureDevice.DeviceType values
 /// - Parameter stringType: The string camera type from JavaScript
 /// - Returns: The corresponding AVCaptureDevice.DeviceType or nil if no match
@@ -56,9 +58,109 @@ public func convertToNativeCameraTypes(_ stringTypes: [String]) -> [AVCaptureDev
 }
 
 /// Creates a temporary file URL for storing captured images
+/// @deprecated Use TempFileManager.shared.createTempImageFile() for automatic cleanup
 public func createTempImageFile() throws -> URL {
     let timestamp = Int(Date().timeIntervalSince1970 * 1000)
     let fileName = "camera_capture_\(timestamp).jpg"
     let tempDir = FileManager.default.temporaryDirectory
     return tempDir.appendingPathComponent(fileName)
 }
+
+// MARK: - Barcode Type Conversion
+
+/// All supported barcode types for detection.
+/// These are enabled by default when no specific types are configured.
+public let ALL_SUPPORTED_BARCODE_TYPES: [AVMetadataObject.ObjectType] = [
+    .qr,
+    .code128,
+    .code39,
+    .code39Mod43,
+    .code93,
+    .ean8,
+    .ean13,
+    .interleaved2of5,
+    .itf14,
+    .pdf417,
+    .aztec,
+    .dataMatrix,
+    .upce
+]
+
+/// Converts a string barcode type identifier from JavaScript to native AVMetadataObject.ObjectType
+/// - Parameter stringType: The string barcode type from JavaScript
+/// - Returns: The corresponding AVMetadataObject.ObjectType or nil if no match
+public func convertToNativeBarcodeType(_ stringType: String) -> AVMetadataObject.ObjectType? {
+    switch stringType {
+    case "qr":
+        return .qr
+    case "code128":
+        return .code128
+    case "code39":
+        return .code39
+    case "code39Mod43":
+        return .code39Mod43
+    case "code93":
+        return .code93
+    case "ean8":
+        return .ean8
+    case "ean13":
+        return .ean13
+    case "interleaved2of5":
+        return .interleaved2of5
+    case "itf14":
+        return .itf14
+    case "pdf417":
+        return .pdf417
+    case "aztec":
+        return .aztec
+    case "dataMatrix":
+        return .dataMatrix
+    case "upce":
+        return .upce
+    default:
+        return nil
+    }
+}
+
+/// Converts AVMetadataObject.ObjectType to JavaScript string value
+/// - Parameter barcodeType: The AVMetadataObject.ObjectType
+/// - Returns: The corresponding string or nil if no match
+public func convertToStringBarcodeType(_ barcodeType: AVMetadataObject.ObjectType) -> String? {
+    switch barcodeType {
+    case .qr:
+        return "qr"
+    case .code128:
+        return "code128"
+    case .code39:
+        return "code39"
+    case .code39Mod43:
+        return "code39Mod43"
+    case .code93:
+        return "code93"
+    case .ean8:
+        return "ean8"
+    case .ean13:
+        return "ean13"
+    case .interleaved2of5:
+        return "interleaved2of5"
+    case .itf14:
+        return "itf14"
+    case .pdf417:
+        return "pdf417"
+    case .aztec:
+        return "aztec"
+    case .dataMatrix:
+        return "dataMatrix"
+    case .upce:
+        return "upce"
+    default:
+        return nil
+    }
+}
+
+/// Converts an array of string barcode type identifiers to native AVMetadataObject.ObjectType values
+/// - Parameter stringTypes: Array of string barcode types from JavaScript
+/// - Returns: Array of AVMetadataObject.ObjectType values (invalid types are filtered out)
+public func convertToNativeBarcodeTypes(_ stringTypes: [String]) -> [AVMetadataObject.ObjectType] {
+    return stringTypes.compactMap { convertToNativeBarcodeType($0) }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "capacitor-camera-view",
-  "version": "2.0.2",
+  "version": "2.2.0-rc.1",
   "description": "A Capacitor plugin for embedding a live camera feed directly into your app.",
   "main": "dist/plugin.cjs.js",
   "module": "dist/esm/index.js",
@@ -48,33 +48,33 @@
     "prepublishOnly": "npm run build"
   },
   "devDependencies": {
-    "@capacitor/android": "^8.0.0",
-    "@capacitor/core": "^8.0.0",
+    "@capacitor/android": "^8.1.0",
+    "@capacitor/core": "^8.1.0",
     "@capacitor/docgen": "^0.3.1",
-    "@capacitor/ios": "^8.0.0",
-    "@commitlint/config-conventional": "^20.3.0",
+    "@capacitor/ios": "^8.1.0",
+    "@commitlint/config-conventional": "^20.4.2",
     "@ionic/prettier-config": "^4.0.0",
     "@ionic/swiftlint-config": "^2.0.0",
     "@semantic-release/changelog": "^6.0.3",
     "@semantic-release/commit-analyzer": "^13.0.1",
     "@semantic-release/git": "^10.0.1",
-    "@semantic-release/github": "^12.0.2",
-    "@semantic-release/npm": "^13.1.3",
+    "@semantic-release/github": "^12.0.6",
+    "@semantic-release/npm": "^13.1.4",
     "@semantic-release/release-notes-generator": "^14.1.0",
-    "@typescript-eslint/eslint-plugin": "^8.51.0",
-    "@typescript-eslint/parser": "^8.51.0",
-    "commitlint": "^20.3.0",
+    "@typescript-eslint/eslint-plugin": "^8.56.0",
+    "@typescript-eslint/parser": "^8.56.0",
+    "commitlint": "^20.4.2",
     "eslint": "^9.39.2",
     "eslint-config-prettier": "^10.1.8",
-    "eslint-plugin-prettier": "^5.5.4",
+    "eslint-plugin-prettier": "^5.5.5",
     "husky": "^9.1.7",
-    "prettier": "^3.7.4",
-    "prettier-plugin-java": "^2.7.7",
+    "prettier": "^3.8.1",
+    "prettier-plugin-java": "^2.8.1",
     "prettier-plugin-organize-imports": "^4.3.0",
-    "prettier-plugin-packagejson": "^2.5.20",
-    "rimraf": "^6.1.2",
-    "rollup": "^4.54.0",
-    "semantic-release": "^25.0.2",
+    "prettier-plugin-packagejson": "^3.0.0",
+    "rimraf": "^6.1.3",
+    "rollup": "^4.58.0",
+    "semantic-release": "^25.0.3",
     "swiftlint": "^2.0.0",
     "typescript": "^5.9.3"
   },