react-native-video-trim 6.1.0 → 6.2.0

package/android/src/main/java/com/videotrim/widgets/VideoTrimmerView.java

@@ -21,6 +21,7 @@ import android.util.AttributeSet;
 import android.util.Log;
 import android.util.TypedValue;
 import android.view.LayoutInflater;
+import android.view.GestureDetector;
 import android.view.MotionEvent;
 import android.view.View;
 import android.widget.FrameLayout;
@@ -104,6 +105,13 @@ public class VideoTrimmerView extends FrameLayout implements IVideoTrimmerView {
   private long zoomedInRangeDuration = 0;
   private boolean isTrimmingLeading = false;
 
+  // range drag
+  private boolean isRangeDragging = false;
+  private float rangeDragInitialRawX = 0;
+  private long rangeDragInitialStartTime = 0;
+  private long rangeDragInitialEndTime = 0;
+  private GestureDetector rangeDragGestureDetector;
+
   // thumbnail caching for zoom functionality
   private final java.util.List<ImageView> cachedFullViewThumbnails = new java.util.ArrayList<>();
   private volatile boolean isGeneratingThumbnails = false;
@@ -155,9 +163,24 @@ public class VideoTrimmerView extends FrameLayout implements IVideoTrimmerView {
     initializeViews();
     configure(config);
     setUpListeners();
+    initRangeDragDetector();
     setProgressIndicatorTouchListener();
   }
 
+  private void initRangeDragDetector() {
+    rangeDragGestureDetector = new GestureDetector(mContext, new GestureDetector.SimpleOnGestureListener() {
+      @Override
+      public void onLongPress(MotionEvent e) {
+        isRangeDragging = true;
+        rangeDragInitialRawX = e.getRawX();
+        rangeDragInitialStartTime = startTime;
+        rangeDragInitialEndTime = endTime;
+        playHapticFeedback(true);
+        fadeOutProgressIndicator();
+      }
+    });
+  }
+
   private void initializeViews() {
     mThumbnailContainer = findViewById(R.id.thumbnailContainer);
     mVideoView = findViewById(R.id.video_loader);
@@ -664,17 +687,29 @@ public class VideoTrimmerView extends FrameLayout implements IVideoTrimmerView {
 
   private void setProgressIndicatorTouchListener() {
     trimmerContainerBg.setOnTouchListener((view, event) -> {
+      rangeDragGestureDetector.onTouchEvent(event);
+
       switch (event.getAction()) {
         case MotionEvent.ACTION_DOWN:
+          isRangeDragging = false;
           didClampWhilePanning = false;
           onMediaPause();
           onTrimmerContainerPanned(event);
           playHapticFeedback(true);
           break;
         case MotionEvent.ACTION_MOVE:
-          onTrimmerContainerPanned(event);
+          if (isRangeDragging) {
+            onRangeDrag(event);
+          } else {
+            onTrimmerContainerPanned(event);
+          }
           break;
         case MotionEvent.ACTION_UP:
+          if (isRangeDragging) {
+            isRangeDragging = false;
+            fadeInProgressIndicator();
+            updateCurrentTime(true);
+          }
           view.performClick();
           break;
         default:
@@ -730,6 +765,45 @@ public class VideoTrimmerView extends FrameLayout implements IVideoTrimmerView {
     seekTo(newVideoPosition, false);
   }
 
+  private void onRangeDrag(MotionEvent event) {
+    float deltaX = event.getRawX() - rangeDragInitialRawX;
+    float containerWidth = trimmerContainerBg.getWidth();
+    if (containerWidth <= 0) return;
+
+    long rangeDuration = rangeDragInitialEndTime - rangeDragInitialStartTime;
+    long deltaTime;
+    if (isZoomedIn) {
+      deltaTime = (long) (deltaX / containerWidth * zoomedInRangeDuration);
+    } else {
+      deltaTime = (long) (deltaX / containerWidth * mDuration);
+    }
+
+    long newStart = rangeDragInitialStartTime + deltaTime;
+    long newEnd = newStart + rangeDuration;
+
+    boolean didClamp = false;
+    if (newStart < 0) {
+      newStart = 0;
+      newEnd = rangeDuration;
+      didClamp = true;
+    }
+    if (newEnd > mDuration) {
+      newEnd = mDuration;
+      newStart = newEnd - rangeDuration;
+      didClamp = true;
+    }
+
+    if (didClamp && !didClampWhilePanning) {
+      playHapticFeedback(false);
+    }
+    didClampWhilePanning = didClamp;
+
+    startTime = newStart;
+    endTime = newEnd;
+    updateHandlePositions();
+    seekTo(startTime, false);
+  }
+
   private void setHandleTouchListener(View handle, boolean isLeading) {
     handle.setOnTouchListener((view, event) -> {
       boolean draggingDisabled = mDuration < mMinDuration; // if the video is shorter than the minimum duration, disable dragging

package/ios/VideoTrimmer.swift

@@ -26,6 +26,11 @@ import AVFoundation
     static let progressChanged = UIControl.Event(rawValue:      0b00010000 << 24)
     static let didEndScrubbing = UIControl.Event(rawValue:      0b00100000 << 24)
     
+    // events for dragging the entire selected range
+    static let didBeginDraggingRange = UIControl.Event(rawValue: 0b01000000 << 24)
+    static let rangeDragChanged = UIControl.Event(rawValue:      0b10000000 << 24)
+    static let didEndDraggingRange = UIControl.Event(rawValue:   1 << 25)
+    
     private struct Thumbnail {
         let uuid = UUID()
         let imageView: UIImageView
@@ -249,6 +254,12 @@ import AVFoundation
     private (set) var trailingGestureRecognizer: UILongPressGestureRecognizer!
     private (set) var progressGestureRecognizer: UILongPressGestureRecognizer!
     private (set) var thumbnailInteractionGestureRecognizer: UILongPressGestureRecognizer!
+    private (set) var rangeDragGestureRecognizer: UILongPressGestureRecognizer!
+    
+    // range drag state
+    private(set) var isDraggingRange = false
+    private var rangeDragInitialRange: CMTimeRange = .zero
+    private var rangeDragInitialLocationX: CGFloat = 0
     
     // private stuff
     private var grabberOffset = CGFloat(0)
@@ -369,11 +380,18 @@ import AVFoundation
         progressGestureRecognizer.require(toFail: trailingGestureRecognizer)
         progressIndicatorControl.addGestureRecognizer(progressGestureRecognizer)
         
+        // Range drag: platform-default long press (0.5s hold, 10pt allowable movement)
+        rangeDragGestureRecognizer = UILongPressGestureRecognizer(target: self, action: #selector(rangeDragPanned(_:)))
+        rangeDragGestureRecognizer.require(toFail: leadingGestureRecognizer)
+        rangeDragGestureRecognizer.require(toFail: trailingGestureRecognizer)
+        thumbView.addGestureRecognizer(rangeDragGestureRecognizer)
+        
         thumbnailInteractionGestureRecognizer = UILongPressGestureRecognizer(target: self, action: #selector(thumbnailPanned(_:)))
         thumbnailInteractionGestureRecognizer.allowableMovement = CGFloat.greatestFiniteMagnitude
         thumbnailInteractionGestureRecognizer.minimumPressDuration = 0
         thumbnailInteractionGestureRecognizer.require(toFail: leadingGestureRecognizer)
         thumbnailInteractionGestureRecognizer.require(toFail: trailingGestureRecognizer)
+        thumbnailInteractionGestureRecognizer.require(toFail: rangeDragGestureRecognizer)
         thumbView.addGestureRecognizer(thumbnailInteractionGestureRecognizer)
     }
     
@@ -583,9 +601,10 @@ import AVFoundation
             setNeedsLayout()
             
         case .hiddenOnlyWhenTrimming:
-            progressIndicator.alpha = (trimmingState == .none ? 1 : 0)
-            progressIndicatorControl.isUserInteractionEnabled = (trimmingState == .none)
-            if trimmingState == .none {
+            let shouldShow = trimmingState == .none && !isDraggingRange
+            progressIndicator.alpha = (shouldShow ? 1 : 0)
+            progressIndicatorControl.isUserInteractionEnabled = shouldShow
+            if shouldShow {
                 setNeedsLayout()
                 if UIView.inheritedAnimationDuration > 0 {
                     UIView.performWithoutAnimation {
@@ -780,6 +799,86 @@ import AVFoundation
         }
     }
     
+    
+    @objc private func rangeDragPanned(_ sender: UILongPressGestureRecognizer) {
+        switch sender.state {
+        case .began:
+            isDraggingRange = true
+            rangeDragInitialRange = selectedRange
+            rangeDragInitialLocationX = sender.location(in: self).x
+            didClampWhilePanning = false
+            
+            if enableHapticFeedback {
+                UISelectionFeedbackGenerator().selectionChanged()
+                impactFeedbackGenerator = UIImpactFeedbackGenerator(style: .heavy)
+                impactFeedbackGenerator?.prepare()
+            }
+            
+            UIView.animate(withDuration: 0.25, delay: 0, options: [.beginFromCurrentState, .allowUserInteraction], animations: {
+                self.updateProgressIndicator()
+            })
+            sendActions(for: Self.didBeginDraggingRange)
+            
+        case .changed:
+            let currentX = sender.location(in: self).x
+            let deltaX = currentX - rangeDragInitialLocationX
+            let inset = thumbView.chevronWidth + horizontalInset
+            let availableWidth = bounds.width - inset * 2
+            let visibleDurationInSeconds = CGFloat(visibleRange.duration.seconds)
+            guard availableWidth > 0 && visibleDurationInSeconds > 0 else { return }
+            
+            let deltaTime = CMTime(
+                seconds: Double(deltaX / availableWidth) * Double(visibleDurationInSeconds),
+                preferredTimescale: 600
+            )
+            let duration = rangeDragInitialRange.duration
+            var newStart = CMTimeAdd(rangeDragInitialRange.start, deltaTime)
+            var newEnd = CMTimeAdd(newStart, duration)
+            
+            var didClamp = false
+            if CMTimeCompare(newStart, range.start) == -1 {
+                newStart = range.start
+                newEnd = CMTimeAdd(newStart, duration)
+                didClamp = true
+            }
+            if CMTimeCompare(newEnd, range.end) == 1 {
+                newEnd = range.end
+                newStart = CMTimeSubtract(newEnd, duration)
+                didClamp = true
+            }
+            
+            if didClamp && !didClampWhilePanning {
+                impactFeedbackGenerator?.impactOccurred()
+            }
+            didClampWhilePanning = didClamp
+            
+            selectedRange = CMTimeRange(start: newStart, end: newEnd)
+            setNeedsLayout()
+            sendActions(for: Self.rangeDragChanged)
+            
+        case .ended:
+            isDraggingRange = false
+            impactFeedbackGenerator = nil
+            UIView.animate(withDuration: 0.25, delay: 0, options: [.beginFromCurrentState, .allowUserInteraction], animations: {
+                self.updateProgressIndicator()
+            })
+            sendActions(for: Self.didEndDraggingRange)
+            
+        case .cancelled:
+            isDraggingRange = false
+            impactFeedbackGenerator = nil
+            UIView.animate(withDuration: 0.25, delay: 0, options: [.beginFromCurrentState, .allowUserInteraction], animations: {
+                self.updateProgressIndicator()
+            })
+            
+        case .possible, .failed:
+            break
+            
+        @unknown default:
+            break
+        }
+    }
+    
     // MARK: - UIView
     
     override var intrinsicContentSize: CGSize {

package/ios/VideoTrimmerViewController.swift

@@ -131,6 +131,20 @@ class VideoTrimmerViewController: UIViewController {
         handleTrimmingEnd(false)
     }
     
+    @objc private func didBeginDraggingRange(_ sender: VideoTrimmer) {
+        handleBeforeProgressChange()
+    }
+    
+    @objc private func rangeDragChanged(_ sender: VideoTrimmer) {
+        handleProgressChanged(time: trimmer.selectedRange.start)
+    }
+    
+    @objc private func didEndDraggingRange(_ sender: VideoTrimmer) {
+        self.trimmer.progress = trimmer.selectedRange.start
+        updateLabels()
+        seek(to: trimmer.progress)
+    }
+    
     @objc private func didBeginScrubbing(_ sender: VideoTrimmer) {
         handleBeforeProgressChange()
     }
@@ -354,6 +368,10 @@ class VideoTrimmerViewController: UIViewController {
         trimmer.addTarget(self, action: #selector(didBeginTrimmingFromEnd(_:)), for: VideoTrimmer.didBeginTrimmingFromEnd)
         trimmer.addTarget(self, action: #selector(trailingGrabberChanged(_:)), for: VideoTrimmer.trailingGrabberChanged)
         trimmer.addTarget(self, action: #selector(didEndTrimmingFromEnd(_:)), for: VideoTrimmer.didEndTrimmingFromEnd)
+        
+        trimmer.addTarget(self, action: #selector(didBeginDraggingRange(_:)), for: VideoTrimmer.didBeginDraggingRange)
+        trimmer.addTarget(self, action: #selector(rangeDragChanged(_:)), for: VideoTrimmer.rangeDragChanged)
+        trimmer.addTarget(self, action: #selector(didEndDraggingRange(_:)), for: VideoTrimmer.didEndDraggingRange)
         trimmer.alpha = 0
         view.addSubview(trimmer)
         trimmer.translatesAutoresizingMaskIntoConstraints = false

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-video-trim",
-  "version": "6.1.0",
+  "version": "6.2.0",
   "description": "Video trimmer for your React Native app",
   "main": "./lib/module/index.js",
   "types": "./lib/typescript/src/index.d.ts",
@@ -91,7 +91,7 @@
   "workspaces": [
     "example"
   ],
-  "packageManager": "yarn@3.6.1",
+  "packageManager": "yarn@4.13.0",
   "jest": {
     "preset": "react-native",
     "modulePathIgnorePatterns": [