yattee/Shared/Player/VideoPlayerView.swift

472 lines
18 KiB
Swift
Raw Normal View History

2021-07-18 22:32:46 +00:00
import AVKit
#if os(iOS)
import CoreMotion
#endif
import Defaults
2021-07-18 22:32:46 +00:00
import Siesta
import SwiftUI
struct VideoPlayerView: View {
2022-05-29 12:29:43 +00:00
#if os(iOS)
static let hiddenOffset = YatteeApp.isForPreviews ? 0 : max(UIScreen.main.bounds.height, UIScreen.main.bounds.width) + 100
2022-08-08 18:02:46 +00:00
static let defaultSidebarQueueValue = UIScreen.main.bounds.width > 900 && Defaults[.playerSidebar] == .whenFits
#else
static let defaultSidebarQueueValue = Defaults[.playerSidebar] != .never
2022-05-29 12:29:43 +00:00
#endif
2021-11-08 16:29:35 +00:00
static let defaultAspectRatio = 16 / 9.0
2021-09-18 20:36:42 +00:00
static var defaultMinimumHeightLeft: Double {
2021-08-22 19:13:33 +00:00
#if os(macOS)
300
#else
200
#endif
}
@State private var playerSize: CGSize = .zero { didSet {
2022-08-08 18:02:46 +00:00
sidebarQueue = playerSize.width > 900 && Defaults[.playerSidebar] == .whenFits
}}
2022-02-27 20:31:17 +00:00
@State private var hoveringPlayer = false
@State private var fullScreenDetails = false
2022-08-08 18:02:46 +00:00
@State private var sidebarQueue = defaultSidebarQueueValue
2021-07-18 22:32:46 +00:00
2021-11-28 14:37:55 +00:00
@Environment(\.colorScheme) private var colorScheme
2021-08-22 19:13:33 +00:00
#if os(iOS)
@Environment(\.verticalSizeClass) private var verticalSizeClass
@State private var orientation = UIInterfaceOrientation.portrait
@State private var lastOrientation: UIInterfaceOrientation?
2022-02-27 20:31:17 +00:00
#elseif os(macOS)
2022-07-10 22:42:47 +00:00
var hoverThrottle = Throttle(interval: 0.5)
2022-02-27 20:31:17 +00:00
var mouseLocation: CGPoint { NSEvent.mouseLocation }
2021-08-22 19:13:33 +00:00
#endif
2021-08-16 22:46:18 +00:00
2022-05-29 20:30:00 +00:00
#if os(iOS)
2022-08-08 18:02:46 +00:00
@GestureState private var dragGestureState = false
@GestureState private var dragGestureOffset = CGSize.zero
@State private var viewDragOffset = 0.0
2022-07-10 11:14:07 +00:00
@State private var orientationObserver: Any?
#endif
2021-12-24 19:20:05 +00:00
@EnvironmentObject<AccountsModel> private var accounts
2022-06-24 22:48:57 +00:00
@EnvironmentObject<NavigationModel> private var navigation
@EnvironmentObject<PlayerModel> private var player
2022-06-25 16:33:35 +00:00
@EnvironmentObject<PlayerControlsModel> private var playerControls
2022-06-24 22:48:57 +00:00
@EnvironmentObject<RecentsModel> private var recents
@EnvironmentObject<SearchModel> private var search
2022-06-07 21:27:48 +00:00
@EnvironmentObject<ThumbnailsModel> private var thumbnails
2021-09-25 08:18:22 +00:00
var body: some View {
2022-06-24 23:39:29 +00:00
#if DEBUG
// TODO: remove
if #available(iOS 15.0, macOS 12.0, *) {
2022-08-08 18:02:46 +00:00
Self._printChanges()
2022-06-24 23:39:29 +00:00
}
#endif
2021-11-04 22:01:27 +00:00
#if os(macOS)
return HSplitView {
2021-11-04 22:01:27 +00:00
content
}
2022-06-24 22:48:57 +00:00
.alert(isPresented: $navigation.presentingAlertInVideoPlayer) { navigation.alert }
.onOpenURL {
OpenURLHandler(
accounts: accounts,
navigation: navigation,
recents: recents,
player: player,
search: search
).handle($0)
}
.frame(minWidth: 950, minHeight: 700)
2021-11-04 22:01:27 +00:00
#else
return GeometryReader { geometry in
2022-04-03 22:33:09 +00:00
HStack(spacing: 0) {
content
.onAppear {
playerSize = geometry.size
}
}
2022-08-06 13:27:34 +00:00
#if os(iOS)
.frame(width: playerWidth.isNil ? nil : Double(playerWidth!), height: playerHeight.isNil ? nil : Double(playerHeight!))
2022-07-09 22:29:13 +00:00
.ignoresSafeArea(.all, edges: playerEdgesIgnoringSafeArea)
2022-08-06 14:28:19 +00:00
#endif
2022-04-03 22:33:09 +00:00
.onChange(of: geometry.size) { size in
self.playerSize = size
}
2022-04-03 22:33:09 +00:00
.onChange(of: fullScreenDetails) { value in
player.backend.setNeedsDrawing(!value)
}
2022-08-08 18:02:46 +00:00
.onAppear {
#if os(iOS)
viewDragOffset = 0.0
2022-05-29 20:30:00 +00:00
configureOrientationUpdatesBasedOnAccelerometer()
DispatchQueue.main.asyncAfter(deadline: .now() + 0.5) { [weak player] in
player?.onPresentPlayer?()
player?.onPresentPlayer = nil
}
2022-07-10 23:26:35 +00:00
if let orientationMask = player.lockedOrientation {
Orientation.lockOrientation(
orientationMask,
andRotateTo: orientationMask == .landscapeLeft ? .landscapeLeft : orientationMask == .landscapeRight ? .landscapeRight : .portrait
)
}
2022-08-08 18:02:46 +00:00
#endif
}
.onDisappear {
#if os(iOS)
2022-05-29 20:30:00 +00:00
if Defaults[.lockPortraitWhenBrowsing] {
Orientation.lockOrientation(.portrait, andRotateTo: .portrait)
} else {
Orientation.lockOrientation(.allButUpsideDown)
}
2022-07-10 11:14:07 +00:00
stopOrientationUpdates()
2022-07-10 17:51:46 +00:00
player.controls.hideOverlays()
2022-08-08 18:02:46 +00:00
player.lockedOrientation = nil
#endif
2022-05-29 12:29:43 +00:00
}
2021-11-04 22:01:27 +00:00
}
2022-05-29 20:30:00 +00:00
#if os(iOS)
2022-08-08 18:02:46 +00:00
.offset(y: playerOffset)
.animation(.linear(duration: 0.2), value: playerOffset)
2022-06-21 22:18:16 +00:00
.backport
.persistentSystemOverlays(!fullScreenLayout)
2022-05-29 20:30:00 +00:00
#endif
2021-11-04 22:01:27 +00:00
#endif
2021-07-18 22:32:46 +00:00
}
2022-08-06 13:27:34 +00:00
#if os(iOS)
2022-08-08 18:02:46 +00:00
var playerOffset: Double {
dragGestureState ? dragGestureOffset.height : viewDragOffset
}
2022-08-06 13:27:34 +00:00
var playerWidth: Double? {
2022-08-07 12:11:57 +00:00
fullScreenLayout ? (UIScreen.main.bounds.size.width - SafeArea.insets.left - SafeArea.insets.right) : nil
2022-08-06 13:27:34 +00:00
}
var playerHeight: Double? {
2022-08-07 12:11:57 +00:00
fullScreenLayout ? UIScreen.main.bounds.size.height - (OrientationTracker.shared.currentInterfaceOrientation.isPortrait ? (SafeArea.insets.top + SafeArea.insets.bottom) : 0) : nil
2022-08-06 13:27:34 +00:00
}
var playerEdgesIgnoringSafeArea: Edge.Set {
2022-07-09 00:21:04 +00:00
if fullScreenLayout, UIDevice.current.orientation.isLandscape {
return [.vertical]
}
2022-08-06 13:27:34 +00:00
return []
}
#endif
2022-07-09 00:21:04 +00:00
var content: some View {
Group {
ZStack(alignment: .bottomLeading) {
#if os(tvOS)
ZStack {
2022-08-06 13:27:34 +00:00
PlayerBackendView()
2022-06-26 12:55:23 +00:00
tvControls
}
2022-08-06 14:38:43 +00:00
.ignoresSafeArea()
.onMoveCommand { direction in
if direction == .up || direction == .down {
playerControls.show()
}
2022-06-26 12:55:23 +00:00
playerControls.resetTimer()
2022-06-26 12:55:23 +00:00
guard !playerControls.presentingControls else { return }
if direction == .left {
player.backend.seek(relative: .secondsInDefaultTimescale(-10))
2022-03-27 19:22:13 +00:00
}
if direction == .right {
player.backend.seek(relative: .secondsInDefaultTimescale(10))
}
}
.onPlayPauseCommand {
player.togglePlay()
}
.onExitCommand {
if playerControls.presentingControls {
playerControls.hide()
} else {
player.hide()
2022-06-28 11:13:19 +00:00
}
}
#else
GeometryReader { geometry in
2022-08-13 14:14:38 +00:00
PlayerBackendView()
#if !os(tvOS)
.modifier(
VideoPlayerSizeModifier(
geometry: geometry,
aspectRatio: player.aspectRatio,
fullScreen: fullScreenLayout
)
)
.overlay(playerPlaceholder)
#endif
2022-02-16 20:23:11 +00:00
.frame(maxWidth: fullScreenLayout ? .infinity : nil, maxHeight: fullScreenLayout ? .infinity : nil)
2022-02-27 20:31:17 +00:00
.onHover { hovering in
hoveringPlayer = hovering
2022-06-25 16:33:35 +00:00
hovering ? playerControls.show() : playerControls.hide()
2022-02-27 20:31:17 +00:00
}
2022-07-10 17:51:46 +00:00
#if os(iOS)
2022-07-11 18:15:48 +00:00
.gesture(playerControls.presentingOverlays ? nil : playerDragGesture)
2022-08-08 18:02:46 +00:00
.onChange(of: dragGestureState) { _ in
if !dragGestureState {
onPlayerDragGestureEnded()
}
}
2022-07-10 17:51:46 +00:00
#elseif os(macOS)
2022-07-10 13:37:07 +00:00
.onAppear(perform: {
NSEvent.addLocalMonitorForEvents(matching: [.mouseMoved]) {
2022-07-10 22:42:47 +00:00
hoverThrottle.execute {
if !player.currentItem.isNil, hoveringPlayer {
playerControls.resetTimer()
}
2022-07-10 13:37:07 +00:00
}
return $0
}
})
#endif
2022-07-10 13:37:07 +00:00
.background(Color.black)
2022-03-27 19:22:13 +00:00
#if !os(tvOS)
2022-07-09 22:29:13 +00:00
if !fullScreenLayout {
2022-08-08 18:02:46 +00:00
VideoDetails(sidebarQueue: sidebarQueue, fullScreen: $fullScreenDetails)
2022-08-06 13:27:34 +00:00
#if os(iOS)
2022-08-08 18:02:46 +00:00
.ignoresSafeArea(.all, edges: .bottom)
.transition(.move(edge: .bottom))
2022-07-09 00:21:04 +00:00
#endif
2022-08-08 18:02:46 +00:00
.background(colorScheme == .dark ? Color.black : Color.white)
.modifier(VideoDetailsPaddingModifier(
playerSize: player.playerSize,
fullScreen: fullScreenDetails
))
2022-02-16 20:23:11 +00:00
}
2022-03-27 19:22:13 +00:00
#endif
2021-08-22 19:13:33 +00:00
}
#endif
}
2022-02-16 20:23:11 +00:00
.background(((colorScheme == .dark || fullScreenLayout) ? Color.black : Color.white).edgesIgnoringSafeArea(.all))
#if os(macOS)
2021-12-02 20:35:42 +00:00
.frame(minWidth: 650)
#endif
2022-07-09 22:29:13 +00:00
if !fullScreenLayout {
2022-02-16 20:23:11 +00:00
#if os(iOS)
if sidebarQueue {
2022-06-25 16:33:35 +00:00
PlayerQueueView(sidebarQueue: true, fullScreen: $fullScreenDetails)
2022-02-16 20:23:11 +00:00
.frame(maxWidth: 350)
2022-07-11 17:52:55 +00:00
.background(colorScheme == .dark ? Color.black : Color.white)
2022-08-08 18:02:46 +00:00
.transition(.move(edge: .bottom))
2022-02-16 20:23:11 +00:00
}
#elseif os(macOS)
if Defaults[.playerSidebar] != .never {
2022-06-25 16:33:35 +00:00
PlayerQueueView(sidebarQueue: true, fullScreen: $fullScreenDetails)
2022-02-16 20:23:11 +00:00
.frame(minWidth: 300)
2022-07-11 17:52:55 +00:00
.background(colorScheme == .dark ? Color.black : Color.white)
2022-02-16 20:23:11 +00:00
}
#endif
}
2021-07-18 22:32:46 +00:00
}
2022-08-13 14:18:27 +00:00
.onChange(of: fullScreenLayout) { newValue in
if !newValue { playerControls.presentingDetailsOverlay = false }
}
2022-03-27 19:22:13 +00:00
#if os(iOS)
2022-07-09 22:29:13 +00:00
.statusBar(hidden: fullScreenLayout)
2022-02-27 20:31:17 +00:00
#endif
2022-02-16 20:23:11 +00:00
}
var fullScreenLayout: Bool {
2022-08-13 14:18:27 +00:00
if player.currentItem.isNil {
return false
}
2022-03-27 19:22:13 +00:00
#if os(iOS)
2022-08-13 14:18:27 +00:00
return player.playingFullScreen || verticalSizeClass == .compact
2022-02-27 20:31:17 +00:00
#else
2022-08-13 14:18:27 +00:00
return player.playingFullScreen
2022-02-27 20:31:17 +00:00
#endif
}
2022-06-24 23:39:29 +00:00
@ViewBuilder var playerPlaceholder: some View {
2022-06-07 21:27:48 +00:00
if player.currentItem.isNil {
ZStack(alignment: .topTrailing) {
2022-06-07 21:27:48 +00:00
HStack {
Spacer()
2022-06-07 21:27:48 +00:00
VStack {
Spacer()
VStack(spacing: 10) {
#if !os(tvOS)
Image(systemName: "ticket")
.font(.system(size: 120))
#endif
}
Spacer()
}
2022-06-07 21:27:48 +00:00
.foregroundColor(.gray)
Spacer()
}
2022-06-07 21:27:48 +00:00
#if os(iOS)
Button {
player.hide()
} label: {
Image(systemName: "xmark")
.font(.system(size: 40))
}
.buttonStyle(.plain)
.padding(10)
.foregroundColor(.gray)
#endif
}
.background(Color.black)
.contentShape(Rectangle())
2022-06-24 23:39:29 +00:00
.frame(width: player.playerSize.width, height: player.playerSize.height)
2021-07-18 22:32:46 +00:00
}
}
2021-08-22 19:13:33 +00:00
#if os(iOS)
2022-08-06 13:27:34 +00:00
var playerDragGesture: some Gesture {
DragGesture(minimumDistance: 0, coordinateSpace: .global)
2022-08-08 18:02:46 +00:00
.updating($dragGestureOffset) { value, state, _ in
state = value.translation.height > 0 ? value.translation : .zero
}
.updating($dragGestureState) { _, state, _ in
state = true
}
2022-08-06 13:27:34 +00:00
.onChanged { value in
guard player.presentingPlayer,
!playerControls.presentingControlsOverlay else { return }
if player.controls.presentingControls {
player.controls.presentingControls = false
}
let drag = value.translation.height
guard drag > 0 else { return }
2022-08-08 18:02:46 +00:00
viewDragOffset = drag
2022-08-06 13:27:34 +00:00
if drag > 60,
2022-08-08 18:02:46 +00:00
player.playingFullScreen
2022-08-06 13:27:34 +00:00
{
player.exitFullScreen()
2022-08-08 18:02:46 +00:00
if Defaults[.rotateToPortraitOnExitFullScreen] {
Orientation.lockOrientation(.allButUpsideDown, andRotateTo: .portrait)
playerControls.show()
}
2022-08-06 13:27:34 +00:00
}
}
.onEnded { _ in
2022-08-08 18:02:46 +00:00
onPlayerDragGestureEnded()
}
}
private func onPlayerDragGestureEnded() {
guard player.presentingPlayer,
!playerControls.presentingControlsOverlay else { return }
if viewDragOffset > 100 {
player.hide()
DispatchQueue.main.asyncAfter(deadline: .now() + 0.4) {
player.backend.setNeedsDrawing(false)
player.exitFullScreen()
}
2022-08-09 17:28:16 +00:00
viewDragOffset = Self.hiddenOffset
2022-08-08 18:02:46 +00:00
} else {
withAnimation(.linear(duration: 0.2)) {
viewDragOffset = 0
2022-08-06 13:27:34 +00:00
}
2022-08-08 18:02:46 +00:00
player.backend.setNeedsDrawing(true)
player.show()
}
2022-08-06 13:27:34 +00:00
}
private func configureOrientationUpdatesBasedOnAccelerometer() {
2022-08-08 18:02:46 +00:00
let currentOrientation = OrientationTracker.shared.currentInterfaceOrientation
if currentOrientation.isLandscape,
Defaults[.enterFullscreenInLandscape],
!player.playingFullScreen,
!player.playingInPictureInPicture
{
DispatchQueue.main.async {
2022-08-06 13:27:34 +00:00
player.controls.presentingControls = false
player.enterFullScreen(showControls: false)
}
2022-08-08 18:02:46 +00:00
Orientation.lockOrientation(.allButUpsideDown, andRotateTo: currentOrientation)
}
2022-07-10 11:14:07 +00:00
orientationObserver = NotificationCenter.default.addObserver(
2022-07-09 22:29:13 +00:00
forName: OrientationTracker.deviceOrientationChangedNotification,
object: nil,
queue: .main
) { _ in
2022-07-10 23:26:35 +00:00
guard !Defaults[.honorSystemOrientationLock],
player.presentingPlayer,
!player.playingInPictureInPicture,
player.lockedOrientation.isNil
else {
return
}
2022-07-09 22:29:13 +00:00
let orientation = OrientationTracker.shared.currentInterfaceOrientation
guard lastOrientation != orientation else {
return
}
lastOrientation = orientation
2022-07-09 22:29:13 +00:00
DispatchQueue.main.async {
guard Defaults[.enterFullscreenInLandscape] else {
return
}
2022-07-09 22:29:13 +00:00
if orientation.isLandscape {
2022-08-06 13:27:34 +00:00
player.controls.presentingControls = false
player.enterFullScreen(showControls: false)
2022-07-09 22:29:13 +00:00
Orientation.lockOrientation(OrientationTracker.shared.currentInterfaceOrientationMask, andRotateTo: orientation)
} else {
player.exitFullScreen(showControls: false)
2022-08-06 13:27:34 +00:00
Orientation.lockOrientation(.allButUpsideDown, andRotateTo: .portrait)
}
}
}
}
2022-07-10 11:14:07 +00:00
private func stopOrientationUpdates() {
guard let observer = orientationObserver else { return }
NotificationCenter.default.removeObserver(observer)
}
#endif
#if os(tvOS)
var tvControls: some View {
TVControls(model: playerControls, player: player, thumbnails: thumbnails)
.onReceive(playerControls.reporter) { _ in
playerControls.show()
playerControls.resetTimer()
}
}
#endif
2021-08-22 19:13:33 +00:00
}
struct VideoPlayerView_Previews: PreviewProvider {
static var previews: some View {
VideoPlayerView()
.injectFixtureEnvironmentObjects()
2021-08-22 19:13:33 +00:00
}
2021-07-18 22:32:46 +00:00
}