yattee/Shared/Player/VideoPlayerView.swift

509 lines
19 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-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 {
if playerSize.width > 900 && Defaults[.playerSidebar] == .whenFits {
sidebarQueue = true
} else {
sidebarQueue = false
}
}}
2022-02-27 20:31:17 +00:00
@State private var hoveringPlayer = false
@State private var fullScreenDetails = false
@State private var sidebarQueue = false
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 motionManager: CMMotionManager!
@State private var orientation = UIInterfaceOrientation.portrait
@State private var lastOrientation: UIInterfaceOrientation?
2022-02-27 20:31:17 +00:00
#elseif os(macOS)
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-05-29 20:13:21 +00:00
@State private var viewVerticalOffset = Self.hiddenOffset
#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-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
init() {
if Defaults[.playerSidebar] == .always {
sidebarQueue = true
}
}
var body: some View {
2022-06-24 23:39:29 +00:00
#if DEBUG
// TODO: remove
if #available(iOS 15.0, macOS 12.0, *) {
_ = Self._printChanges()
}
#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
}
}
.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)
}
#if os(iOS)
.onReceive(NotificationCenter.default.publisher(for: UIDevice.orientationDidChangeNotification)) { _ in
handleOrientationDidChangeNotification()
}
2022-05-29 12:29:43 +00:00
.onChange(of: player.presentingPlayer) { newValue in
if newValue {
2022-05-29 20:13:21 +00:00
viewVerticalOffset = 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-05-29 12:29:43 +00:00
} else {
2022-05-29 20:30:00 +00:00
if Defaults[.lockPortraitWhenBrowsing] {
Orientation.lockOrientation(.portrait, andRotateTo: .portrait)
} else {
Orientation.lockOrientation(.allButUpsideDown)
}
2022-05-29 12:29:43 +00:00
2022-05-29 20:30:00 +00:00
motionManager?.stopAccelerometerUpdates()
motionManager = nil
viewVerticalOffset = Self.hiddenOffset
2022-05-29 12:29:43 +00:00
}
}
2022-05-29 20:30:00 +00:00
#endif
2021-11-04 22:01:27 +00:00
}
2022-05-29 20:30:00 +00:00
#if os(iOS)
2022-05-29 20:13:21 +00:00
.offset(y: viewVerticalOffset)
.animation(.easeOut(duration: 0.3), value: viewVerticalOffset)
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
}
var content: some View {
Group {
ZStack(alignment: .bottomLeading) {
#if os(tvOS)
2022-03-27 19:22:13 +00:00
playerView
2022-02-16 20:23:11 +00:00
.ignoresSafeArea(.all, edges: .all)
2022-03-27 19:22:13 +00:00
.onMoveCommand { direction in
if direction == .left {
playerControls.resetTimer()
player.backend.seek(relative: .secondsInDefaultTimescale(-10))
}
if direction == .right {
playerControls.resetTimer()
player.backend.seek(relative: .secondsInDefaultTimescale(10))
}
if direction == .up {
playerControls.show()
playerControls.resetTimer()
}
if direction == .down {
playerControls.show()
playerControls.resetTimer()
}
}
#else
GeometryReader { geometry in
VStack(spacing: 0) {
2022-06-07 21:27:48 +00:00
if player.playingInPictureInPicture {
2022-06-24 23:39:29 +00:00
pictureInPicturePlaceholder
} else {
2022-03-27 19:22:13 +00:00
playerView
#if !os(tvOS)
2022-02-16 20:23:11 +00:00
.modifier(
VideoPlayerSizeModifier(
geometry: geometry,
aspectRatio: player.avPlayerBackend.controller?.aspectRatio,
fullScreen: player.playingFullScreen
)
2022-02-16 20:23:11 +00:00
)
2022-06-24 23:39:29 +00:00
.overlay(playerPlaceholder)
2022-03-27 19:22:13 +00:00
#endif
2021-08-22 19:13:33 +00:00
}
}
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
// hovering ? playerControls.show() : playerControls.hide()
2022-02-27 20:31:17 +00:00
}
2022-05-29 12:29:43 +00:00
#if !os(macOS)
.gesture(
2022-05-29 13:35:02 +00:00
DragGesture(coordinateSpace: .global)
.onChanged { value in
2022-06-24 23:39:29 +00:00
guard player.presentingPlayer else { return }
let drag = value.translation.height
2022-06-24 23:39:29 +00:00
guard drag > 0 else { return }
guard drag < 100 else {
player.hide()
return
}
viewVerticalOffset = drag
}
.onEnded { _ in
2022-05-29 20:13:21 +00:00
if viewVerticalOffset > 100 {
2022-05-29 13:35:02 +00:00
player.backend.setNeedsDrawing(false)
player.hide()
} else {
2022-05-29 20:13:21 +00:00
viewVerticalOffset = 0
2022-05-29 13:35:02 +00:00
player.backend.setNeedsDrawing(true)
player.show()
}
}
)
2022-05-29 12:29:43 +00:00
#else
// .onAppear(perform: {
// NSEvent.addLocalMonitorForEvents(matching: [.mouseMoved]) {
// if hoveringPlayer {
// playerControls.resetTimer()
// }
//
// return $0
// }
// })
#endif
.background(Color.black)
2022-03-27 19:22:13 +00:00
#if !os(tvOS)
if !player.playingFullScreen {
VStack(spacing: 0) {
2022-03-27 19:22:13 +00:00
#if os(iOS)
if verticalSizeClass == .regular {
VideoDetails(sidebarQueue: sidebarQueue, fullScreen: fullScreenDetails)
2022-06-24 23:39:29 +00:00
.edgesIgnoringSafeArea(.bottom)
2022-03-27 19:22:13 +00:00
}
2022-03-27 19:22:13 +00:00
#else
VideoDetails(sidebarQueue: sidebarQueue, fullScreen: fullScreenDetails)
2022-03-27 19:22:13 +00:00
#endif
}
.background(colorScheme == .dark ? Color.black : Color.white)
.modifier(VideoDetailsPaddingModifier(
geometry: geometry,
aspectRatio: player.avPlayerBackend.controller?.aspectRatio,
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
if !player.playingFullScreen {
2022-02-16 20:23:11 +00:00
#if os(iOS)
if sidebarQueue {
PlayerQueueView(sidebarQueue: true, fullScreen: fullScreenDetails)
2022-02-16 20:23:11 +00:00
.frame(maxWidth: 350)
}
#elseif os(macOS)
if Defaults[.playerSidebar] != .never {
PlayerQueueView(sidebarQueue: true, fullScreen: fullScreenDetails)
2022-02-16 20:23:11 +00:00
.frame(minWidth: 300)
}
#endif
}
2021-07-18 22:32:46 +00:00
}
2022-02-16 20:23:11 +00:00
.ignoresSafeArea(.all, edges: fullScreenLayout ? .vertical : Edge.Set())
2022-03-27 19:22:13 +00:00
#if os(iOS)
.statusBar(hidden: player.playingFullScreen)
2022-02-27 20:31:17 +00:00
.navigationBarHidden(true)
#endif
2022-02-16 20:23:11 +00:00
}
2022-03-27 19:22:13 +00:00
var playerView: some View {
ZStack(alignment: .top) {
switch player.activeBackend {
case .mpv:
player.mpvPlayerView
.overlay(GeometryReader { proxy in
Color.clear
.onAppear {
player.playerSize = proxy.size
}
.onChange(of: proxy.size) { _ in
player.playerSize = proxy.size
}
})
case .appleAVPlayer:
player.avPlayerView
2022-05-20 21:23:14 +00:00
#if os(iOS)
.onAppear {
player.pipController = .init(playerLayer: player.playerLayerView.playerLayer)
let pipDelegate = PiPDelegate()
pipDelegate.player = player
player.pipDelegate = pipDelegate
player.pipController!.delegate = pipDelegate
player.playerLayerView.playerLayer.player = player.avPlayerBackend.avPlayer
}
#endif
2022-03-27 19:22:13 +00:00
}
#if !os(tvOS)
PlayerGestures()
#endif
2022-06-07 21:27:48 +00:00
PlayerControls(player: player, thumbnails: thumbnails)
2022-03-27 19:22:13 +00:00
}
}
2022-02-16 20:23:11 +00:00
var fullScreenLayout: Bool {
2022-03-27 19:22:13 +00:00
#if os(iOS)
player.playingFullScreen || verticalSizeClass == .compact
2022-02-27 20:31:17 +00:00
#else
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: .topLeading) {
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
2022-06-24 23:39:29 +00:00
var pictureInPicturePlaceholder: some View {
HStack {
Spacer()
VStack {
Spacer()
VStack(spacing: 10) {
#if !os(tvOS)
Image(systemName: "pip")
.font(.system(size: 120))
#endif
Text("Playing in Picture in Picture")
}
Spacer()
}
.foregroundColor(.gray)
Spacer()
}
.contextMenu {
Button {
player.closePiP()
} label: {
Label("Exit Picture in Picture", systemImage: "pip.exit")
}
}
.contentShape(Rectangle())
2022-06-24 23:39:29 +00:00
.frame(width: player.playerSize.width, height: player.playerSize.height)
}
#if os(iOS)
private func configureOrientationUpdatesBasedOnAccelerometer() {
if UIDevice.current.orientation.isLandscape,
Defaults[.enterFullscreenInLandscape],
!player.playingFullScreen,
!player.playingInPictureInPicture
{
DispatchQueue.main.async {
player.enterFullScreen()
}
}
guard !Defaults[.honorSystemOrientationLock], motionManager.isNil else {
return
}
motionManager = CMMotionManager()
motionManager.accelerometerUpdateInterval = 0.2
motionManager.startAccelerometerUpdates(to: OperationQueue()) { data, _ in
guard player.presentingPlayer, !player.playingInPictureInPicture, !data.isNil else {
return
}
guard let acceleration = data?.acceleration else {
return
}
var orientation = UIInterfaceOrientation.unknown
if acceleration.x >= 0.65 {
orientation = .landscapeLeft
} else if acceleration.x <= -0.65 {
orientation = .landscapeRight
} else if acceleration.y <= -0.65 {
orientation = .portrait
} else if acceleration.y >= 0.65 {
orientation = .portraitUpsideDown
}
guard lastOrientation != orientation else {
return
}
lastOrientation = orientation
if orientation.isLandscape {
DispatchQueue.main.asyncAfter(deadline: .now() + 0.8) {
guard Defaults[.enterFullscreenInLandscape] else {
return
}
player.enterFullScreen()
let orientationLockMask = orientation == .landscapeLeft ?
UIInterfaceOrientationMask.landscapeLeft : .landscapeRight
Orientation.lockOrientation(orientationLockMask, andRotateTo: orientation)
guard Defaults[.lockOrientationInFullScreen] else {
return
}
player.lockedOrientation = orientation
}
} else {
guard abs(acceleration.z) <= 0.74,
player.lockedOrientation.isNil,
Defaults[.enterFullscreenInLandscape],
!Defaults[.lockOrientationInFullScreen]
else {
return
}
DispatchQueue.main.asyncAfter(deadline: .now() + 0.4) {
player.exitFullScreen()
}
Orientation.lockOrientation(.portrait)
}
}
}
private func handleOrientationDidChangeNotification() {
2022-05-29 20:13:21 +00:00
viewVerticalOffset = viewVerticalOffset == 0 ? 0 : Self.hiddenOffset
let newOrientation = UIApplication.shared.windows.first?.windowScene?.interfaceOrientation
if newOrientation?.isLandscape ?? false,
player.presentingPlayer,
Defaults[.lockOrientationInFullScreen],
!player.lockedOrientation.isNil
{
Orientation.lockOrientation(.landscape, andRotateTo: newOrientation)
return
}
guard player.presentingPlayer, Defaults[.enterFullscreenInLandscape], Defaults[.honorSystemOrientationLock] else {
return
}
if UIDevice.current.orientation.isLandscape {
DispatchQueue.main.async {
player.lockedOrientation = newOrientation
player.enterFullScreen()
}
} else {
DispatchQueue.main.async {
player.exitFullScreen()
}
DispatchQueue.main.asyncAfter(deadline: .now() + 0.8) {
player.exitFullScreen()
}
}
}
#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
}