1
0
mirror of https://github.com/yattee/yattee.git synced 2024-12-14 14:20:32 +05:30
yattee/Shared/Player/VideoPlayerView.swift

513 lines
18 KiB
Swift
Raw Normal View History

2021-07-19 04:02:46 +05:30
import AVKit
#if os(iOS)
import CoreMotion
#endif
import Defaults
2022-09-01 00:54:46 +05:30
import Repeat
2021-07-19 04:02:46 +05:30
import Siesta
import SwiftUI
struct VideoPlayerView: View {
2022-05-29 17:59:43 +05:30
#if os(iOS)
2022-08-25 22:39:55 +05:30
static let hiddenOffset = UIScreen.main.bounds.height
2022-08-08 23:32:46 +05:30
static let defaultSidebarQueueValue = UIScreen.main.bounds.width > 900 && Defaults[.playerSidebar] == .whenFits
#else
static let defaultSidebarQueueValue = Defaults[.playerSidebar] != .never
2022-05-29 17:59:43 +05:30
#endif
#if os(macOS)
static let hiddenOffset = 0.0
#endif
static let defaultAspectRatio = Constants.aspectRatio16x9
2021-09-19 02:06:42 +05:30
static var defaultMinimumHeightLeft: Double {
2021-08-23 00:43:33 +05:30
#if os(macOS)
335
2021-08-23 00:43:33 +05:30
#else
200
#endif
}
2022-11-13 23:22:15 +05:30
@State private var playerSize: CGSize = .zero { didSet { updateSidebarQueue() } }
2022-02-28 02:01:17 +05:30
@State private var hoveringPlayer = false
@State private var fullScreenDetails = false
2022-08-08 23:32:46 +05:30
@State private var sidebarQueue = defaultSidebarQueueValue
2021-07-19 04:02:46 +05:30
2021-11-28 20:07:55 +05:30
@Environment(\.colorScheme) private var colorScheme
2021-08-23 00:43:33 +05:30
#if os(iOS)
@Environment(\.verticalSizeClass) private var verticalSizeClass
@ObservedObject private var safeAreaModel = SafeAreaModel.shared
private var orientationModel = OrientationModel.shared
2022-02-28 02:01:17 +05:30
#elseif os(macOS)
2022-07-11 04:12:47 +05:30
var hoverThrottle = Throttle(interval: 0.5)
2022-02-28 02:01:17 +05:30
var mouseLocation: CGPoint { NSEvent.mouseLocation }
2021-08-23 00:43:33 +05:30
#endif
2021-08-17 04:16:18 +05:30
#if !os(tvOS)
2023-09-23 18:37:27 +05:30
@GestureState var dragGestureState = false
@GestureState var dragGestureOffset = CGSize.zero
@State var isHorizontalDrag = false // swiftlint:disable:this swiftui_state_private
@State var isVerticalDrag = false // swiftlint:disable:this swiftui_state_private
@State var viewDragOffset = Self.hiddenOffset // swiftlint:disable:this swiftui_state_private
#endif
2023-09-23 18:45:21 +05:30
@ObservedObject var player = PlayerModel.shared // swiftlint:disable:this swiftui_state_private
2022-08-29 03:51:12 +05:30
#if os(macOS)
@ObservedObject private var navigation = NavigationModel.shared
2022-11-13 04:37:23 +05:30
#endif
@Default(.horizontalPlayerGestureEnabled) var horizontalPlayerGestureEnabled
@Default(.seekGestureSpeed) var seekGestureSpeed
2022-08-29 17:37:27 +05:30
@Default(.seekGestureSensitivity) var seekGestureSensitivity
2022-11-13 23:22:15 +05:30
@Default(.playerSidebar) var playerSidebar
2022-12-19 16:38:27 +05:30
@Default(.gestureBackwardSeekDuration) private var gestureBackwardSeekDuration
@Default(.gestureForwardSeekDuration) private var gestureForwardSeekDuration
2023-09-23 18:37:27 +05:30
@Default(.avPlayerUsesSystemControls) var avPlayerUsesSystemControls
2021-09-25 13:48:22 +05:30
2023-09-23 18:45:21 +05:30
@ObservedObject var controlsOverlayModel = ControlOverlaysModel.shared // swiftlint:disable:this swiftui_state_private
2022-09-02 04:35:31 +05:30
var body: some View {
2022-08-14 22:36:22 +05:30
ZStack(alignment: overlayAlignment) {
videoPlayer
2022-08-24 02:45:00 +05:30
.zIndex(-1)
2022-08-14 22:36:22 +05:30
#if os(iOS)
2022-09-02 04:35:31 +05:30
.gesture(controlsOverlayModel.presenting ? videoPlayerCloseControlsOverlayGesture : nil)
2022-08-14 22:36:22 +05:30
#endif
overlay
2022-08-14 22:36:22 +05:30
}
2022-08-21 02:01:03 +05:30
.onAppear {
if player.musicMode {
player.backend.startControlsUpdates()
}
2022-11-13 23:22:15 +05:30
updateSidebarQueue()
}
.onChange(of: playerSidebar) { _ in
updateSidebarQueue()
2022-08-21 02:01:03 +05:30
}
2022-08-14 22:36:22 +05:30
}
var videoPlayer: some View {
2023-06-09 21:16:31 +05:30
GeometryReader { geometry in
2022-12-18 04:40:04 +05:30
HStack(spacing: 0) {
content
.onAppear {
playerSize = geometry.size
}
2021-11-05 03:31:27 +05:30
}
2023-05-21 02:19:10 +05:30
.ignoresSafeArea(.all, edges: .bottom)
2022-12-18 04:40:04 +05:30
#if os(iOS)
2023-05-21 03:48:10 +05:30
.frame(height: playerHeight.isNil ? nil : Double(playerHeight!))
#endif
.onChange(of: geometry.size) { _ in
self.playerSize = geometry.size
2022-12-18 04:40:04 +05:30
}
2023-05-21 03:48:10 +05:30
.onChange(of: fullScreenDetails) { value in
player.backend.setNeedsDrawing(!value)
}
#if os(iOS)
.onChange(of: player.presentingPlayer) { newValue in
if newValue {
viewDragOffset = 0
2022-12-19 00:09:03 +05:30
}
2023-05-21 03:48:10 +05:30
}
.onAppear {
#if os(macOS)
if player.videoForDisplay.isNil {
player.hide()
}
#endif
viewDragOffset = 0
2023-05-21 03:48:10 +05:30
Delay.by(0.2) {
orientationModel.configureOrientationUpdatesBasedOnAccelerometer()
2022-07-11 04:56:35 +05:30
2023-05-21 03:48:10 +05:30
if let orientationMask = player.lockedOrientation {
Orientation.lockOrientation(
orientationMask,
andRotateTo: orientationMask == .landscapeLeft ? .landscapeLeft : orientationMask == .landscapeRight ? .landscapeRight : .portrait
)
} else {
Orientation.lockOrientation(.allButUpsideDown)
}
}
}
.onAnimationCompleted(for: viewDragOffset) {
guard !dragGestureState else { return }
if viewDragOffset == 0 {
player.onPresentPlayer.forEach { $0() }
player.onPresentPlayer = []
} else if viewDragOffset == Self.hiddenOffset {
player.hide(animate: false)
}
2022-12-18 04:40:04 +05:30
}
2022-05-30 02:00:00 +05:30
#endif
2022-12-18 04:40:04 +05:30
}
#if os(iOS)
.onChange(of: dragGestureState) { newValue in
guard !newValue else { return }
onPlayerDragGestureEnded()
}
.offset(y: playerOffset)
.animation(dragGestureState ? .interactiveSpring(response: 0.05) : .easeOut(duration: 0.2), value: playerOffset)
.backport
.persistentSystemOverlays(!fullScreenPlayer)
2021-11-05 03:31:27 +05:30
#endif
2022-12-19 00:09:03 +05:30
#if os(macOS)
.frame(minWidth: playerSidebar != .never ? 1100 : 650, minHeight: 700)
2022-12-19 00:09:03 +05:30
#endif
2021-07-19 04:02:46 +05:30
}
2022-11-13 23:22:15 +05:30
func updateSidebarQueue() {
#if os(iOS)
sidebarQueue = playerSize.width > 900 && playerSidebar == .whenFits
#elseif os(macOS)
sidebarQueue = playerSidebar != .never
#endif
}
var overlay: some View {
VStack {
2022-09-02 04:35:31 +05:30
if controlsOverlayModel.presenting {
HStack {
HStack {
ControlsOverlay()
#if os(tvOS)
.onExitCommand {
2022-09-02 04:35:31 +05:30
withAnimation(PlayerControls.animation) {
2022-09-01 23:31:01 +05:30
player.controls.hideOverlays()
}
}
.onPlayPauseCommand {
player.togglePlay()
}
#endif
.padding()
.modifier(ControlBackgroundModifier())
.clipShape(RoundedRectangle(cornerRadius: 4))
}
#if !os(tvOS)
2022-09-11 21:55:10 +05:30
.frame(maxWidth: fullScreenPlayer ? .infinity : player.playerSize.width)
#endif
#if !os(tvOS)
2023-04-22 14:26:18 +05:30
if !fullScreenPlayer, sidebarQueue {
Spacer()
}
#endif
}
#if os(tvOS)
.clipShape(RoundedRectangle(cornerRadius: 10))
#endif
.zIndex(1)
.transition(.opacity)
}
}
}
2022-08-14 22:36:22 +05:30
var overlayWidth: Double {
guard playerSize.width.isFinite else { return 200 }
return [playerSize.width - 50, 250].min()!
}
var overlayAlignment: Alignment {
#if os(tvOS)
return .bottomTrailing
#else
return .top
#endif
}
2022-08-06 18:57:34 +05:30
#if os(iOS)
2022-08-14 22:36:22 +05:30
var videoPlayerCloseControlsOverlayGesture: some Gesture {
TapGesture().onEnded {
withAnimation(PlayerControls.animation) {
2022-09-01 23:31:01 +05:30
player.controls.hideOverlays()
2022-08-14 22:36:22 +05:30
}
}
}
2022-08-08 23:32:46 +05:30
var playerOffset: Double {
2023-05-21 17:23:23 +05:30
dragGestureState && !isHorizontalDrag ? dragGestureOffset.height : dragOffset
}
var dragOffset: Double {
if viewDragOffset.isZero || viewDragOffset == Self.hiddenOffset {
return viewDragOffset
}
return player.presentingPlayer ? 0 : Self.hiddenOffset
2022-08-08 23:32:46 +05:30
}
2022-08-06 18:57:34 +05:30
var playerHeight: Double? {
let lockedPortrait = player.lockedOrientation?.contains(.portrait) ?? false
let isPortrait = OrientationTracker.shared.currentInterfaceOrientation.isPortrait || lockedPortrait
return fullScreenPlayer ? UIScreen.main.bounds.size.height - (isPortrait ? safeAreaModel.safeArea.top + safeAreaModel.safeArea.bottom : 0) : nil
2022-08-06 18:57:34 +05:30
}
#endif
2022-07-09 05:51:04 +05:30
var content: some View {
Group {
ZStack(alignment: .bottomLeading) {
#if os(tvOS)
ZStack {
2022-08-19 04:10:46 +05:30
player.playerBackendView
2022-06-26 18:25:23 +05:30
2022-08-21 02:35:40 +05:30
if player.activeBackend == .mpv {
tvControls
}
}
2022-08-06 20:08:43 +05:30
.ignoresSafeArea()
#else
GeometryReader { geometry in
player.playerBackendView
.modifier(
VideoPlayerSizeModifier(
geometry: geometry,
aspectRatio: player.aspectRatio,
2023-05-21 02:19:10 +05:30
fullScreen: fullScreenPlayer,
detailsHiddenInFullScreen: detailsHiddenInFullScreen
)
2022-08-13 19:44:38 +05:30
)
.onHover { hovering in
hoveringPlayer = hovering
2023-06-17 17:39:51 +05:30
if hovering {
player.controls.show()
} else {
player.controls.hide()
}
}
.gesture(player.controls.presentingOverlays ? nil : playerDragGesture)
#if os(macOS)
.onAppear {
2022-12-18 04:40:04 +05:30
NSEvent.addLocalMonitorForEvents(matching: [.mouseMoved]) {
hoverThrottle.execute {
if !player.currentItem.isNil, hoveringPlayer {
player.controls.resetTimer()
}
2022-07-11 04:12:47 +05:30
}
2022-12-18 04:40:04 +05:30
return $0
}
}
#endif
.background(Color.black)
2023-05-21 02:19:10 +05:30
if !detailsHiddenInFullScreen {
2022-12-18 17:41:06 +05:30
VideoDetails(
video: player.videoForDisplay,
fullScreen: $fullScreenDetails,
sidebarQueue: $sidebarQueue
2022-12-18 17:41:06 +05:30
)
.modifier(VideoDetailsPaddingModifier(
playerSize: player.playerSize,
fullScreen: fullScreenDetails
))
.onDisappear {
if player.presentingPlayer {
player.setNeedsDrawing(true)
2022-12-18 04:40:04 +05:30
}
2022-12-18 17:41:06 +05:30
}
2023-04-22 20:19:45 +05:30
.id(player.currentVideo?.cacheKey)
2022-12-18 17:41:06 +05:30
.transition(.opacity)
2023-05-25 18:23:33 +05:30
} else {
2023-11-26 15:03:58 +05:30
VStack {}
2022-12-18 04:40:04 +05:30
}
2021-08-23 00:43:33 +05:30
}
#endif
}
2023-05-21 03:48:10 +05:30
#if os(iOS)
.background(BackgroundBlackView().edgesIgnoringSafeArea(.all))
2023-05-21 03:48:10 +05:30
#endif
2022-09-11 21:55:10 +05:30
.background(((colorScheme == .dark || fullScreenPlayer) ? Color.black : Color.white).edgesIgnoringSafeArea(.all))
#if os(macOS)
2021-12-03 02:05:42 +05:30
.frame(minWidth: 650)
#endif
2022-08-14 22:36:22 +05:30
#if os(tvOS)
.onMoveCommand { direction in
if direction == .up {
2022-09-01 23:31:01 +05:30
player.controls.show()
2022-09-02 04:35:31 +05:30
} else if direction == .down, !controlsOverlayModel.presenting, !player.controls.presentingControls {
withAnimation(PlayerControls.animation) {
2022-11-18 03:17:45 +05:30
controlsOverlayModel.hide()
2022-08-14 22:36:22 +05:30
}
}
2022-09-01 23:31:01 +05:30
player.controls.resetTimer()
2022-08-14 22:36:22 +05:30
2022-09-01 23:31:01 +05:30
guard !player.controls.presentingControls else { return }
2022-08-14 22:36:22 +05:30
if direction == .left {
2022-12-19 16:38:27 +05:30
let interval = TimeInterval(gestureBackwardSeekDuration) ?? 10
player.backend.seek(relative: .secondsInDefaultTimescale(-interval), seekType: .userInteracted)
2022-08-14 22:36:22 +05:30
}
if direction == .right {
2022-12-19 16:38:27 +05:30
let interval = TimeInterval(gestureForwardSeekDuration) ?? 10
player.backend.seek(relative: .secondsInDefaultTimescale(interval), seekType: .userInteracted)
2022-08-14 22:36:22 +05:30
}
}
.onPlayPauseCommand {
player.togglePlay()
}
.onExitCommand {
2022-09-01 23:31:01 +05:30
if player.controls.presentingOverlays {
player.controls.hideOverlays()
2022-08-14 22:36:22 +05:30
}
2022-09-01 23:31:01 +05:30
if player.controls.presentingControls {
player.controls.hide()
2022-08-14 22:36:22 +05:30
} else {
player.hide()
}
}
#endif
2023-05-21 02:19:10 +05:30
if !detailsHiddenInFullScreen {
2022-02-17 01:53:11 +05:30
#if os(iOS)
if sidebarQueue {
List {
PlayerQueueView(sidebarQueue: true)
}
#if os(macOS)
.listStyle(.inset)
#elseif os(iOS)
.listStyle(.grouped)
.backport
.scrollContentBackground(false)
#else
.listStyle(.plain)
#endif
.frame(maxWidth: 350)
2023-06-08 03:05:44 +05:30
.background((colorScheme == .dark ? Color.black : Color.white).ignoresSafeArea())
.transition(.move(edge: .bottom))
2022-02-17 01:53:11 +05:30
}
#elseif os(macOS)
if Defaults[.playerSidebar] != .never {
List {
PlayerQueueView(sidebarQueue: true)
}
2023-04-22 23:36:30 +05:30
.frame(maxWidth: 450)
.background(colorScheme == .dark ? Color.black : Color.white)
2022-02-17 01:53:11 +05:30
}
#endif
2023-05-25 18:23:33 +05:30
} else {
2023-11-26 15:03:58 +05:30
VStack {}
2022-02-17 01:53:11 +05:30
}
2021-07-19 04:02:46 +05:30
}
2022-09-11 21:55:10 +05:30
.onChange(of: fullScreenPlayer) { newValue in
2022-09-01 23:31:01 +05:30
if !newValue { player.controls.hideOverlays() }
2022-08-13 19:48:27 +05:30
}
2022-03-28 00:52:13 +05:30
#if os(iOS)
2022-09-11 21:55:10 +05:30
.statusBar(hidden: fullScreenPlayer)
2023-05-21 02:19:10 +05:30
.backport
.toolbarBackground(colorScheme == .light ? .white : .black)
.backport
.toolbarBackgroundVisibility(true)
.backport
.toolbarColorScheme(colorScheme)
2022-09-11 21:55:10 +05:30
#endif
2022-12-22 01:46:47 +05:30
#if os(macOS)
.background(
EmptyView().sheet(isPresented: $navigation.presentingPlaybackSettings) {
PlaybackSettings()
}
)
#endif
2022-09-11 21:55:10 +05:30
}
2023-05-21 02:19:10 +05:30
var detailsHiddenInFullScreen: Bool {
guard fullScreenPlayer else { return false }
if player.activeBackend == .mpv {
return true
}
2023-05-21 03:48:10 +05:30
#if os(iOS)
return !avPlayerUsesSystemControls || verticalSizeClass == .compact
#else
return !avPlayerUsesSystemControls
#endif
2023-05-21 02:19:10 +05:30
}
2022-09-11 21:55:10 +05:30
var fullScreenPlayer: Bool {
#if os(iOS)
player.playingFullScreen || verticalSizeClass == .compact
#elseif os(macOS)
player.playingFullScreen
#elseif os(tvOS)
true
2022-02-28 02:01:17 +05:30
#endif
}
2022-06-25 05:09:29 +05:30
@ViewBuilder var playerPlaceholder: some View {
2022-06-08 02:57:48 +05:30
if player.currentItem.isNil {
ZStack(alignment: .topTrailing) {
2022-06-08 02:57:48 +05:30
HStack {
Spacer()
2022-06-08 02:57:48 +05:30
VStack {
Spacer()
VStack(spacing: 10) {
#if !os(tvOS)
Image(systemName: "ticket")
.font(.system(size: 120))
#endif
}
Spacer()
}
2022-06-08 02:57:48 +05:30
.foregroundColor(.gray)
Spacer()
}
2022-06-08 02:57:48 +05:30
#if os(iOS)
Button {
2022-08-25 22:39:55 +05:30
withAnimation(.spring(response: 0.3, dampingFraction: 0, blendDuration: 0)) {
viewDragOffset = Self.hiddenOffset
}
2022-06-08 02:57:48 +05:30
} label: {
Image(systemName: "xmark")
.font(.system(size: 40))
}
2022-11-13 23:22:15 +05:30
.opacity(fullScreenPlayer ? 1 : 0)
2022-06-08 02:57:48 +05:30
.buttonStyle(.plain)
.padding(10)
.foregroundColor(.gray)
#endif
}
2022-12-18 04:40:04 +05:30
.background(colorScheme == .dark ? Color.black : .white)
2022-06-08 02:57:48 +05:30
.contentShape(Rectangle())
2022-06-25 05:09:29 +05:30
.frame(width: player.playerSize.width, height: player.playerSize.height)
2021-07-19 04:02:46 +05:30
}
}
2021-08-23 00:43:33 +05:30
#if os(tvOS)
var tvControls: some View {
TVControls()
}
#endif
2021-08-23 00:43:33 +05:30
}
struct VideoPlayerView_Previews: PreviewProvider {
static var previews: some View {
2022-12-21 03:51:37 +05:30
ZStack {
Color.red
VideoPlayerView()
}
2021-08-23 00:43:33 +05:30
}
2021-07-19 04:02:46 +05:30
}
2023-05-21 03:48:10 +05:30
#if os(iOS)
struct BackgroundBlackView: UIViewRepresentable {
func makeUIView(context _: Context) -> UIView {
let view = UIView()
DispatchQueue.main.async {
view.superview?.superview?.backgroundColor = .black
view.superview?.superview?.layer.removeAllAnimations()
}
return view
}
2023-11-26 15:03:58 +05:30
func updateUIView(_: UIView, context _: Context) {}
2023-05-21 03:48:10 +05:30
}
#endif