Yattee v2 rewrite

Yattee/Views/Player/tvOS/TVPlayerProgressBar.swift

@@ -0,0 +1,421 @@
+//
+//  TVPlayerProgressBar.swift
+//  Yattee
+//
+//  Focusable progress bar for tvOS with smooth touchpad scrubbing support.
+//
+
+#if os(tvOS)
+import SwiftUI
+import UIKit
+
+/// Progress bar with smooth scrubbing support for tvOS Siri Remote touchpad.
+struct TVPlayerProgressBar: View {
+    let currentTime: TimeInterval
+    let duration: TimeInterval
+    let bufferedTime: TimeInterval
+    let storyboard: Storyboard?
+    let chapters: [VideoChapter]
+    let onSeek: (TimeInterval) -> Void
+    /// Called when scrubbing state changes - parent should stop auto-hide timer when true
+    var onScrubbingChanged: ((Bool) -> Void)?
+    /// Whether the current stream is live
+    let isLive: Bool
+    /// Whether to show chapter markers on the progress bar (default: true)
+    var showChapters: Bool = true
+    /// SponsorBlock segments to display on the progress bar.
+    var sponsorSegments: [SponsorBlockSegment] = []
+    /// Settings for SponsorBlock segment display.
+    var sponsorBlockSettings: SponsorBlockSegmentSettings = .default
+    /// Color for the played portion of the progress bar.
+    var playedColor: Color = .red
+
+    /// Track focus state internally.
+    @FocusState private var isFocused: Bool
+
+    /// Time during active scrubbing (nil when not scrubbing).
+    @State private var scrubTime: TimeInterval?
+
+    /// Whether user is actively scrubbing.
+    @State private var isScrubbing = false
+
+    /// Accumulated pan translation for scrubbing.
+    @State private var panAccumulator: CGFloat = 0
+
+    /// The time to display (scrub time if scrubbing, else current time).
+    private var displayTime: TimeInterval {
+        scrubTime ?? currentTime
+    }
+
+    /// Progress as a fraction (0-1).
+    private var progress: Double {
+        guard duration > 0 else { return 0 }
+        return min(max(displayTime / duration, 0), 1)
+    }
+
+    /// Buffered progress as a fraction (0-1).
+    private var bufferedProgress: Double {
+        guard duration > 0 else { return 0 }
+        return min(bufferedTime / duration, 1)
+    }
+
+    var body: some View {
+        ZStack {
+            // Gesture capture layer (only when scrubbing)
+            if isScrubbing {
+                TVPanGestureView(
+                    onPanChanged: { translation, velocity in
+                        handlePan(translation: translation, velocity: velocity)
+                    },
+                    onPanEnded: {
+                        handlePanEnded()
+                    }
+                )
+                .frame(maxWidth: .infinity, maxHeight: .infinity)
+            }
+
+            // Visual content with button for click-to-scrub (disabled for live)
+            Button {
+                if isScrubbing {
+                    commitScrub()
+                } else if !isLive {
+                    enterScrubMode()
+                }
+            } label: {
+                progressContent
+            }
+            .buttonStyle(TVProgressBarButtonStyle(isFocused: isFocused))
+            .disabled(isLive)
+        }
+        .focused($isFocused)
+        .onMoveCommand { direction in
+            // D-pad fallback for scrubbing
+            if isScrubbing {
+                handleDPad(direction: direction)
+            }
+        }
+        .onChange(of: isFocused) { _, focused in
+            if !focused {
+                commitScrub()
+            }
+        }
+        .animation(.easeInOut(duration: 0.2), value: isFocused)
+        .animation(.easeInOut(duration: 0.1), value: isScrubbing)
+    }
+
+    private func enterScrubMode() {
+        scrubTime = currentTime
+        panAccumulator = 0
+        withAnimation(.easeOut(duration: 0.15)) {
+            isScrubbing = true
+        }
+        onScrubbingChanged?(true)
+    }
+
+    private var progressContent: some View {
+        VStack(spacing: 12) {
+            // Progress bar (hide for live streams)
+            if !isLive {
+                GeometryReader { geometry in
+                    ZStack(alignment: .leading) {
+                        // Progress bar with chapter segments (4pt gaps for tvOS visibility)
+                        SegmentedProgressBar(
+                            chapters: showChapters ? chapters : [],
+                            duration: duration,
+                            currentTime: displayTime,
+                            bufferedTime: bufferedTime,
+                            height: isFocused ? (isScrubbing ? 16 : 12) : 6,
+                            gapWidth: 4,
+                            playedColor: isFocused ? playedColor : .white,
+                            bufferedColor: .white.opacity(0.4),
+                            backgroundColor: .white.opacity(0.2),
+                            sponsorSegments: sponsorSegments,
+                            sponsorBlockSettings: sponsorBlockSettings
+                        )
+
+                        // Scrub handle (visible when focused)
+                        if isFocused {
+                            Circle()
+                                .fill(.white)
+                                .frame(width: isScrubbing ? 32 : 24, height: isScrubbing ? 32 : 24)
+                                .shadow(color: .black.opacity(0.3), radius: 4)
+                                .offset(x: (geometry.size.width * progress) - (isScrubbing ? 16 : 12))
+                                .animation(.easeOut(duration: 0.1), value: progress)
+                        }
+                    }
+                }
+                .frame(height: isFocused ? (isScrubbing ? 16 : 12) : 6)
+            }
+
+            // Time labels
+            HStack {
+                // Current time or LIVE indicator
+                if isLive {
+                    HStack(spacing: 6) {
+                        Circle()
+                            .fill(.red)
+                            .frame(width: 8, height: 8)
+                        Text("LIVE")
+                            .font(.subheadline.weight(.semibold))
+                            .foregroundStyle(.red)
+                    }
+                } else {
+                    Text(formatTime(displayTime))
+                        .monospacedDigit()
+                        .font(.subheadline)
+                        .fontWeight(isScrubbing ? .semibold : .regular)
+                        .foregroundStyle(.white)
+                }
+
+                Spacer()
+
+                // Scrub hint when focused (only for non-live)
+                if !isLive && isFocused && !isScrubbing {
+                    Text("Press to scrub")
+                        .font(.caption)
+                        .foregroundStyle(.white.opacity(0.5))
+                } else if !isLive && isScrubbing {
+                    Text("Swipe ← → • press to seek")
+                        .font(.caption)
+                        .foregroundStyle(.white.opacity(0.7))
+                }
+
+                Spacer()
+
+                // Remaining time (only for non-live)
+                if !isLive {
+                    Text("-\(formatTime(max(0, duration - displayTime)))")
+                        .monospacedDigit()
+                        .font(.subheadline)
+                        .foregroundStyle(.white.opacity(0.7))
+                }
+            }
+
+            // Scrub preview (storyboard thumbnail or large time display)
+            if isScrubbing {
+                if let storyboard {
+                    TVSeekPreviewView(
+                        storyboard: storyboard,
+                        seekTime: scrubTime ?? currentTime,
+                        chapters: showChapters ? chapters : []
+                    )
+                    .transition(.scale.combined(with: .opacity))
+                } else {
+                    // Fallback when no storyboard available
+                    Text(formatTime(scrubTime ?? currentTime))
+                        .font(.system(size: 48, weight: .medium))
+                        .monospacedDigit()
+                        .foregroundStyle(.white)
+                        .padding(.horizontal, 32)
+                        .padding(.vertical, 16)
+                        .background(
+                            RoundedRectangle(cornerRadius: 16)
+                                .fill(.ultraThinMaterial)
+                        )
+                        .transition(.scale.combined(with: .opacity))
+                }
+            }
+        }
+    }
+
+    // MARK: - Pan Gesture Handling
+
+    private func handlePan(translation: CGFloat, velocity: CGFloat) {
+        guard duration > 0, isScrubbing else { return }
+
+        // Cancel any pending seek when user starts new pan
+        seekTask?.cancel()
+
+        // Calculate scrub sensitivity based on duration
+        // Lower values = slower/finer scrubbing
+        let baseSensitivity: CGFloat
+        if duration > 3600 {
+            baseSensitivity = duration / 2000  // ~1.8 sec per unit for 1hr video
+        } else if duration > 600 {
+            baseSensitivity = duration / 3000  // ~0.2 sec per unit for 10min video
+        } else {
+            baseSensitivity = duration / 4000  // very fine control for short videos
+        }
+
+        // Apply velocity multiplier (faster swipe = faster scrub)
+        // Reduced range: 0.3x to 2.0x
+        let velocityMultiplier = min(max(abs(velocity) / 800, 0.3), 2.0)
+        let adjustedSensitivity = baseSensitivity * velocityMultiplier
+
+        // Update scrub time based on translation delta
+        let delta = translation - panAccumulator
+        panAccumulator = translation
+
+        let timeChange = TimeInterval(delta * adjustedSensitivity)
+        let currentScrubTime = scrubTime ?? currentTime
+        scrubTime = min(max(0, currentScrubTime + timeChange), duration)
+    }
+
+    private func handlePanEnded() {
+        // Reset accumulator for next swipe
+        panAccumulator = 0
+        // Schedule debounced seek but stay in scrub mode
+        scheduleSeek()
+    }
+
+    @State private var seekTask: Task<Void, Never>?
+
+    private func scheduleSeek() {
+        seekTask?.cancel()
+        seekTask = Task {
+            try? await Task.sleep(for: .milliseconds(1000))
+            guard !Task.isCancelled else { return }
+            await MainActor.run {
+                if let time = scrubTime {
+                    onSeek(time)
+                }
+            }
+        }
+    }
+
+    // MARK: - D-Pad Fallback
+
+    private func handleDPad(direction: MoveCommandDirection) {
+        guard duration > 0, isScrubbing else { return }
+
+        switch direction {
+        case .left, .right:
+            // Determine scrub increment based on video length
+            let scrubAmount: TimeInterval
+            if duration > 3600 {
+                scrubAmount = 30
+            } else if duration > 600 {
+                scrubAmount = 15
+            } else {
+                scrubAmount = 10
+            }
+
+            let currentScrubTime = scrubTime ?? currentTime
+            if direction == .left {
+                scrubTime = max(0, currentScrubTime - scrubAmount)
+            } else {
+                scrubTime = min(duration, currentScrubTime + scrubAmount)
+            }
+
+        case .up, .down:
+            // Exit scrub mode and let navigation happen
+            commitScrub()
+
+        @unknown default:
+            break
+        }
+    }
+
+    // MARK: - Commit
+
+    private func commitScrub() {
+        seekTask?.cancel()
+        seekTask = nil
+
+        let wasScrubbing = isScrubbing
+
+        if let time = scrubTime {
+            onSeek(time)
+        }
+
+        withAnimation(.easeOut(duration: 0.15)) {
+            scrubTime = nil
+            isScrubbing = false
+        }
+        panAccumulator = 0
+
+        if wasScrubbing {
+            onScrubbingChanged?(false)
+        }
+    }
+
+    // MARK: - Formatting
+
+    private func formatTime(_ time: TimeInterval) -> String {
+        let totalSeconds = Int(max(0, time))
+        let hours = totalSeconds / 3600
+        let minutes = (totalSeconds % 3600) / 60
+        let seconds = totalSeconds % 60
+
+        if hours > 0 {
+            return String(format: "%d:%02d:%02d", hours, minutes, seconds)
+        }
+        return String(format: "%d:%02d", minutes, seconds)
+    }
+}
+
+// MARK: - Pan Gesture View
+
+/// UIKit view that captures pan gestures on the Siri Remote touchpad.
+struct TVPanGestureView: UIViewRepresentable {
+    let onPanChanged: (CGFloat, CGFloat) -> Void  // (translation, velocity)
+    let onPanEnded: () -> Void
+
+    func makeUIView(context: Context) -> TVPanGestureUIView {
+        let view = TVPanGestureUIView()
+        view.onPanChanged = onPanChanged
+        view.onPanEnded = onPanEnded
+        return view
+    }
+
+    func updateUIView(_ uiView: TVPanGestureUIView, context: Context) {
+        uiView.onPanChanged = onPanChanged
+        uiView.onPanEnded = onPanEnded
+    }
+}
+
+class TVPanGestureUIView: UIView {
+    var onPanChanged: ((CGFloat, CGFloat) -> Void)?
+    var onPanEnded: (() -> Void)?
+
+    private var panRecognizer: UIPanGestureRecognizer!
+
+    override init(frame: CGRect) {
+        super.init(frame: frame)
+        setupGesture()
+    }
+
+    required init?(coder: NSCoder) {
+        super.init(coder: coder)
+        setupGesture()
+    }
+
+    private func setupGesture() {
+        panRecognizer = UIPanGestureRecognizer(target: self, action: #selector(handlePan(_:)))
+        panRecognizer.allowedTouchTypes = [NSNumber(value: UITouch.TouchType.indirect.rawValue)]
+        addGestureRecognizer(panRecognizer)
+
+        // Make view focusable
+        isUserInteractionEnabled = true
+    }
+
+    @objc private func handlePan(_ gesture: UIPanGestureRecognizer) {
+        let translation = gesture.translation(in: self).x
+        let velocity = gesture.velocity(in: self).x
+
+        switch gesture.state {
+        case .began, .changed:
+            onPanChanged?(translation, velocity)
+        case .ended, .cancelled:
+            onPanEnded?()
+            gesture.setTranslation(.zero, in: self)
+        default:
+            break
+        }
+    }
+}
+
+// MARK: - Button Style
+
+/// Button style for the progress bar.
+struct TVProgressBarButtonStyle: ButtonStyle {
+    let isFocused: Bool
+
+    func makeBody(configuration: Configuration) -> some View {
+        configuration.label
+            .scaleEffect(configuration.isPressed ? 0.98 : 1.0)
+            .opacity(configuration.isPressed ? 0.9 : 1.0)
+    }
+}
+
+#endif