@movementinfra/expo-twostep-video 0.1.15 → 0.1.16

package/ios/ExpoTwoStepVideoModule.swift

@@ -667,11 +667,77 @@ public class ExpoTwoStepVideoModule: Module {
             self.activeVideoCompositions.removeAll()
         }
 
+        // MARK: - Media Picker Functions
+
+        /// Pick video(s) from the photo library using native PHPickerViewController
+        /// - Parameter selectionLimit: Maximum number of videos to select (default 1)
+        /// - Returns: Array of picked video metadata (or empty array if cancelled)
+        AsyncFunction("pickVideo") { (selectionLimit: Int?, promise: Promise) in
+            let options = PickerOptions(selectionLimit: selectionLimit ?? 1)
+
+            self.twoStep.mediaPicker.pickVideo(options: options) { result in
+                switch result {
+                case .success(let videos):
+                    // Convert to JS-friendly dictionaries
+                    let jsVideos = videos.map { video -> [String: Any] in
+                        var dict: [String: Any] = [
+                            "uri": video.uri,
+                            "path": video.path,
+                            "fileName": video.fileName,
+                            "width": video.width,
+                            "height": video.height,
+                            "duration": video.duration,
+                            "fileSize": video.fileSize,
+                            "type": video.type
+                        ]
+
+                        if let creationDate = video.creationDate {
+                            dict["creationDate"] = creationDate
+                        }
+                        if let modificationDate = video.modificationDate {
+                            dict["modificationDate"] = modificationDate
+                        }
+                        if let assetIdentifier = video.assetIdentifier {
+                            dict["assetIdentifier"] = assetIdentifier
+                        }
+
+                        return dict
+                    }
+
+                    promise.resolve(jsVideos)
+
+                case .failure(let error):
+                    // Cancellation returns empty array, not an error
+                    if (error as? MediaPickerError) == .cancelled {
+                        promise.resolve([])
+                    } else {
+                        promise.reject("PICKER_ERROR", error.localizedDescription)
+                    }
+                }
+            }
+        }
+
+        /// Clean up a specific picked video file
+        /// - Parameter path: File path to clean up
+        Function("cleanupPickedVideo") { (path: String) in
+            self.twoStep.mediaPicker.cleanupPickedVideo(at: path)
+        }
+
+        /// Clean up all picked video files from temp storage
+        Function("cleanupAllPickedVideos") {
+            self.twoStep.mediaPicker.cleanupAllPickedVideos()
+        }
+
+        /// Get list of currently tracked picked video paths
+        Function("getPickedVideoPaths") { () -> [String] in
+            return self.twoStep.mediaPicker.trackedPickedVideoPaths
+        }
+
         // MARK: - Video Player View
 
         View(ExpoTwoStepVideoView.self) {
             // Events emitted by the view
-            Events("onPlaybackStatusChange", "onProgress", "onEnd", "onError", "onPanZoomChange")
+            Events("onPlaybackStatusChange", "onProgress", "onEnd", "onError", "onPanZoomChange", "onDoubleTapSkip")
 
             // Prop to set composition ID - view will load it
             Prop("compositionId") { (view: ExpoTwoStepVideoView, compositionId: String?) in
@@ -709,6 +775,16 @@ public class ExpoTwoStepVideoModule: Module {
                 view.maxZoom = CGFloat(maxZoom ?? 5.0)
             }
 
+            // Prop to enable/disable native double-tap to skip
+            Prop("enableDoubleTapSkip") { (view: ExpoTwoStepVideoView, enable: Bool?) in
+                view.enableDoubleTapSkip = enable ?? true
+            }
+
+            // Prop to set double-tap skip interval in seconds
+            Prop("doubleTapSkipInterval") { (view: ExpoTwoStepVideoView, interval: Double?) in
+                view.doubleTapSkipInterval = interval ?? 5.0
+            }
+
             // Playback control functions
             AsyncFunction("play") { (view: ExpoTwoStepVideoView) in
                 view.play()

package/ios/ExpoTwoStepVideoView.swift

@@ -45,6 +45,19 @@ class ExpoTwoStepVideoView: ExpoView {
     /// Gesture recognizers
     private var pinchGesture: UIPinchGestureRecognizer?
     private var panGesture: UIPanGestureRecognizer?
+    private var doubleTapLeftGesture: UITapGestureRecognizer?
+    private var doubleTapRightGesture: UITapGestureRecognizer?
+
+    // MARK: - Double-Tap Skip Properties
+
+    /// Whether double-tap to skip is enabled
+    var enableDoubleTapSkip: Bool = true
+
+    /// Seconds to skip on double-tap
+    var doubleTapSkipInterval: Double = 5.0
+
+    /// Event dispatcher for double-tap skip feedback
+    let onDoubleTapSkip = EventDispatcher()
 
     // MARK: - Initialization
 
@@ -159,6 +172,20 @@ class ExpoTwoStepVideoView: ExpoView {
         addGestureRecognizer(pan)
         panGesture = pan
 
+        // Double-tap on left side to skip backward
+        let doubleTapLeft = UITapGestureRecognizer(target: self, action: #selector(handleDoubleTapLeft(_:)))
+        doubleTapLeft.numberOfTapsRequired = 2
+        doubleTapLeft.delegate = self
+        addGestureRecognizer(doubleTapLeft)
+        doubleTapLeftGesture = doubleTapLeft
+
+        // Double-tap on right side to skip forward
+        let doubleTapRight = UITapGestureRecognizer(target: self, action: #selector(handleDoubleTapRight(_:)))
+        doubleTapRight.numberOfTapsRequired = 2
+        doubleTapRight.delegate = self
+        addGestureRecognizer(doubleTapRight)
+        doubleTapRightGesture = doubleTapRight
+
         isUserInteractionEnabled = true
     }
 
@@ -183,18 +210,6 @@ class ExpoTwoStepVideoView: ExpoView {
         return AVMakeRect(aspectRatio: videoSize, insideRect: layerBounds)
     }
 
-    /// Adjust an anchor point to be relative to the video content rect.
-    /// Clamps points outside the video area to the nearest edge.
-    private func adjustedAnchorPoint(for point: CGPoint) -> CGPoint {
-        let contentRect = videoContentRect()
-
-        // Clamp the point to the video content rect
-        let clampedX = min(max(point.x, contentRect.minX), contentRect.maxX)
-        let clampedY = min(max(point.y, contentRect.minY), contentRect.maxY)
-
-        return CGPoint(x: clampedX, y: clampedY)
-    }
-
     // MARK: - Gesture Handlers
 
     /// Get the current visual transform, reading from the presentation layer if an animation is in progress
@@ -227,14 +242,39 @@ class ExpoTwoStepVideoView: ExpoView {
             beginGesture()
 
         case .changed:
-            let rawAnchor = gesture.location(in: self)
-            // Adjust anchor to account for letterboxing/pillarboxing
-            let anchor = adjustedAnchorPoint(for: rawAnchor)
+            // Get the pinch center in the PARENT's coordinate system (self)
+            // This gives us a stable anchor point that doesn't change with the view's transform
+            let anchor = gesture.location(in: self)
+
+            // Get the incremental scale change
             let scale = gesture.scale
-            let scaleTransform = CGAffineTransform.anchoredScale(scale: scale, anchor: anchor)
-            let newTransform = gestureStartTransform.concatenating(scaleTransform)
-            currentTransform = newTransform
-            playerContainerView.transform = newTransform
+            gesture.scale = 1.0
+
+            // Check if new scale would exceed limits
+            let currentScale = currentTransform.scaleX
+            let proposedScale = currentScale * scale
+
+            // Skip if we'd go below min zoom
+            if proposedScale < minZoom && scale < 1.0 {
+                return
+            }
+
+            // Clamp scale factor if we'd exceed max zoom
+            var effectiveScale = scale
+            if proposedScale > maxZoom {
+                effectiveScale = maxZoom / currentScale
+            }
+
+            // Calculate new transform that scales around the anchor point
+            // Formula: The anchor point in screen coordinates should stay fixed
+            // newTx = anchor.x * (1 - scale) + currentTx * scale
+            // newTy = anchor.y * (1 - scale) + currentTy * scale
+            let newScale = currentScale * effectiveScale
+            let newTx = anchor.x * (1 - effectiveScale) + currentTransform.tx * effectiveScale
+            let newTy = anchor.y * (1 - effectiveScale) + currentTransform.ty * effectiveScale
+
+            currentTransform = CGAffineTransform(a: newScale, b: 0, c: 0, d: newScale, tx: newTx, ty: newTy)
+            playerContainerView.transform = currentTransform
 
         case .ended, .cancelled:
             onGestureEnded()
@@ -244,6 +284,57 @@ class ExpoTwoStepVideoView: ExpoView {
         }
     }
 
+    // MARK: - Double-Tap Handlers
+
+    @objc private func handleDoubleTapLeft(_ gesture: UITapGestureRecognizer) {
+        guard enableDoubleTapSkip else { return }
+
+        let location = gesture.location(in: self)
+        // Only handle taps on the left half
+        guard location.x < bounds.width / 2 else { return }
+
+        guard let player = player,
+              let currentItem = player.currentItem else { return }
+
+        let currentTime = CMTimeGetSeconds(player.currentTime())
+        let newTime = max(0, currentTime - doubleTapSkipInterval)
+        let seekTime = CMTime(seconds: newTime, preferredTimescale: CMTimeScale(NSEC_PER_SEC))
+
+        player.seek(to: seekTime, toleranceBefore: .zero, toleranceAfter: .zero)
+
+        // Emit event for UI feedback
+        onDoubleTapSkip([
+            "direction": "backward",
+            "skipInterval": doubleTapSkipInterval,
+            "newTime": newTime
+        ])
+    }
+
+    @objc private func handleDoubleTapRight(_ gesture: UITapGestureRecognizer) {
+        guard enableDoubleTapSkip else { return }
+
+        let location = gesture.location(in: self)
+        // Only handle taps on the right half
+        guard location.x >= bounds.width / 2 else { return }
+
+        guard let player = player,
+              let currentItem = player.currentItem else { return }
+
+        let duration = CMTimeGetSeconds(currentItem.duration)
+        let currentTime = CMTimeGetSeconds(player.currentTime())
+        let newTime = min(duration, currentTime + doubleTapSkipInterval)
+        let seekTime = CMTime(seconds: newTime, preferredTimescale: CMTimeScale(NSEC_PER_SEC))
+
+        player.seek(to: seekTime, toleranceBefore: .zero, toleranceAfter: .zero)
+
+        // Emit event for UI feedback
+        onDoubleTapSkip([
+            "direction": "forward",
+            "skipInterval": doubleTapSkipInterval,
+            "newTime": newTime
+        ])
+    }
+
     @objc private func handlePanGesture(_ gesture: UIPanGestureRecognizer) {
         switch gesture.state {
         case .began:
@@ -316,13 +407,16 @@ class ExpoTwoStepVideoView: ExpoView {
         }
 
         // Constrain pan to keep content visible
+        // When scaled, the content extends beyond the view bounds.
+        // The maximum pan distance is half the excess on each side.
+        // For a 2x scale on 100px width: content is 200px, excess is 100px, max pan is ±50px
         let contentSize = bounds.size
-        let maxX = contentSize.width * (capped.scaleX - 1)
-        let maxY = contentSize.height * (capped.scaleY - 1)
+        let maxPanX = contentSize.width * (capped.scaleX - 1) / 2
+        let maxPanY = contentSize.height * (capped.scaleY - 1) / 2
 
-        // tx/ty constraints: can't pan past edges
-        capped.tx = min(max(capped.tx, -maxX), 0)
-        capped.ty = min(max(capped.ty, -maxY), 0)
+        // tx/ty constraints: allow panning in both directions, but keep content edges visible
+        capped.tx = min(max(capped.tx, -maxPanX), maxPanX)
+        capped.ty = min(max(capped.ty, -maxPanY), maxPanY)
 
         return capped
     }
@@ -330,12 +424,16 @@ class ExpoTwoStepVideoView: ExpoView {
     /// Emit the current pan/zoom state to JavaScript
     private func emitPanZoomChange() {
         let scale = currentTransform.scaleX
-        let panX = scale > 1.0 ? currentTransform.tx / (bounds.width * (scale - 1)) : 0
-        let panY = scale > 1.0 ? currentTransform.ty / (bounds.height * (scale - 1)) : 0
+        // Convert tx/ty to normalized -1 to 1 range
+        // maxPan = size * (scale - 1) / 2, so panX = tx / maxPan
+        let maxPanX = bounds.width * (scale - 1) / 2
+        let maxPanY = bounds.height * (scale - 1) / 2
+        let panX = (scale > 1.0 && maxPanX > 0) ? currentTransform.tx / maxPanX : 0
+        let panY = (scale > 1.0 && maxPanY > 0) ? currentTransform.ty / maxPanY : 0
 
         onPanZoomChange([
-            "panX": -panX,  // Normalize to -1 to 0 range
-            "panY": -panY,
+            "panX": panX,   // -1 to 1, positive = content shifted right
+            "panY": panY,   // -1 to 1, positive = content shifted down
             "zoomLevel": scale
         ])
     }
@@ -345,12 +443,15 @@ class ExpoTwoStepVideoView: ExpoView {
     /// Get the current pan/zoom state
     func getPanZoomState() -> [String: CGFloat] {
         let scale = currentTransform.scaleX
-        let panX = scale > 1.0 ? currentTransform.tx / (bounds.width * (scale - 1)) : 0
-        let panY = scale > 1.0 ? currentTransform.ty / (bounds.height * (scale - 1)) : 0
+        // Convert tx/ty to normalized -1 to 1 range
+        let maxPanX = bounds.width * (scale - 1) / 2
+        let maxPanY = bounds.height * (scale - 1) / 2
+        let panX = (scale > 1.0 && maxPanX > 0) ? currentTransform.tx / maxPanX : 0
+        let panY = (scale > 1.0 && maxPanY > 0) ? currentTransform.ty / maxPanY : 0
 
         return [
-            "panX": -panX,
-            "panY": -panY,
+            "panX": panX,   // -1 to 1, positive = content shifted right
+            "panY": panY,   // -1 to 1, positive = content shifted down
             "zoomLevel": scale
         ]
     }
@@ -372,8 +473,12 @@ class ExpoTwoStepVideoView: ExpoView {
         if let x = panX, let y = panY {
             let scale = newTransform.scaleX
             if scale > 1.0 {
-                newTransform.tx = -x * bounds.width * (scale - 1)
-                newTransform.ty = -y * bounds.height * (scale - 1)
+                // Convert normalized -1 to 1 values to tx/ty
+                // maxPan = size * (scale - 1) / 2, so tx = panX * maxPan
+                let maxPanX = bounds.width * (scale - 1) / 2
+                let maxPanY = bounds.height * (scale - 1) / 2
+                newTransform.tx = x * maxPanX
+                newTransform.ty = y * maxPanY
             }
         }
 
@@ -590,7 +695,7 @@ class ExpoTwoStepVideoView: ExpoView {
 // MARK: - UIGestureRecognizerDelegate
 
 extension ExpoTwoStepVideoView: UIGestureRecognizerDelegate {
-    /// Allow pinch and pan gestures to work simultaneously
+    /// Allow gestures to work simultaneously
     func gestureRecognizer(_ gestureRecognizer: UIGestureRecognizer, shouldRecognizeSimultaneouslyWith otherGestureRecognizer: UIGestureRecognizer) -> Bool {
         // Allow our pinch and pan to work together
         if (gestureRecognizer == pinchGesture && otherGestureRecognizer == panGesture) ||
@@ -601,15 +706,29 @@ extension ExpoTwoStepVideoView: UIGestureRecognizerDelegate {
         if gestureRecognizer == pinchGesture {
             return true
         }
+        // Allow double-tap gestures to work with each other (left and right can coexist)
+        if (gestureRecognizer == doubleTapLeftGesture || gestureRecognizer == doubleTapRightGesture) &&
+           (otherGestureRecognizer == doubleTapLeftGesture || otherGestureRecognizer == doubleTapRightGesture) {
+            return true
+        }
         return false
     }
 
-    /// Only allow pan gesture when zoomed in
+    /// Only allow pan gesture when zoomed in, and filter double-tap by location
     override func gestureRecognizerShouldBegin(_ gestureRecognizer: UIGestureRecognizer) -> Bool {
         if gestureRecognizer == panGesture {
             // Read from actual view transform to be accurate
             return playerContainerView.transform.scaleX > 1.01
         }
+        // Filter double-tap gestures by their location (left half vs right half)
+        if gestureRecognizer == doubleTapLeftGesture {
+            let location = gestureRecognizer.location(in: self)
+            return location.x < bounds.width / 2
+        }
+        if gestureRecognizer == doubleTapRightGesture {
+            let location = gestureRecognizer.location(in: self)
+            return location.x >= bounds.width / 2
+        }
         return true
     }