capacitor-camera-view 2.2.0 → 2.3.1

package/ios/Sources/CameraViewPlugin/CameraViewPlugin.swift

@@ -29,6 +29,8 @@ public class CameraViewPlugin: CAPPlugin, CAPBridgedPlugin, CameraEventDelegate
         CAPPluginMethod(name: "isRunning", returnType: CAPPluginReturnPromise),
         CAPPluginMethod(name: "capture", returnType: CAPPluginReturnPromise),
         CAPPluginMethod(name: "captureSample", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "startRecording", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "stopRecording", returnType: CAPPluginReturnPromise),
         CAPPluginMethod(name: "getAvailableDevices", returnType: CAPPluginReturnPromise),
         CAPPluginMethod(name: "flipCamera", returnType: CAPPluginReturnPromise),
         CAPPluginMethod(name: "getZoom", returnType: CAPPluginReturnPromise),
@@ -203,6 +205,63 @@ public class CameraViewPlugin: CAPPlugin, CAPBridgedPlugin, CameraEventDelegate
         }
     }
     
+    @objc func startRecording(_ call: CAPPluginCall) {
+        let enableAudio = call.getBool("enableAudio") ?? false
+        let videoQuality = call.getString("videoQuality") ?? "highest"
+
+        guard let parsedVideoQuality = VideoRecordingQuality(rawValue: videoQuality) else {
+            call.reject("Invalid videoQuality. Use one of: lowest, sd, hd, fhd, uhd, highest")
+            return
+        }
+        
+        if enableAudio {
+            maybeRequestMicrophoneAccess { [weak self] granted in
+                guard granted else {
+                    call.reject("Microphone access denied")
+                    return
+                }
+                self?.doStartRecording(call: call, enableAudio: true, videoQuality: parsedVideoQuality)
+            }
+        } else {
+            doStartRecording(call: call, enableAudio: false, videoQuality: parsedVideoQuality)
+        }
+    }
+    
+    private func doStartRecording(
+        call: CAPPluginCall,
+        enableAudio: Bool,
+        videoQuality: VideoRecordingQuality
+    ) {
+        implementation.startRecording(enableAudio: enableAudio, videoQuality: videoQuality) { error in
+            if let error = error {
+                call.reject("Failed to start recording", nil, error)
+                return
+            }
+            call.resolve()
+        }
+    }
+    
+    @objc func stopRecording(_ call: CAPPluginCall) {
+        implementation.stopRecording { [weak self] (outputURL, error) in
+            if let error = error {
+                call.reject("Failed to stop recording", nil, error)
+                return
+            }
+            
+            guard let outputURL = outputURL else {
+                call.reject("No output file URL")
+                return
+            }
+            
+            guard let webPath = self?.bridge?.portablePath(fromLocalURL: outputURL)?.absoluteString else {
+                call.reject("Failed to create web-accessible path")
+                return
+            }
+            
+            call.resolve(["webPath": webPath])
+        }
+    }
+    
     @objc func getAvailableDevices(_ call: CAPPluginCall) {
         let devices = implementation.getAvailableDevices()
         
@@ -331,28 +390,53 @@ public class CameraViewPlugin: CAPPlugin, CAPBridgedPlugin, CameraEventDelegate
     }
     
     @objc override public func checkPermissions(_ call: CAPPluginCall) {
-        let cameraState: String
-        
-        switch AVCaptureDevice.authorizationStatus(for: .video) {
-        case .notDetermined:
-            cameraState = "prompt"
-        case .restricted, .denied:
-            cameraState = "denied"
-        case .authorized:
-            cameraState = "granted"
-        @unknown default:
-            cameraState = "prompt"
-        }
-        
         call.resolve([
-            "camera": cameraState
+            "camera": authorizationStateString(for: .video),
+            "microphone": authorizationStateString(for: .audio)
         ])
     }
     
     @objc override public func requestPermissions(_ call: CAPPluginCall) {
-        AVCaptureDevice.requestAccess(for: .video) { [weak self] _ in
+        let permissionsList = call.getArray("permissions", String.self) ?? ["camera"]
+
+        let requestCamera = permissionsList.contains("camera")
+        let requestMicrophone = permissionsList.contains("microphone")
+        
+        let completionHandler: () -> Void = { [weak self] in
             self?.checkPermissions(call)
         }
+        
+        if requestCamera {
+            AVCaptureDevice.requestAccess(for: .video) { _ in
+                if requestMicrophone {
+                    AVCaptureDevice.requestAccess(for: .audio) { _ in
+                        completionHandler()
+                    }
+                } else {
+                    completionHandler()
+                }
+            }
+        } else if requestMicrophone {
+            AVCaptureDevice.requestAccess(for: .audio) { _ in
+                completionHandler()
+            }
+        } else {
+            completionHandler()
+        }
+    }
+    
+    /// Maps AVFoundation authorization status to the Capacitor permission state string.
+    private func authorizationStateString(for mediaType: AVMediaType) -> String {
+        switch AVCaptureDevice.authorizationStatus(for: mediaType) {
+        case .notDetermined:
+            return "prompt"
+        case .restricted, .denied:
+            return "denied"
+        case .authorized:
+            return "granted"
+        @unknown default:
+            return "prompt"
+        }
     }
     
     private func maybeRequestCameraAccess(completion: @escaping (Bool) -> Void) {
@@ -369,4 +453,19 @@ public class CameraViewPlugin: CAPPlugin, CAPBridgedPlugin, CameraEventDelegate
             completion(false)
         }
     }
+    
+    private func maybeRequestMicrophoneAccess(completion: @escaping (Bool) -> Void) {
+        let status = AVCaptureDevice.authorizationStatus(for: .audio)
+        if status == .authorized {
+            completion(true)
+        } else if status == .notDetermined {
+            AVCaptureDevice.requestAccess(for: .audio) { granted in
+                DispatchQueue.main.async {
+                    completion(granted)
+                }
+            }
+        } else {
+            completion(false)
+        }
+    }
 }

package/ios/Sources/CameraViewPlugin/TempFileManager.swift

@@ -11,29 +11,29 @@ import UIKit
 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
@@ -43,50 +43,84 @@ public final class TempFileManager: @unchecked Sendable {
         let fileName = "\(tempFilePrefix)\(timestamp).jpg"
         let tempDir = FileManager.default.temporaryDirectory
         let fileURL = tempDir.appendingPathComponent(fileName)
-        
+
         queue.sync {
-            trackedFiles.insert(fileURL)
+            _ = 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,
@@ -97,34 +131,34 @@ public final class TempFileManager: @unchecked Sendable {
             }
         }
     }
-    
+
     /// 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)
@@ -132,7 +166,7 @@ public final class TempFileManager: @unchecked Sendable {
             // Silently ignore - file may already be deleted or inaccessible
         }
     }
-    
+
     private func setupAppLifecycleObservers() {
         NotificationCenter.default.addObserver(
             self,
@@ -140,7 +174,7 @@ public final class TempFileManager: @unchecked Sendable {
             name: UIApplication.didBecomeActiveNotification,
             object: nil
         )
-        
+
         NotificationCenter.default.addObserver(
             self,
             selector: #selector(handleAppWillTerminate),
@@ -148,21 +182,21 @@ public final class TempFileManager: @unchecked Sendable {
             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,
@@ -174,7 +208,7 @@ public final class TempFileManager: @unchecked Sendable {
                     }
                 }
             }
-            
+
             self.trackedFiles.removeAll()
         }
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "capacitor-camera-view",
-  "version": "2.2.0",
+  "version": "2.3.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",