shakebug-react-native 2.0.0 → 2.2.0

package/ios/TrimVideo/VideoTrimmer.swift

@@ -1,810 +0,0 @@
-//
-//  VideoTrimmer.swift
-//  Shakebug
-//
-//  Created by ideveloper2 on 26/04/24.
-//  Copyright © 2024 Facebook. All rights reserved.
-//
-
-import UIKit
-import AVFoundation
-
-// Controls that allows trimming a range and scrubbing a progress indicator
-@available(iOS 13.0, *)
-@IBDesignable class VideoTrimmer: UIControl {
-
-    // events for changing selectedRange ("trimming")
-    static let didBeginTrimming = UIControl.Event(rawValue:     0b00000001 << 24)
-    static let selectedRangeChanged = UIControl.Event(rawValue: 0b00000010 << 24)
-    static let didEndTrimming = UIControl.Event(rawValue:       0b00000100 << 24)
-
-    // events for scrubbing the progress indicator ("scrubbing")
-    static let didBeginScrubbing = UIControl.Event(rawValue:    0b00001000 << 24)
-    static let progressChanged = UIControl.Event(rawValue:      0b00010000 << 24)
-    static let didEndScrubbing = UIControl.Event(rawValue:      0b00100000 << 24)
-
-    private struct Thumbnail {
-        let uuid = UUID()
-        let imageView: UIImageView
-        let time: CMTime
-    }
-
-    let thumbView = VideoTrimmerThumb()
-    private let wrapperView = UIView()
-    private let shadowView = UIView()
-    private let thumbnailClipView = UIView()
-    private let thumbnailWrapperView = UIView()
-    private let thumbnailTrackView = UIView()
-    private let thumbnailLeadingCoverView = UIView()
-    private let thumbnailTrailingCoverView = UIView()
-    private let leadingThumbRest = UIView()
-    private let trailingThumbRest = UIView()
-    private let progressIndicator = UIView()
-    private let progressIndicatorControl = UIControl()
-
-    // defines how much the control is insetted from its sides:
-    // this is set to 16, so that you can have the control fullscreen (and have it
-    // edge-to-edge when zooming in)
-    @IBInspectable var horizontalInset: CGFloat = 16 {
-        didSet {
-            guard horizontalInset != oldValue else {return}
-            setNeedsLayout()
-        }
-    }
-
-    // the asset to use
-    var asset: AVAsset? {
-        didSet {
-            if let asset = asset {
-                let duration = asset.duration
-                range = CMTimeRange(start: .zero, duration: duration)
-                selectedRange = range
-                lastKnownViewSizeForThumbnailGeneration = .zero
-                setNeedsLayout()
-            }
-        }
-    }
-
-    // the video composition to use
-    var videoComposition: AVVideoComposition? {
-        didSet {
-            lastKnownViewSizeForThumbnailGeneration = .zero
-            setNeedsLayout()
-        }
-    }
-
-    // a clip cannot be trimmed shorter than this duration
-    var minimumDuration: CMTime = CMTime(seconds: 1, preferredTimescale: 600)
-    var maximumDuration: CMTime = .positiveInfinity
-
-    // the available range of the asset.
-    // Will be set to the full duration of the asset when assigning a new asset
-    var range: CMTimeRange = .invalid {
-        didSet {
-            setNeedsLayout()
-        }
-    }
-
-    // the range that is selected, will be set to the full duration
-    // when changing asset.
-    var selectedRange: CMTimeRange = .invalid {
-        didSet {
-            setNeedsLayout()
-        }
-    }
-
-    // defines what to do with the progress indicator
-    enum ProgressIndicatorMode {
-        case hiddenOnlyWhenTrimming // the progress indicator gets hidden when the user starts trimming
-        case alwaysShown // the progress indicator is always shown, even when the user is trimming
-        case alwaysHidden // the progress indicator is never shown
-    }
-    var progressIndicatorMode = ProgressIndicatorMode.hiddenOnlyWhenTrimming {
-        didSet {
-            updateProgressIndicator()
-        }
-    }
-
-    func setProgressIndicatorMode(_ mode: ProgressIndicatorMode, animated: Bool) {
-        guard progressIndicatorMode != mode else {return}
-
-        if animated == true {
-            UIView.animate(withDuration: 0.25, delay: 0, options: [.beginFromCurrentState, .allowUserInteraction], animations: {
-                self.progressIndicatorMode = mode
-                self.layoutIfNeeded()
-            })
-        } else {
-            progressIndicatorMode = mode
-        }
-    }
-
-    // defines where the progress indicator is shown.
-    var progress: CMTime = .zero {
-        didSet {
-            setNeedsLayout()
-        }
-    }
-
-    func setProgress(_ progress: CMTime, animated: Bool) {
-        guard CMTimeCompare(self.progress, progress) != 0 else {return}
-
-        self.progress = progress
-        if animated == true {
-            UIView.animate(withDuration: 0.25, delay: 0, options: [.beginFromCurrentState, .allowUserInteraction], animations: {
-                self.layoutIfNeeded()
-            })
-        }
-    }
-
-
-    // defines if the user is trimming or not, and if so, which edge
-    enum TrimmingState {
-        case none        // user isn't trimming
-        case leading    // user is trimming the leading part of the asset
-        case trailing    // user is trimming the trailing part of the asset
-    }
-
-    private(set) var trimmingState = TrimmingState.none {
-        didSet {
-            UIViewPropertyAnimator.runningPropertyAnimator(withDuration: 0.25, delay: 0, options: [.beginFromCurrentState, .allowUserInteraction], animations: {
-                self.shadowView.layer.shadowOpacity = (self.trimmingState != .none ? 0.5 : 0.25)
-                self.shadowView.layer.shadowRadius = (self.trimmingState != .none ? 4 : 2)
-            })
-        }
-    }
-
-    // yes if the user is zoomed in
-    private(set) var isZoomedIn = false
-    private(set) var zoomedInRange: CMTimeRange = .zero
-
-
-    // yes if the user is scrubbing the progress indicator
-    private(set) var isScrubbing = false
-
-    // background color for the track
-    var trackBackgroundColor = UIColor.black {
-        didSet {
-            thumbnailWrapperView.backgroundColor = trackBackgroundColor
-        }
-    }
-
-    // background color for the place where the thumbs rest on when the selectedRange == range
-    var thumbRestColor = UIColor.black {
-        didSet {
-            leadingThumbRest.backgroundColor = thumbRestColor
-            trailingThumbRest.backgroundColor = thumbRestColor
-        }
-    }
-
-    // the range that's currently visible: could be less than "range" when zoomed in
-    var visibleRange: CMTimeRange  {
-        return isZoomedIn == true ? zoomedInRange : range
-    }
-
-    // the time that's currently selected by the user when trimming
-    var selectedTime: CMTime {
-        switch trimmingState {
-            case .none: return .zero
-            case .leading: return selectedRange.start
-            case .trailing: return selectedRange.end
-        }
-    }
-
-    // gesture recognizers used. Can be used, for instance, to
-    // require a tableview panGestureRecognizer to fail
-    private (set) var leadingGestureRecognizer: UILongPressGestureRecognizer!
-    private (set) var trailingGestureRecognizer: UILongPressGestureRecognizer!
-    private (set) var progressGestureRecognizer: UILongPressGestureRecognizer!
-    private (set) var thumbnailInteractionGestureRecognizer: UILongPressGestureRecognizer!
-
-    // private stuff
-    private var grabberOffset = CGFloat(0)
-    private var zoomWaitTimer: Timer?
-
-    private var lastKnownViewSizeForThumbnailGeneration: CGSize = .zero
-    private var thumbnailSize: CGSize = .zero
-    private var lastKnownThumbnailRange: CMTimeRange = .zero
-    private var thumbnails = Array<Thumbnail>()
-    private var generator: AVAssetImageGenerator?
-
-    private var impactFeedbackGenerator: UIImpactFeedbackGenerator?
-    private var didClampWhilePanning = false
-
-
-    // MARK: - Private
-    private func setup() {
-        addSubview(thumbnailClipView)
-        thumbnailClipView.addSubview(thumbnailWrapperView)
-        thumbnailWrapperView.addSubview(leadingThumbRest)
-        thumbnailWrapperView.addSubview(trailingThumbRest)
-        thumbnailWrapperView.addSubview(thumbnailTrackView)
-        thumbnailWrapperView.addSubview(thumbnailLeadingCoverView)
-        thumbnailWrapperView.addSubview(thumbnailTrailingCoverView)
-
-        progressIndicator.backgroundColor = .white
-        progressIndicator.layer.shadowColor = UIColor.black.cgColor
-        progressIndicator.layer.shadowOffset = .zero
-        progressIndicator.layer.shadowRadius = 2
-        progressIndicator.layer.shadowOpacity = 0.25
-        progressIndicator.layer.cornerRadius = 2
-        progressIndicator.layer.cornerCurve = .continuous
-
-        addSubview(shadowView)
-        wrapperView.clipsToBounds = true
-        shadowView.addSubview(wrapperView)
-        wrapperView.addSubview(thumbView)
-
-        wrapperView.addSubview(progressIndicator)
-        wrapperView.addSubview(progressIndicatorControl)
-
-        thumbnailClipView.clipsToBounds = true
-        thumbnailTrackView.clipsToBounds = true
-        thumbnailLeadingCoverView.backgroundColor = UIColor(white: 0, alpha: 0.75)
-        thumbnailTrailingCoverView.backgroundColor = UIColor(white: 0, alpha: 0.75)
-
-        leadingThumbRest.backgroundColor = thumbRestColor
-        trailingThumbRest.backgroundColor = thumbRestColor
-
-        thumbnailWrapperView.backgroundColor = trackBackgroundColor
-        thumbnailWrapperView.layer.cornerRadius = 6
-        thumbnailWrapperView.layer.cornerCurve = .continuous
-
-        leadingThumbRest.layer.cornerRadius = 6
-        leadingThumbRest.layer.maskedCorners = [.layerMinXMaxYCorner, .layerMinXMinYCorner]
-        leadingThumbRest.layer.cornerCurve = .continuous
-
-        trailingThumbRest.layer.cornerRadius = 6
-        trailingThumbRest.layer.maskedCorners = [.layerMaxXMaxYCorner, .layerMaxXMinYCorner]
-        trailingThumbRest.layer.cornerCurve = .continuous
-
-        shadowView.layer.shadowColor = UIColor.black.cgColor
-        shadowView.layer.shadowOffset = .zero
-        shadowView.layer.shadowRadius = 2
-        shadowView.layer.shadowOpacity = 0.25
-
-        leadingGestureRecognizer = UILongPressGestureRecognizer(target: self, action: #selector(leadingGrabberPanned(_:)))
-        leadingGestureRecognizer.allowableMovement = CGFloat.greatestFiniteMagnitude
-        leadingGestureRecognizer.minimumPressDuration = 0
-        thumbView.leadingGrabber.addGestureRecognizer(leadingGestureRecognizer)
-
-        trailingGestureRecognizer = UILongPressGestureRecognizer(target: self, action: #selector(trailingGrabberPanned(_:)))
-        trailingGestureRecognizer.allowableMovement = CGFloat.greatestFiniteMagnitude
-        trailingGestureRecognizer.minimumPressDuration = 0
-        thumbView.trailingGrabber.addGestureRecognizer(trailingGestureRecognizer)
-
-        progressGestureRecognizer = UILongPressGestureRecognizer(target: self, action: #selector(progressGrabberPanned(_:)))
-        progressGestureRecognizer.allowableMovement = CGFloat.greatestFiniteMagnitude
-        progressGestureRecognizer.minimumPressDuration = 0
-        progressGestureRecognizer.require(toFail: leadingGestureRecognizer)
-        progressGestureRecognizer.require(toFail: trailingGestureRecognizer)
-        progressIndicatorControl.addGestureRecognizer(progressGestureRecognizer)
-
-        thumbnailInteractionGestureRecognizer = UILongPressGestureRecognizer(target: self, action: #selector(thumbnailPanned(_:)))
-        thumbnailInteractionGestureRecognizer.allowableMovement = CGFloat.greatestFiniteMagnitude
-        thumbnailInteractionGestureRecognizer.minimumPressDuration = 0
-        thumbnailInteractionGestureRecognizer.require(toFail: leadingGestureRecognizer)
-        thumbnailInteractionGestureRecognizer.require(toFail: trailingGestureRecognizer)
-        thumbView.addGestureRecognizer(thumbnailInteractionGestureRecognizer)
-    }
-
-    private func regenerateThumbnailsIfNeeded() {
-        let size = bounds.size
-        guard size.width > 0 && size.height > 0 else {return}
-        guard lastKnownViewSizeForThumbnailGeneration != size || CMTimeRangeEqual(lastKnownThumbnailRange, visibleRange) == false else {return}
-        guard let asset = asset else {return}
-        guard let track = asset.tracks(withMediaType: .video).first else {return}
-
-        lastKnownViewSizeForThumbnailGeneration = size
-        lastKnownThumbnailRange = visibleRange
-
-        let naturalSize = track.naturalSize
-        let transform = track.preferredTransform
-        let fixedSize = naturalSize.applyingVideoTransform(transform)
-
-        let generator = AVAssetImageGenerator(asset: asset)
-        generator.apertureMode = .cleanAperture
-        generator.videoComposition = videoComposition
-        self.generator = generator
-
-        let height = size.height - thumbView.edgeHeight * 2
-        thumbnailSize = CGSize(width: height / fixedSize.height * fixedSize.width, height: height)
-        let numberOfThumbnails = Int(ceil(size.width / thumbnailSize.width))
-
-        var newThumbnails = Array<Thumbnail>()
-        let thumbnailDuration = visibleRange.duration.seconds / Double(numberOfThumbnails)
-        var times = Array<NSValue>()
-        // we add some extra thumbnails as padding
-        for index in -3..<numberOfThumbnails + 6 {
-            let time = CMTimeAdd(visibleRange.start, CMTime(seconds: thumbnailDuration * Double(index), preferredTimescale: asset.duration.timescale * 2))
-            guard CMTimeCompare(time, .zero) != -1 else {continue}
-            times.append(NSValue(time: time))
-
-            let newThumbnail = Thumbnail(imageView: UIImageView(), time: time)
-            self.thumbnailTrackView.addSubview(newThumbnail.imageView)
-            newThumbnails.append(newThumbnail)
-        }
-
-        generator.appliesPreferredTrackTransform = true
-        generator.maximumSize = CGSize(width: thumbnailSize.width * UIScreen.main.scale, height: thumbnailSize.height * UIScreen.main.scale)
-
-        let oldThumbnails = thumbnails
-        thumbnails.append(contentsOf: newThumbnails)
-
-        UIView.animate(withDuration: 0.25, delay: 0.25, options: [.beginFromCurrentState], animations: {
-            oldThumbnails.forEach {$0.imageView.alpha = 0}
-        }, completion: { _ in
-            oldThumbnails.forEach {$0.imageView.removeFromSuperview()}
-            let uuidsToRemove = Set(oldThumbnails.map({$0.uuid}))
-            self.thumbnails.removeAll(where: {uuidsToRemove.contains($0.uuid)})
-        })
-
-        var seenIndex = 0
-        generator.requestedTimeToleranceBefore = .zero
-        generator.requestedTimeToleranceAfter = .zero
-        generator.generateCGImagesAsynchronously(forTimes: times) { requestedTime, cgImage, actualTime, result, error in
-            DispatchQueue.main.async {
-                seenIndex += 1
-
-                guard let cgImage = cgImage else {return}
-                let image = UIImage(cgImage: cgImage)
-
-                let imageView = newThumbnails[seenIndex - 1].imageView
-                UIView.transition(with: imageView, duration: 0.25, options: [.transitionCrossDissolve], animations: {
-                    imageView.image = image
-                })
-            }
-        }
-    }
-
-    private func timeForLocation(_ x: CGFloat) -> CMTime {
-        let size = bounds.size
-        let inset = thumbView.chevronWidth + horizontalInset
-        let offset = x - inset
-
-        let availableWidth = size.width - inset * 2
-        let visibleDurationInSeconds = CGFloat(visibleRange.duration.seconds)
-        let ratio = visibleDurationInSeconds != 0 ? availableWidth / visibleDurationInSeconds : 0
-
-        let timeDifference = CMTime(seconds: Double(offset / ratio), preferredTimescale: 600)
-        return CMTimeAdd(visibleRange.start, timeDifference)
-    }
-
-    private func locationForTime(_ time: CMTime) -> CGFloat {
-        let size = bounds.size
-        let inset = thumbView.chevronWidth + horizontalInset
-        let availableWidth = size.width - inset * 2
-
-        let offset = CMTimeSubtract(time, visibleRange.start)
-
-        let visibleDurationInSeconds = CGFloat(visibleRange.duration.seconds)
-        let ratio = visibleDurationInSeconds != 0 ? availableWidth / visibleDurationInSeconds : 0
-
-        let location = CGFloat(offset.seconds) * ratio
-        return SnapToDevicePixels(location) + inset
-    }
-
-    private func startZoomWaitTimer() {
-        stopZoomWaitTimer()
-        guard isZoomedIn == false else {return}
-        zoomWaitTimer = Timer.scheduledTimer(withTimeInterval: 0.5, repeats: false, block: { [weak self] _ in
-            guard let self = self else {return}
-            self.stopZoomWaitTimer()
-            self.zoomIfNeeded()
-        })
-    }
-
-    private func stopZoomWaitTimer() {
-        zoomWaitTimer?.invalidate()
-        zoomWaitTimer = nil
-    }
-
-    private func stopZoomIfNeeded() {
-        stopZoomWaitTimer()
-        isZoomedIn = false
-        animateChanges()
-    }
-
-    private func zoomIfNeeded() {
-        guard isZoomedIn == false else {return}
-
-        let size = bounds.size
-        let inset = thumbView.chevronWidth + horizontalInset
-        let availableWidth = size.width - inset * 2
-        let newDuration = CGFloat(range.duration.seconds > 4 ?  2.0 : range.duration.seconds * 0.5)
-
-        let durationTime = CMTime(seconds: Double(newDuration), preferredTimescale: 600)
-
-        if trimmingState == .leading {
-            let position = locationForTime(selectedRange.start) - inset
-            let start = position / availableWidth * newDuration
-            zoomedInRange = CMTimeRange(start: CMTimeSubtract(selectedRange.start, CMTime(seconds: Double(start), preferredTimescale: 600)), duration: durationTime)
-        } else {
-            let position = locationForTime(selectedRange.end) - inset
-
-            let durationToStart = position / availableWidth * newDuration
-            let newStart = CMTimeSubtract(selectedRange.end, CMTime(seconds: Double(durationToStart), preferredTimescale: 600))
-            zoomedInRange = CMTimeRange(start: newStart, duration: durationTime)
-        }
-
-        isZoomedIn = true
-        animateChanges()
-
-        UISelectionFeedbackGenerator().selectionChanged()
-    }
-
-    private func animateChanges() {
-        setNeedsLayout()
-        thumbView.setNeedsLayout()
-        UIView.animate(withDuration: 0.5, delay: 0, options: [.beginFromCurrentState, .allowUserInteraction], animations: {
-            self.layoutIfNeeded()
-            self.thumbView.layoutIfNeeded()
-        })
-    }
-
-    private func startPanning() {
-        sendActions(for: Self.didBeginTrimming)
-        UISelectionFeedbackGenerator().selectionChanged()
-
-        didClampWhilePanning = false
-
-        impactFeedbackGenerator = UIImpactFeedbackGenerator(style: .heavy)
-        impactFeedbackGenerator?.prepare()
-
-        UIView.animate(withDuration: 0.25, delay: 0, options: [.beginFromCurrentState, .allowUserInteraction], animations: {
-            self.updateProgressIndicator()
-        })
-    }
-
-    private func stopPanning() {
-        trimmingState = .none
-        stopZoomIfNeeded()
-        impactFeedbackGenerator = nil
-        sendActions(for: Self.didEndTrimming)
-
-        UIView.animate(withDuration: 0.25, delay: 0, options: [.beginFromCurrentState, .allowUserInteraction], animations: {
-            self.updateProgressIndicator()
-        })
-    }
-
-    private func updateProgressIndicator() {
-        switch progressIndicatorMode {
-            case .alwaysHidden:
-                progressIndicator.alpha = 0
-                progressIndicatorControl.isUserInteractionEnabled = false
-
-            case .alwaysShown:
-                progressIndicator.alpha = 1
-                progressIndicatorControl.isUserInteractionEnabled = true
-                setNeedsLayout()
-
-            case .hiddenOnlyWhenTrimming:
-                progressIndicator.alpha = (trimmingState == .none ? 1 : 0)
-                progressIndicatorControl.isUserInteractionEnabled = (trimmingState == .none)
-                if trimmingState == .none {
-                    setNeedsLayout()
-                    if UIView.inheritedAnimationDuration > 0 {
-                        UIView.performWithoutAnimation {
-                            layoutIfNeeded()
-                        }
-                    }
-                }
-        }
-        progressIndicatorControl.alpha = progressIndicator.alpha
-    }
-
-
-    // MARK: - Input
-    @objc private func thumbnailPanned(_ sender: UILongPressGestureRecognizer) {
-        progressGrabberPanned(sender)
-    }
-
-
-    @objc private func progressGrabberPanned(_ sender: UILongPressGestureRecognizer) {
-
-        func handleChanged() {
-            let location = sender.location(in: self)
-            var time = timeForLocation(location.x + grabberOffset)
-
-            var didClamp = false
-            if CMTimeCompare(time, selectedRange.start) == -1 {
-                time = selectedRange.start
-                didClamp = true
-            }
-            if CMTimeCompare(time, selectedRange.end) == 1 {
-                time = selectedRange.end
-                didClamp = true
-            }
-
-            if didClamp == true && didClamp != didClampWhilePanning {
-                impactFeedbackGenerator?.impactOccurred()
-            }
-            didClampWhilePanning = didClamp
-
-            progress = time
-            setNeedsLayout()
-            sendActions(for: Self.progressChanged)
-        }
-        switch sender.state {
-            case .began:
-
-                UISelectionFeedbackGenerator().selectionChanged()
-                impactFeedbackGenerator = UIImpactFeedbackGenerator(style: .heavy)
-                impactFeedbackGenerator?.prepare()
-                didClampWhilePanning = false
-
-                isScrubbing = true
-                sendActions(for: Self.didBeginScrubbing)
-                handleChanged()
-
-            case .changed:
-                handleChanged()
-
-            case .ended, .cancelled:
-                impactFeedbackGenerator = nil
-
-                isScrubbing = false
-                sendActions(for: Self.didEndScrubbing)
-
-            case .possible, .failed:
-                break
-
-            @unknown default:
-                break
-        }
-    }
-
-
-    @objc private func leadingGrabberPanned(_ sender: UILongPressGestureRecognizer) {
-        switch sender.state {
-            case .began:
-                trimmingState = .leading
-                grabberOffset = thumbView.chevronWidth - sender.location(in: thumbView.leadingGrabber).x
-
-                startPanning()
-
-            case .changed:
-                let location = sender.location(in: self)
-                var time = timeForLocation(location.x + grabberOffset)
-                let newDuration = CMTimeSubtract(selectedRange.end, time)
-                let newRange = CMTimeRange(start: time, end: selectedRange.end)
-            
-                if CMTimeCompare(newRange.duration, maximumDuration) == 1 {
-                    return
-                }
-            
-                if CMTimeCompare(newRange.start, .zero) == -1 { // prevent start time to be less than 0
-                    return
-                }
-
-                var didClamp = false
-                if CMTimeCompare(newDuration, minimumDuration) == -1 {
-                    // time = CMTimeSubtract(selectedRange.end, minimumDuration)
-                    // didClamp = true
-                    return
-                }
-                if CMTimeCompare(time, range.start) == -1 {
-                    time = range.start
-                    didClamp = true
-                }
-                if CMTimeCompare(time, range.end) == 1 {
-                    time = range.end
-                    didClamp = true
-                }
-
-
-                if didClamp == true && didClamp != didClampWhilePanning {
-                    impactFeedbackGenerator?.impactOccurred()
-                } else {
-//                    if didClamp == false && CMTimeCompare(progress, time) == 0 && CMTimeCompare(progress, range.start) != 0 && CMTimeCompare(progress, range.end) != 0 {
-//                        impactFeedbackGenerator?.impactOccurred(intensity: 0.5)
-//                        didClamp = true
-//                    }
-                }
-                didClampWhilePanning = didClamp
-
-                selectedRange = newRange
-                sendActions(for: Self.selectedRangeChanged)
-                setNeedsLayout()
-
-                startZoomWaitTimer()
-
-            case .ended:
-                stopPanning()
-
-            case .cancelled:
-                stopPanning()
-
-            case .possible, .failed:
-                break
-
-            @unknown default:
-                break
-        }
-    }
-
-    @objc private func trailingGrabberPanned(_ sender: UILongPressGestureRecognizer) {
-        switch sender.state {
-            case .began:
-                trimmingState = .trailing
-                grabberOffset = sender.location(in: thumbView.trailingGrabber).x
-
-                startPanning()
-
-            case .changed:
-                let location = sender.location(in: self)
-                var time = timeForLocation(location.x - grabberOffset)
-                let newDuration = CMTimeSubtract(time, selectedRange.start)
-                let newRange = CMTimeRange(start: selectedRange.start, end: time)
-            
-                if CMTimeCompare(newRange.duration, maximumDuration) == 1 {
-                    return
-                }
-            
-                if CMTimeCompare(newRange.end, range.duration) == 1 { // prevent endTime to be greater than video endTime
-                    return
-                }
-
-                var didClamp = false
-                if CMTimeCompare(newDuration, minimumDuration) == -1 {
-                    // time = CMTimeAdd(selectedRange.start, minimumDuration)
-                    // didClamp = true
-                    return
-                }
-                if CMTimeCompare(time, range.start) == -1 {
-                    time = range.start
-                    didClamp = true
-                }
-                if CMTimeCompare(time, range.end) == 1 {
-                    time = range.end
-                    didClamp = true
-                }
-
-                if didClamp == true && didClamp != didClampWhilePanning {
-                    impactFeedbackGenerator?.impactOccurred()
-                } else {
-//                    if didClamp == false && CMTimeCompare(progress, time) == 0 && CMTimeCompare(progress, range.start) != 0 && CMTimeCompare(progress, range.end) != 0 {
-//                        impactFeedbackGenerator?.impactOccurred(intensity: 0.5)
-//                        didClamp = true
-//                    }
-                }
-                didClampWhilePanning = didClamp
-
-                selectedRange = newRange
-                sendActions(for: Self.selectedRangeChanged)
-                setNeedsLayout()
-
-                startZoomWaitTimer()
-
-            case .ended:
-                stopPanning()
-
-            case .cancelled:
-                stopPanning()
-
-            case .possible, .failed:
-                break
-
-            @unknown default:
-                break
-        }
-    }
-
-    // MARK: - UIView
-
-    override var intrinsicContentSize: CGSize {
-        return CGSize(width: UIView.noIntrinsicMetric, height: 50)
-    }
-
-    override func layoutSubviews() {
-        super.layoutSubviews()
-
-        let size = bounds.size
-        let inset = thumbView.chevronWidth
-        var left = locationForTime(selectedRange.start) - inset
-        var right = locationForTime(selectedRange.end) + inset
-
-        if right > bounds.width {
-            right = bounds.width + inset * 2
-        }
-
-        if left < 0 {
-            left = -inset
-        }
-
-        let rect = CGRect(origin: .zero, size: size)
-        shadowView.frame = rect
-        wrapperView.frame = rect
-        thumbView.frame = CGRect(x: left, y: 0, width: max(right - left, inset * 2), height: size.height)
-
-        let isZoomedToEnd = (trimmingState == .leading && isZoomedIn == true)
-
-        let thumbnailOffset = (isZoomedIn == true ? horizontalInset + inset + 6 : 0)
-        let coverOffset = thumbnailOffset - horizontalInset
-        let coverStartOffset = (isZoomedIn == false ? inset : 0)
-
-        let thumbnailRect = rect.insetBy(dx: horizontalInset - thumbnailOffset, dy: thumbView.edgeHeight)
-        thumbnailClipView.frame = rect
-        thumbnailWrapperView.frame = thumbnailRect
-        thumbnailTrackView.frame = CGRect(origin: .zero, size: CGSize(width: thumbnailRect.width - (isZoomedToEnd == false ? inset : 0), height: thumbnailRect.height))
-        thumbnailLeadingCoverView.frame = CGRect(x: coverStartOffset, y: 0, width: left + inset * 0.5 + coverOffset - coverStartOffset, height: thumbnailRect.height)
-        thumbnailTrailingCoverView.frame = CGRect(x: right - inset * 0.5 + coverOffset, y: 0, width: thumbnailRect.width - coverStartOffset - (right - inset * 0.5 + coverOffset), height: thumbnailRect.height)
-
-        leadingThumbRest.frame = CGRect(x: 0, y: 0, width: inset, height: thumbnailRect.height)
-        trailingThumbRest.frame = CGRect(x: thumbnailRect.width - inset, y: 0, width: inset, height: thumbnailRect.height)
-
-        if progressIndicator.alpha > 0 {
-            let progressWidth = CGFloat(4)
-            let progressIndicatorOffset = locationForTime(progress)
-            let progressLeft = min(max(thumbView.frame.minX + inset, progressIndicatorOffset - progressWidth * 0.5), thumbView.frame.maxX - inset - progressWidth)
-            progressIndicator.frame = CGRect(x: progressLeft, y: thumbnailRect.minY, width: progressWidth, height: thumbnailRect.height)
-
-            let progressControlWidth = CGFloat(24)
-
-            var progressControlLeft = max(thumbView.frame.minX + inset, progressLeft)
-            var progressControlRight = progressLeft + progressControlWidth
-            if progressControlRight > thumbView.frame.maxX - inset {
-                progressControlRight = thumbView.frame.maxX - inset
-                progressControlLeft = max(thumbView.frame.minX + inset, progressControlRight - progressControlWidth)
-            }
-            progressIndicatorControl.frame = CGRect(x: progressControlLeft, y: thumbnailRect.minY, width: progressControlRight - progressControlLeft, height: thumbnailRect.height)
-        }
-
-        regenerateThumbnailsIfNeeded()
-
-        for thumbnail in thumbnails {
-            let position = locationForTime(thumbnail.time) - horizontalInset + thumbnailOffset
-            let frame = CGRect(x: position, y: 0, width: thumbnailSize.width, height: thumbnailSize.height)
-            if thumbnail.imageView.bounds.width == 0 {
-                UIView.performWithoutAnimation {
-                    thumbnail.imageView.frame = frame
-                }
-            } else {
-                thumbnail.imageView.frame = frame
-            }
-        }
-    }
-
-    override init(frame: CGRect) {
-        super.init(frame: frame)
-        setup()
-    }
-
-    required init?(coder: NSCoder) {
-        super.init(coder: coder)
-        setup()
-    }
-}
-
-// MARK: -
-
-fileprivate func SnapToDevicePixels(_ value: CGFloat, scale: CGFloat? = nil) -> CGFloat {
-    let actualScale = scale ?? UIScreen.main.scale
-    return round(value * actualScale) / actualScale
-}
-
-fileprivate func SnapToDevicePixels(_ rect: CGRect, scale: CGFloat? = nil) -> CGRect {
-    return CGRect(x: SnapToDevicePixels(rect.origin.x, scale: scale),
-                  y: SnapToDevicePixels(rect.origin.y, scale: scale),
-                  width: SnapToDevicePixels(rect.maxX - rect.minX, scale: scale),
-                  height: SnapToDevicePixels(rect.maxY - rect.minY, scale: scale))
-}
-
-fileprivate extension CGRect {
-    func snappedToDevicePixels(scale: CGFloat? = nil) -> CGRect {
-        return SnapToDevicePixels(self, scale: scale)
-    }
-}
-
-fileprivate extension CGSize {
-    func ceiled() -> CGSize {
-        return CGSize(width: ceil(width), height: ceil((height)))
-    }
-
-    func snappedToDevicePixels(scale: CGFloat? = nil) -> CGSize {
-        return CGSize(width: SnapToDevicePixels(width, scale: scale), height: SnapToDevicePixels(height, scale: scale))
-    }
-
-    func applyingVideoTransform(_ transform: CGAffineTransform) -> CGSize {
-        return CGRect(origin: .zero, size: self).applying(transform).size
-    }
-}