@movementinfra/expo-twostep-video 0.1.0

package/ios/TwoStepVideo/Core/VideoExporter.swift

@@ -0,0 +1,353 @@
+import Foundation
+import AVFoundation
+
+/// Handles video export operations
+public class VideoExporter {
+
+    /// Progress callback closure
+    public typealias ProgressHandler = (Float) -> Void
+
+    /// Completion callback closure
+    public typealias CompletionHandler = (Result<URL, VideoEditingError>) -> Void
+
+    /// Initialize a new VideoExporter
+    public init() {}
+
+    /// Export a composition to a file
+    /// - Parameters:
+    ///   - composition: The composition to export
+    ///   - configuration: Export configuration
+    ///   - progressHandler: Optional progress callback (0.0 to 1.0)
+    /// - Returns: The URL of the exported file
+    /// - Throws: VideoEditingError if export fails
+    public func export(
+        composition: AVComposition,
+        configuration: ExportConfiguration,
+        progressHandler: ProgressHandler? = nil
+    ) async throws -> URL {
+        // Remove existing file if present
+        if FileManager.default.fileExists(atPath: configuration.outputURL.path) {
+            try? FileManager.default.removeItem(at: configuration.outputURL)
+        }
+
+        // Create export session
+        guard let exportSession = AVAssetExportSession(
+            asset: composition,
+            presetName: AVAssetExportPresetPassthrough
+        ) else {
+            throw VideoEditingError.exportFailed(
+                reason: "Failed to create export session"
+            )
+        }
+
+        // Configure export session
+        exportSession.outputURL = configuration.outputURL
+        exportSession.outputFileType = configuration.fileType
+        exportSession.shouldOptimizeForNetworkUse = configuration.optimizeForNetworkUse
+
+        // Apply custom video settings if provided
+        if let customVideoSettings = configuration.customVideoSettings {
+            exportSession.videoComposition = try await createVideoComposition(
+                for: composition,
+                settings: customVideoSettings
+            )
+        }
+
+        // Start progress monitoring if handler provided
+        let progressTask: Task<Void, Never>? = progressHandler.map { handler in
+            Task {
+                await monitorProgress(of: exportSession, handler: handler)
+            }
+        }
+
+        // Perform export
+        await exportSession.export()
+
+        // Cancel progress monitoring
+        progressTask?.cancel()
+
+        // Check export status
+        switch exportSession.status {
+        case .completed:
+            return configuration.outputURL
+
+        case .failed:
+            let error = exportSession.error
+            throw VideoEditingError.exportFailed(
+                reason: "Export session failed",
+                underlyingError: error
+            )
+
+        case .cancelled:
+            throw VideoEditingError.exportCancelled
+
+        default:
+            throw VideoEditingError.exportFailed(
+                reason: "Export ended with unexpected status: \(exportSession.status.rawValue)"
+            )
+        }
+    }
+
+    /// Export a video asset directly (without composition)
+    /// - Parameters:
+    ///   - asset: The video asset to export
+    ///   - configuration: Export configuration
+    ///   - progressHandler: Optional progress callback
+    /// - Returns: The URL of the exported file
+    /// - Throws: VideoEditingError if export fails
+    public func export(
+        asset: VideoAsset,
+        configuration: ExportConfiguration,
+        progressHandler: ProgressHandler? = nil
+    ) async throws -> URL {
+        // Remove existing file if present
+        if FileManager.default.fileExists(atPath: configuration.outputURL.path) {
+            try? FileManager.default.removeItem(at: configuration.outputURL)
+        }
+
+        // Get appropriate preset for quality
+        let preset = exportPreset(for: configuration.quality)
+
+        guard let exportSession = AVAssetExportSession(
+            asset: asset.avAsset,
+            presetName: preset
+        ) else {
+            throw VideoEditingError.exportFailed(
+                reason: "Failed to create export session with preset: \(preset)"
+            )
+        }
+
+        // Configure export session
+        exportSession.outputURL = configuration.outputURL
+        exportSession.outputFileType = configuration.fileType
+        exportSession.shouldOptimizeForNetworkUse = configuration.optimizeForNetworkUse
+
+        // Start progress monitoring if handler provided
+        let progressTask: Task<Void, Never>? = progressHandler.map { handler in
+            Task {
+                await monitorProgress(of: exportSession, handler: handler)
+            }
+        }
+
+        // Perform export
+        await exportSession.export()
+
+        // Cancel progress monitoring
+        progressTask?.cancel()
+
+        // Check export status
+        switch exportSession.status {
+        case .completed:
+            return configuration.outputURL
+
+        case .failed:
+            // Clean up partial file on failure
+            cleanupPartialFile(at: configuration.outputURL)
+
+            let error = exportSession.error
+            throw VideoEditingError.exportFailed(
+                reason: "Export session failed",
+                underlyingError: error
+            )
+
+        case .cancelled:
+            // Clean up partial file on cancellation
+            cleanupPartialFile(at: configuration.outputURL)
+
+            throw VideoEditingError.exportCancelled
+
+        default:
+            // Clean up partial file on unexpected status
+            cleanupPartialFile(at: configuration.outputURL)
+
+            throw VideoEditingError.exportFailed(
+                reason: "Export ended with unexpected status: \(exportSession.status.rawValue)"
+            )
+        }
+    }
+
+    /// Export with a custom AVAssetExportSession configuration
+    /// Provides full control over export settings
+    /// - Parameters:
+    ///   - composition: The composition to export
+    ///   - outputURL: Output file URL
+    ///   - sessionConfigurator: Closure to configure the export session
+    ///   - progressHandler: Optional progress callback
+    /// - Returns: The URL of the exported file
+    /// - Throws: VideoEditingError if export fails
+    public func exportWithCustomSession(
+        composition: AVComposition,
+        outputURL: URL,
+        sessionConfigurator: (AVAssetExportSession) -> Void,
+        progressHandler: ProgressHandler? = nil
+    ) async throws -> URL {
+        // Remove existing file if present
+        if FileManager.default.fileExists(atPath: outputURL.path) {
+            try? FileManager.default.removeItem(at: outputURL)
+        }
+
+        guard let exportSession = AVAssetExportSession(
+            asset: composition,
+            presetName: AVAssetExportPresetHighestQuality
+        ) else {
+            throw VideoEditingError.exportFailed(
+                reason: "Failed to create export session"
+            )
+        }
+
+        // Apply custom configuration
+        sessionConfigurator(exportSession)
+        exportSession.outputURL = outputURL
+
+        // Start progress monitoring if handler provided
+        let progressTask: Task<Void, Never>? = progressHandler.map { handler in
+            Task {
+                await monitorProgress(of: exportSession, handler: handler)
+            }
+        }
+
+        // Perform export
+        await exportSession.export()
+
+        // Cancel progress monitoring
+        progressTask?.cancel()
+
+        // Check export status
+        switch exportSession.status {
+        case .completed:
+            return outputURL
+
+        case .failed:
+            // Clean up partial file on failure
+            cleanupPartialFile(at: outputURL)
+
+            let error = exportSession.error
+            throw VideoEditingError.exportFailed(
+                reason: "Export session failed",
+                underlyingError: error
+            )
+
+        case .cancelled:
+            // Clean up partial file on cancellation
+            cleanupPartialFile(at: outputURL)
+
+            throw VideoEditingError.exportCancelled
+
+        default:
+            // Clean up partial file on unexpected status
+            cleanupPartialFile(at: outputURL)
+
+            throw VideoEditingError.exportFailed(
+                reason: "Export ended with unexpected status: \(exportSession.status.rawValue)"
+            )
+        }
+    }
+
+    /// Clean up a temporary or partial export file
+    /// - Parameter url: The URL of the file to remove
+    public func cleanupFile(at url: URL) {
+        cleanupPartialFile(at: url)
+    }
+
+    /// Cancel an ongoing export operation
+    /// Note: This requires keeping a reference to the export session
+    /// For managed cancellation, use the async/await methods which support Task cancellation
+    public func cancelExport() {
+        // This is a placeholder for potential future session management
+        // In practice, callers should cancel the Task that called the export method
+    }
+
+    // MARK: - Private Helper Methods
+
+    /// Clean up a partial or temporary file
+    private func cleanupPartialFile(at url: URL) {
+        guard FileManager.default.fileExists(atPath: url.path) else {
+            return
+        }
+
+        do {
+            try FileManager.default.removeItem(at: url)
+        } catch {
+            // Log but don't throw - cleanup is best-effort
+            print("Warning: Failed to clean up file at \(url.path): \(error)")
+        }
+    }
+
+    /// Monitor export progress
+    private func monitorProgress(
+        of session: AVAssetExportSession,
+        handler: @escaping ProgressHandler
+    ) async {
+        while !Task.isCancelled && session.status == .exporting {
+            handler(session.progress)
+            try? await Task.sleep(nanoseconds: 100_000_000) // 0.1 seconds
+        }
+    }
+
+    /// Get export preset for quality level
+    private func exportPreset(for quality: ExportConfiguration.Quality) -> String {
+        switch quality {
+        case .low:
+            return AVAssetExportPresetLowQuality
+        case .medium:
+            return AVAssetExportPresetMediumQuality
+        case .high:
+            return AVAssetExportPresetHighestQuality
+        case .highest:
+            return AVAssetExportPresetHighestQuality
+        }
+    }
+
+    /// Create a video composition with custom settings
+    private func createVideoComposition(
+        for asset: AVComposition,
+        settings: [String: Any]
+    ) async throws -> AVMutableVideoComposition {
+        let videoTracks = try await asset.loadTracks(withMediaType: .video)
+        guard let videoTrack = videoTracks.first else {
+            throw VideoEditingError.noVideoTrack
+        }
+
+        let naturalSize = try await videoTrack.load(.naturalSize)
+
+        let videoComposition = AVMutableVideoComposition()
+        videoComposition.frameDuration = CMTime(value: 1, timescale: 30)
+        videoComposition.renderSize = naturalSize
+
+        let instruction = AVMutableVideoCompositionInstruction()
+        instruction.timeRange = CMTimeRange(
+            start: .zero,
+            duration: asset.duration
+        )
+
+        let layerInstruction = AVMutableVideoCompositionLayerInstruction(
+            assetTrack: videoTrack
+        )
+        instruction.layerInstructions = [layerInstruction]
+        videoComposition.instructions = [instruction]
+
+        return videoComposition
+    }
+}
+
+// MARK: - Export Session Status Extension
+extension AVAssetExportSession.Status: @retroactive CustomStringConvertible {
+    public var description: String {
+        switch self {
+        case .unknown:
+            return "unknown"
+        case .waiting:
+            return "waiting"
+        case .exporting:
+            return "exporting"
+        case .completed:
+            return "completed"
+        case .failed:
+            return "failed"
+        case .cancelled:
+            return "cancelled"
+        @unknown default:
+            return "unknown(\(rawValue))"
+        }
+    }
+}