@movementinfra/expo-twostep-video 0.1.14 → 0.1.16

package/ios/TwoStepVideo/Core/MediaPicker.swift

@@ -0,0 +1,355 @@
+import Foundation
+import PhotosUI
+import AVFoundation
+import UIKit
+
+/// Result from picking a video from the photo library
+public struct PickedVideo {
+    /// File URI (file:// path to temp copy)
+    public let uri: String
+    /// Absolute file path
+    public let path: String
+    /// Original filename
+    public let fileName: String
+    /// Video width in pixels
+    public let width: Int
+    /// Video height in pixels
+    public let height: Int
+    /// Duration in seconds
+    public let duration: Double
+    /// File size in bytes
+    public let fileSize: Int64
+    /// Date the video was originally created/captured (ISO 8601 string)
+    public let creationDate: String?
+    /// Date the video was last modified (ISO 8601 string)
+    public let modificationDate: String?
+    /// PHAsset local identifier (for use with loadAssetFromPhotos)
+    public let assetIdentifier: String?
+    /// Media type (always "video" for this picker)
+    public let type: String = "video"
+}
+
+/// Options for the video picker
+public struct PickerOptions {
+    /// Maximum number of videos to select (default 1)
+    public let selectionLimit: Int
+
+    public init(selectionLimit: Int = 1) {
+        self.selectionLimit = selectionLimit
+    }
+}
+
+/// Native media picker using PHPickerViewController
+public class MediaPicker: NSObject {
+
+    // MARK: - Properties
+
+    /// Shared instance for convenience
+    public static let shared = MediaPicker()
+
+    /// Serial queue for thread-safe access to mutable state
+    private let stateQueue = DispatchQueue(label: "com.twostepvideo.mediapicker.state")
+
+    /// Directory for storing picked video copies
+    private var pickedVideosDirectory: URL {
+        let tempDir = FileManager.default.temporaryDirectory
+        let pickedDir = tempDir.appendingPathComponent("TwoStepPickedVideos", isDirectory: true)
+        // Ensure directory exists (may have been deleted by cleanup)
+        if !FileManager.default.fileExists(atPath: pickedDir.path) {
+            try? FileManager.default.createDirectory(at: pickedDir, withIntermediateDirectories: true, attributes: nil)
+        }
+        return pickedDir
+    }
+
+    /// Track picked video paths for cleanup (access via stateQueue)
+    private var _pickedVideoPaths: Set<String> = []
+
+    /// Completion handler for current pick operation (access via stateQueue)
+    private var _pickCompletion: ((Result<[PickedVideo], Error>) -> Void)?
+
+    // MARK: - Public Methods
+
+    /// Pick video(s) from the photo library
+    /// - Parameters:
+    ///   - options: Picker options
+    ///   - completion: Completion handler with picked videos or error
+    public func pickVideo(
+        options: PickerOptions = PickerOptions(),
+        completion: @escaping (Result<[PickedVideo], Error>) -> Void
+    ) {
+        // Store completion for delegate callback (thread-safe)
+        stateQueue.sync { self._pickCompletion = completion }
+
+        // Request photo library permission first (for metadata access like creationDate)
+        // This provides the natural permission flow users expect
+        requestPhotoLibraryPermissionIfNeeded { [weak self] granted in
+            guard let self = self else { return }
+
+            // We proceed even if not granted - picker still works, just without some metadata
+            // But the permission dialog will have been shown if needed
+
+            // Everything must happen on main thread for PHPickerViewController
+            DispatchQueue.main.async {
+                // Configure picker
+                var config = PHPickerConfiguration(photoLibrary: .shared())
+                config.filter = .videos
+                config.selectionLimit = options.selectionLimit
+                config.preferredAssetRepresentationMode = .current // Preserves original quality
+
+                let picker = PHPickerViewController(configuration: config)
+                picker.delegate = self
+
+                guard let windowScene = UIApplication.shared.connectedScenes.first as? UIWindowScene,
+                      let rootVC = windowScene.windows.first?.rootViewController else {
+                    completion(.failure(MediaPickerError.noRootViewController))
+                    return
+                }
+
+                // Find the top-most presented controller
+                var topVC = rootVC
+                while let presented = topVC.presentedViewController {
+                    topVC = presented
+                }
+
+                topVC.present(picker, animated: true)
+            }
+        }
+    }
+
+    /// Request photo library permission if not already determined
+    /// This triggers the native permission dialog if needed
+    private func requestPhotoLibraryPermissionIfNeeded(completion: @escaping (Bool) -> Void) {
+        let status = PHPhotoLibrary.authorizationStatus(for: .readWrite)
+
+        switch status {
+        case .notDetermined:
+            // Request permission - this shows the native dialog
+            PHPhotoLibrary.requestAuthorization(for: .readWrite) { newStatus in
+                let granted = newStatus == .authorized || newStatus == .limited
+                completion(granted)
+            }
+        case .authorized, .limited:
+            completion(true)
+        case .denied, .restricted:
+            completion(false)
+        @unknown default:
+            completion(false)
+        }
+    }
+
+    /// Clean up a specific picked video file
+    /// - Parameter path: File path to clean up
+    public func cleanupPickedVideo(at path: String) {
+        let url = URL(fileURLWithPath: path)
+        try? FileManager.default.removeItem(at: url)
+        stateQueue.sync { _pickedVideoPaths.remove(path) }
+    }
+
+    /// Clean up all picked video files
+    public func cleanupAllPickedVideos() {
+        let paths = stateQueue.sync { Array(_pickedVideoPaths) }
+        for path in paths {
+            try? FileManager.default.removeItem(at: URL(fileURLWithPath: path))
+        }
+        stateQueue.sync { _pickedVideoPaths.removeAll() }
+
+        // Also clean up the entire directory to catch any orphaned files
+        try? FileManager.default.removeItem(at: pickedVideosDirectory)
+        try? FileManager.default.createDirectory(at: pickedVideosDirectory, withIntermediateDirectories: true, attributes: nil)
+    }
+
+    /// Get list of currently tracked picked video paths
+    public var trackedPickedVideoPaths: [String] {
+        stateQueue.sync { Array(_pickedVideoPaths) }
+    }
+
+    // MARK: - Private Methods
+
+    /// Process a picked PHPickerResult
+    private func processPickerResult(_ result: PHPickerResult) async throws -> PickedVideo {
+        // Get the asset identifier for PHAsset access
+        let assetIdentifier = result.assetIdentifier
+
+        // Get PHAsset metadata if available
+        var creationDate: Date?
+        var modificationDate: Date?
+
+        if let identifier = assetIdentifier {
+            let fetchResult = PHAsset.fetchAssets(withLocalIdentifiers: [identifier], options: nil)
+            if let phAsset = fetchResult.firstObject {
+                creationDate = phAsset.creationDate
+                modificationDate = phAsset.modificationDate
+            }
+        }
+
+        // Load the video file
+        let itemProvider = result.itemProvider
+
+        guard itemProvider.hasItemConformingToTypeIdentifier(UTType.movie.identifier) else {
+            throw MediaPickerError.invalidMediaType
+        }
+
+        // Load and copy the file (must copy inside completion handler as temp file is deleted after)
+        let (destURL, fileName) = try await loadAndCopyVideo(from: itemProvider)
+
+        // Track the path for cleanup (thread-safe)
+        stateQueue.sync { _pickedVideoPaths.insert(destURL.path) }
+
+        // Get video metadata
+        let asset = AVURLAsset(url: destURL)
+        let duration = try await asset.load(.duration)
+        let tracks = try await asset.load(.tracks)
+
+        var width: Int = 0
+        var height: Int = 0
+
+        if let videoTrack = tracks.first(where: { $0.mediaType == .video }) {
+            let size = try await videoTrack.load(.naturalSize)
+            let transform = try await videoTrack.load(.preferredTransform)
+
+            // Apply transform to get actual display size
+            let transformedSize = size.applying(transform)
+            width = Int(abs(transformedSize.width))
+            height = Int(abs(transformedSize.height))
+        }
+
+        // Get file size
+        let fileAttributes = try FileManager.default.attributesOfItem(atPath: destURL.path)
+        let fileSize = (fileAttributes[.size] as? Int64) ?? 0
+
+        // Format dates as ISO 8601
+        let dateFormatter = ISO8601DateFormatter()
+        dateFormatter.formatOptions = [.withInternetDateTime, .withFractionalSeconds]
+
+        return PickedVideo(
+            uri: destURL.absoluteString,
+            path: destURL.path,
+            fileName: fileName,
+            width: width,
+            height: height,
+            duration: CMTimeGetSeconds(duration),
+            fileSize: fileSize,
+            creationDate: creationDate.map { dateFormatter.string(from: $0) },
+            modificationDate: modificationDate.map { dateFormatter.string(from: $0) },
+            assetIdentifier: assetIdentifier
+        )
+    }
+
+    /// Load video from item provider and copy to our managed directory
+    /// The copy MUST happen inside the completion handler as the temp file is deleted immediately after
+    private func loadAndCopyVideo(from itemProvider: NSItemProvider) async throws -> (URL, String) {
+        try await withCheckedThrowingContinuation { continuation in
+            itemProvider.loadFileRepresentation(forTypeIdentifier: UTType.movie.identifier) { [weak self] tempURL, error in
+                guard let self = self else {
+                    continuation.resume(throwing: MediaPickerError.failedToLoadVideo)
+                    return
+                }
+
+                if let error = error {
+                    continuation.resume(throwing: error)
+                    return
+                }
+
+                guard let tempURL = tempURL else {
+                    continuation.resume(throwing: MediaPickerError.failedToLoadVideo)
+                    return
+                }
+
+                do {
+                    // Generate unique filename - use suggested name or create one
+                    let suggestedName = itemProvider.suggestedName
+                    let fileExtension = tempURL.pathExtension.isEmpty ? "mov" : tempURL.pathExtension
+                    let fileName: String
+                    if let suggested = suggestedName, !suggested.isEmpty {
+                        // Ensure it has the right extension
+                        if suggested.lowercased().hasSuffix(".\(fileExtension.lowercased())") {
+                            fileName = suggested
+                        } else {
+                            fileName = "\(suggested).\(fileExtension)"
+                        }
+                    } else {
+                        fileName = "video_\(UUID().uuidString).\(fileExtension)"
+                    }
+
+                    let destURL = self.pickedVideosDirectory.appendingPathComponent(fileName)
+
+                    // Remove existing file at destination if any
+                    if FileManager.default.fileExists(atPath: destURL.path) {
+                        try FileManager.default.removeItem(at: destURL)
+                    }
+
+                    // Copy IMMEDIATELY while temp file still exists
+                    try FileManager.default.copyItem(at: tempURL, to: destURL)
+
+                    continuation.resume(returning: (destURL, fileName))
+                } catch {
+                    continuation.resume(throwing: error)
+                }
+            }
+        }
+    }
+}
+
+// MARK: - PHPickerViewControllerDelegate
+
+extension MediaPicker: PHPickerViewControllerDelegate {
+
+    public func picker(_ picker: PHPickerViewController, didFinishPicking results: [PHPickerResult]) {
+        // Dismiss picker first
+        picker.dismiss(animated: true)
+
+        // Get completion handler (thread-safe)
+        let completion = stateQueue.sync { _pickCompletion }
+
+        // Handle cancellation
+        guard !results.isEmpty else {
+            completion?(.success([]))
+            stateQueue.sync { _pickCompletion = nil }
+            return
+        }
+
+        // Process results asynchronously
+        Task {
+            do {
+                var pickedVideos: [PickedVideo] = []
+
+                for result in results {
+                    let pickedVideo = try await processPickerResult(result)
+                    pickedVideos.append(pickedVideo)
+                }
+
+                await MainActor.run {
+                    completion?(.success(pickedVideos))
+                    self.stateQueue.sync { self._pickCompletion = nil }
+                }
+            } catch {
+                await MainActor.run {
+                    completion?(.failure(error))
+                    self.stateQueue.sync { self._pickCompletion = nil }
+                }
+            }
+        }
+    }
+}
+
+// MARK: - Errors
+
+public enum MediaPickerError: LocalizedError {
+    case noRootViewController
+    case invalidMediaType
+    case failedToLoadVideo
+    case cancelled
+
+    public var errorDescription: String? {
+        switch self {
+        case .noRootViewController:
+            return "Could not find root view controller to present picker"
+        case .invalidMediaType:
+            return "Selected item is not a video"
+        case .failedToLoadVideo:
+            return "Failed to load video file"
+        case .cancelled:
+            return "User cancelled video selection"
+        }
+    }
+}

package/ios/TwoStepVideo/TwoStepVideo.swift

@@ -20,11 +20,15 @@ public class TwoStepVideo {
     /// Video exporter instance
     public let videoExporter: VideoExporter
 
+    /// Media picker instance for selecting videos from photo library
+    public let mediaPicker: MediaPicker
+
     /// Initialize a new instance
     public init() {
         self.assetLoader = AssetLoader()
         self.videoTrimmer = VideoTrimmer()
         self.videoTransformer = VideoTransformer()
         self.videoExporter = VideoExporter()
+        self.mediaPicker = MediaPicker()
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@movementinfra/expo-twostep-video",
-  "version": "0.1.14",
+  "version": "0.1.16",
   "description": "Minimal video editing for React Native using AVFoundation",
   "main": "build/index.js",
   "types": "build/index.d.ts",