@movementinfra/expo-twostep-video 0.1.0

package/ios/ExpoTwostepVideoView.swift

@@ -0,0 +1,223 @@
+import ExpoModulesCore
+import AVFoundation
+import UIKit
+
+/// Native video player view that can play compositions directly
+class ExpoTwostepVideoView: ExpoView {
+
+    // MARK: - Properties
+
+    private var player: AVPlayer?
+    private var playerLayer: AVPlayerLayer?
+    private var timeObserver: Any?
+    private var isObservingStatus: Bool = false
+
+    /// Event dispatchers
+    let onPlaybackStatusChange = EventDispatcher()
+    let onProgress = EventDispatcher()
+    let onEnd = EventDispatcher()
+    let onError = EventDispatcher()
+
+    /// Current composition ID being played
+    private var currentCompositionId: String?
+    private var currentAssetId: String?
+
+    /// Whether to loop playback continuously
+    var shouldLoop: Bool = false
+
+    // MARK: - Initialization
+
+    required init(appContext: AppContext? = nil) {
+        super.init(appContext: appContext)
+        clipsToBounds = true
+        backgroundColor = .black
+        setupPlayerLayer()
+    }
+
+    private func setupPlayerLayer() {
+        playerLayer = AVPlayerLayer()
+        playerLayer?.videoGravity = .resizeAspect
+        playerLayer?.backgroundColor = UIColor.black.cgColor
+        if let playerLayer = playerLayer {
+            layer.addSublayer(playerLayer)
+        }
+    }
+
+    override func layoutSubviews() {
+        super.layoutSubviews()
+        playerLayer?.frame = bounds
+    }
+
+    // MARK: - Public Methods (called from module)
+
+    func loadComposition(compositionId: String, composition: AVMutableComposition, videoComposition: AVMutableVideoComposition?) {
+        // Clean up previous player
+        cleanup()
+
+        currentCompositionId = compositionId
+        currentAssetId = nil
+
+        // Create player item from composition
+        let playerItem = AVPlayerItem(asset: composition)
+
+        // Apply video composition for transforms (mirror, etc.)
+        if let videoComposition = videoComposition {
+            playerItem.videoComposition = videoComposition
+        }
+
+        setupPlayer(with: playerItem)
+    }
+
+    func loadAsset(assetId: String, asset: AVAsset) {
+        // Clean up previous player
+        cleanup()
+
+        currentAssetId = assetId
+        currentCompositionId = nil
+
+        let playerItem = AVPlayerItem(asset: asset)
+        setupPlayer(with: playerItem)
+    }
+
+    private func setupPlayer(with playerItem: AVPlayerItem) {
+        // Create player
+        player = AVPlayer(playerItem: playerItem)
+        playerLayer?.player = player
+
+        // Observe playback status (track that we added this observer)
+        playerItem.addObserver(self, forKeyPath: "status", options: [.new, .initial], context: nil)
+        isObservingStatus = true
+
+        // Observe when playback ends
+        NotificationCenter.default.addObserver(
+            self,
+            selector: #selector(playerDidFinishPlaying),
+            name: .AVPlayerItemDidPlayToEndTime,
+            object: playerItem
+        )
+
+        // Add periodic time observer for progress (0.25s interval is sufficient and reduces overhead)
+        let interval = CMTime(seconds: 0.25, preferredTimescale: CMTimeScale(NSEC_PER_SEC))
+        timeObserver = player?.addPeriodicTimeObserver(forInterval: interval, queue: .main) { [weak self] time in
+            guard let self = self,
+                  let duration = self.player?.currentItem?.duration,
+                  duration.isNumeric && !duration.isIndefinite else { return }
+
+            let currentTime = CMTimeGetSeconds(time)
+            let totalDuration = CMTimeGetSeconds(duration)
+
+            self.onProgress([
+                "currentTime": currentTime,
+                "duration": totalDuration,
+                "progress": totalDuration > 0 ? currentTime / totalDuration : 0
+            ])
+        }
+
+        onPlaybackStatusChange(["status": "ready"])
+    }
+
+    func play() {
+        player?.play()
+        onPlaybackStatusChange(["status": "playing"])
+    }
+
+    func pause() {
+        player?.pause()
+        onPlaybackStatusChange(["status": "paused"])
+    }
+
+    func seek(to time: Double) {
+        let cmTime = CMTime(seconds: time, preferredTimescale: CMTimeScale(NSEC_PER_SEC))
+        player?.seek(to: cmTime, toleranceBefore: .zero, toleranceAfter: .zero) { [weak self] finished in
+            if finished {
+                self?.onPlaybackStatusChange(["status": "seeked", "time": time])
+            }
+        }
+    }
+
+    func replay() {
+        seek(to: 0)
+        play()
+    }
+
+    var isPlaying: Bool {
+        return player?.rate != 0 && player?.error == nil
+    }
+
+    var currentTime: Double {
+        guard let time = player?.currentTime() else { return 0 }
+        return CMTimeGetSeconds(time)
+    }
+
+    var duration: Double {
+        guard let duration = player?.currentItem?.duration,
+              duration.isNumeric && !duration.isIndefinite else { return 0 }
+        return CMTimeGetSeconds(duration)
+    }
+
+    // MARK: - Observers
+
+    override func observeValue(forKeyPath keyPath: String?, of object: Any?, change: [NSKeyValueChangeKey : Any]?, context: UnsafeMutableRawPointer?) {
+        if keyPath == "status" {
+            if let playerItem = object as? AVPlayerItem {
+                switch playerItem.status {
+                case .readyToPlay:
+                    onPlaybackStatusChange(["status": "ready"])
+                case .failed:
+                    onError(["error": playerItem.error?.localizedDescription ?? "Unknown error"])
+                default:
+                    break
+                }
+            }
+        }
+    }
+
+    @objc private func playerDidFinishPlaying() {
+        if shouldLoop {
+            // Seek back to start and play again
+            player?.seek(to: .zero) { [weak self] _ in
+                self?.player?.play()
+            }
+        } else {
+            onEnd([:])
+            onPlaybackStatusChange(["status": "ended"])
+        }
+    }
+
+    // MARK: - Cleanup
+
+    private func cleanup() {
+        // Remove time observer first
+        if let observer = timeObserver, let player = player {
+            player.removeTimeObserver(observer)
+        }
+        timeObserver = nil
+
+        // Remove KVO observer only if we added it
+        if isObservingStatus, let playerItem = player?.currentItem {
+            playerItem.removeObserver(self, forKeyPath: "status")
+            isObservingStatus = false
+        }
+
+        // Remove notification observer
+        if let playerItem = player?.currentItem {
+            NotificationCenter.default.removeObserver(self, name: .AVPlayerItemDidPlayToEndTime, object: playerItem)
+        }
+
+        // Stop and clear player
+        player?.pause()
+        player?.replaceCurrentItem(with: nil)
+        player = nil
+        playerLayer?.player = nil
+
+        currentCompositionId = nil
+        currentAssetId = nil
+    }
+
+    deinit {
+        cleanup()
+        // Also remove the layer to break any potential retain cycles
+        playerLayer?.removeFromSuperlayer()
+        playerLayer = nil
+    }
+}

package/ios/Package.swift

@@ -0,0 +1,32 @@
+// swift-tools-version: 5.9
+// The swift-tools-version declares the minimum version of Swift required to build this package.
+
+import PackageDescription
+
+let package = Package(
+    name: "TwoStepVideo",
+    platforms: [
+        .iOS(.v16),
+        .macOS(.v13)
+    ],
+    products: [
+        .library(
+            name: "TwoStepVideo",
+            targets: ["TwoStepVideo"]),
+    ],
+    targets: [
+        // Swift library target
+        .target(
+            name: "TwoStepVideo",
+            path: "TwoStepVideo",
+            exclude: []
+        ),
+
+        // Test target
+        .testTarget(
+            name: "TwoStepVideoTests",
+            dependencies: ["TwoStepVideo"],
+            path: "Tests"
+        ),
+    ]
+)

package/ios/TwoStepVideo/Core/AssetLoader.swift

@@ -0,0 +1,175 @@
+import Foundation
+import AVFoundation
+import Photos
+
+/// Handles loading video assets from various sources
+public class AssetLoader {
+
+    /// Initialize a new AssetLoader
+    public init() {}
+
+    /// Load a video asset from a file URL
+    /// - Parameter url: The file URL of the video
+    /// - Returns: A VideoAsset
+    /// - Throws: VideoEditingError if loading fails
+    public func loadAsset(from url: URL) async throws -> VideoAsset {
+        let avAsset = AVURLAsset(url: url)
+
+        // Verify the asset is readable
+        do {
+            let isReadable = try await avAsset.load(.isReadable)
+            guard isReadable else {
+                throw VideoEditingError.assetLoadingFailed(
+                    reason: "Asset is not readable"
+                )
+            }
+
+            // Load using the VideoAsset.load method which handles all async loading
+            let videoAsset = try await VideoAsset.load(from: avAsset, url: url)
+
+            // Verify the asset has a video track
+            if videoAsset.naturalSize == nil {
+                throw VideoEditingError.noVideoTrack
+            }
+
+            return videoAsset
+
+        } catch let error as VideoEditingError {
+            throw error
+        } catch {
+            throw VideoEditingError.assetLoadingFailed(
+                reason: "Failed to load asset properties",
+                underlyingError: error
+            )
+        }
+    }
+
+    /// Load a video asset from a PHAsset (Photos library)
+    /// - Parameter phAsset: The PHAsset from the Photos library
+    /// - Returns: A VideoAsset
+    /// - Throws: VideoEditingError if loading fails
+    public func loadAsset(from phAsset: PHAsset) async throws -> VideoAsset {
+        guard phAsset.mediaType == .video else {
+            throw VideoEditingError.assetLoadingFailed(
+                reason: "PHAsset is not a video"
+            )
+        }
+
+        let avAsset: AVAsset = try await withCheckedThrowingContinuation { continuation in
+            let options = PHVideoRequestOptions()
+            options.version = .current
+            options.deliveryMode = .highQualityFormat
+            options.isNetworkAccessAllowed = true
+
+            PHImageManager.default().requestAVAsset(
+                forVideo: phAsset,
+                options: options
+            ) { avAsset, audioMix, info in
+                if let error = info?[PHImageErrorKey] as? Error {
+                    continuation.resume(
+                        throwing: VideoEditingError.assetLoadingFailed(
+                            reason: "Failed to load PHAsset",
+                            underlyingError: error
+                        )
+                    )
+                    return
+                }
+
+                guard let avAsset = avAsset else {
+                    continuation.resume(
+                        throwing: VideoEditingError.assetLoadingFailed(
+                            reason: "PHAsset returned nil AVAsset"
+                        )
+                    )
+                    return
+                }
+
+                continuation.resume(returning: avAsset)
+            }
+        }
+
+        // Load metadata using async API
+        return try await VideoAsset.load(from: avAsset, url: nil)
+    }
+
+    /// Load asset metadata without creating a full VideoAsset
+    /// Useful for quick validation and preview purposes
+    /// - Parameter url: The file URL of the video
+    /// - Returns: A dictionary containing metadata
+    /// - Throws: VideoEditingError if loading fails
+    public func loadMetadata(from url: URL) async throws -> [String: Any] {
+        let avAsset = AVURLAsset(url: url)
+
+        do {
+            let duration = try await avAsset.load(.duration)
+            let tracks = try await avAsset.load(.tracks)
+            let videoTracks = tracks.filter { $0.mediaType == .video }
+            let audioTracks = tracks.filter { $0.mediaType == .audio }
+
+            var metadata: [String: Any] = [
+                "duration": CMTimeGetSeconds(duration),
+                "hasVideo": !videoTracks.isEmpty,
+                "hasAudio": !audioTracks.isEmpty
+            ]
+
+            if let videoTrack = videoTracks.first {
+                let naturalSize = try await videoTrack.load(.naturalSize)
+                let frameRate = try await videoTrack.load(.nominalFrameRate)
+
+                metadata["width"] = naturalSize.width
+                metadata["height"] = naturalSize.height
+                metadata["frameRate"] = frameRate
+            }
+
+            return metadata
+
+        } catch {
+            throw VideoEditingError.assetLoadingFailed(
+                reason: "Failed to load metadata",
+                underlyingError: error
+            )
+        }
+    }
+
+    /// Validate that a URL points to a valid video file
+    /// - Parameter url: The file URL to validate
+    /// - Returns: True if the URL points to a valid video file
+    public func validateVideoURL(_ url: URL) async -> Bool {
+        do {
+            _ = try await loadMetadata(from: url)
+            return true
+        } catch {
+            return false
+        }
+    }
+
+    /// Preload asset properties for faster access
+    /// This method loads commonly used properties into memory
+    /// - Parameter asset: The video asset to preload
+    /// - Throws: VideoEditingError if preloading fails
+    public func preloadAsset(_ asset: VideoAsset) async throws {
+        let avAsset = asset.avAsset
+
+        do {
+            // Preload commonly used properties
+            _ = try await avAsset.load(.duration)
+            _ = try await avAsset.load(.tracks)
+            _ = try await avAsset.load(.isPlayable)
+            _ = try await avAsset.load(.isReadable)
+
+            // Preload video track properties
+            let videoTracks = try await avAsset.loadTracks(withMediaType: .video)
+            if let videoTrack = videoTracks.first {
+                _ = try await videoTrack.load(.naturalSize)
+                _ = try await videoTrack.load(.nominalFrameRate)
+                _ = try await videoTrack.load(.timeRange)
+            }
+
+        } catch {
+            throw VideoEditingError.assetLoadingFailed(
+                reason: "Failed to preload asset properties",
+                underlyingError: error
+            )
+        }
+    }
+}