yattee/Model/Player/PlayerModel.swift

885 lines
26 KiB
Swift
Raw Normal View History

import AVKit
import CoreData
#if os(iOS)
import CoreMotion
#endif
import Defaults
2021-06-14 18:05:02 +00:00
import Foundation
2021-06-15 16:35:21 +00:00
import Logging
2021-10-28 20:18:23 +00:00
import MediaPlayer
2021-10-16 22:48:58 +00:00
import Siesta
2021-10-23 16:49:45 +00:00
import SwiftUI
2021-10-16 22:48:58 +00:00
import SwiftyJSON
#if !os(macOS)
import UIKit
#endif
2021-06-14 18:05:02 +00:00
2021-09-25 08:18:22 +00:00
final class PlayerModel: ObservableObject {
2022-07-10 22:24:56 +00:00
enum PlaybackMode: String, CaseIterable, Defaults.Serializable {
case queue, shuffle, loopOne, related
var systemImage: String {
switch self {
case .queue:
return "list.number"
case .shuffle:
return "shuffle"
case .loopOne:
return "repeat.1"
case .related:
return "infinity"
}
}
}
2021-11-02 17:24:59 +00:00
static let availableRates: [Float] = [0.5, 0.67, 0.8, 1, 1.25, 1.5, 2]
2021-11-07 13:32:01 +00:00
let logger = Logger(label: "stream.yattee.app")
2021-06-15 16:35:21 +00:00
2022-02-27 20:31:17 +00:00
var avPlayerView = AppleAVPlayerView()
var playerItem: AVPlayerItem?
2021-06-15 21:21:57 +00:00
2022-02-16 20:23:11 +00:00
var mpvPlayerView = MPVPlayerView()
2022-08-08 18:02:46 +00:00
@Published var presentingPlayer = true { didSet { handlePresentationChange() } }
2022-02-16 20:23:11 +00:00
@Published var activeBackend = PlayerBackendType.mpv
var avPlayerBackend: AVPlayerBackend!
var mpvBackend: MPVBackend!
var backends: [PlayerBackend] {
[avPlayerBackend, mpvBackend]
}
2021-06-18 10:17:01 +00:00
2022-02-16 20:23:11 +00:00
var backend: PlayerBackend! {
switch activeBackend {
case .mpv:
return mpvBackend
case .appleAVPlayer:
return avPlayerBackend
}
}
2022-03-27 11:42:20 +00:00
@Published var playerSize: CGSize = .zero { didSet {
backend.setSize(playerSize.width, playerSize.height)
}}
2022-07-10 01:15:15 +00:00
@Published var aspectRatio = VideoPlayerView.defaultAspectRatio
@Published var stream: Stream?
2022-02-16 20:23:11 +00:00
@Published var currentRate: Float = 1.0 { didSet { backend.setRate(currentRate) } }
2021-06-15 16:35:21 +00:00
@Published var availableStreams = [Stream]() { didSet { handleAvailableStreamsChange() } }
2021-10-23 16:49:45 +00:00
@Published var streamSelection: Stream? { didSet { rebuildTVMenu() } }
2021-10-16 22:48:58 +00:00
2022-06-26 14:46:29 +00:00
@Published var queue = [PlayerQueueItem]() { didSet { handleQueueChange() } }
2022-01-09 15:05:05 +00:00
@Published var currentItem: PlayerQueueItem! { didSet { handleCurrentItemChange() } }
@Published var videoBeingOpened: Video?
@Published var historyVideos = [Video]()
2021-06-15 16:35:21 +00:00
2021-12-17 20:01:05 +00:00
@Published var preservedTime: CMTime?
2021-06-17 22:43:29 +00:00
2021-10-23 16:49:45 +00:00
@Published var sponsorBlock = SponsorBlockAPI()
@Published var segmentRestorationTime: CMTime?
@Published var lastSkipped: Segment? { didSet { rebuildTVMenu() } }
@Published var restoredSegments = [Segment]()
2022-06-07 21:27:48 +00:00
@Published var musicMode = false
@Published var playbackMode = PlaybackMode.queue { didSet { handlePlaybackModeChange() } }
2022-07-10 22:24:56 +00:00
@Published var autoplayItem: PlayerQueueItem?
@Published var autoplayItemSource: Video?
@Published var advancing = false
2022-03-19 23:04:56 +00:00
@Published var returnYouTubeDislike = ReturnYouTubeDislikeAPI()
@Published var isSeeking = false { didSet {
2022-06-24 23:39:29 +00:00
backend.setNeedsNetworkStateUpdates(true)
}}
2022-07-10 23:26:35 +00:00
#if os(iOS)
@Published var lockedOrientation: UIInterfaceOrientationMask?
@Default(.rotateToPortraitOnExitFullScreen) private var rotateToPortraitOnExitFullScreen
2022-07-10 23:26:35 +00:00
#endif
2021-10-16 22:48:58 +00:00
var accounts: AccountsModel
2021-12-04 19:35:41 +00:00
var comments: CommentsModel
2022-02-16 20:23:11 +00:00
var controls: PlayerControlsModel { didSet {
backends.forEach { backend in
var backend = backend
backend.controls = controls
backend.controls.player = self
2022-02-16 20:23:11 +00:00
}
}}
var playerTime: PlayerTimeModel { didSet {
backends.forEach { backend in
var backend = backend
backend.playerTime = playerTime
backend.playerTime.player = self
}
}}
var networkState: NetworkStateModel { didSet {
backends.forEach { backend in
var backend = backend
backend.networkState = networkState
backend.networkState.player = self
}
}}
2022-06-29 22:44:32 +00:00
var navigation: NavigationModel
var context: NSManagedObjectContext = PersistenceController.shared.container.viewContext
var backgroundContext = PersistenceController.shared.container.newBackgroundContext()
2022-07-10 17:51:46 +00:00
#if os(tvOS)
static let fullScreenIsDefault = true
#else
static let fullScreenIsDefault = false
#endif
@Published var playingFullScreen = PlayerModel.fullScreenIsDefault
2022-02-16 20:23:11 +00:00
@Published var playingInPictureInPicture = false
2022-05-20 21:23:14 +00:00
var pipController: AVPictureInPictureController?
var pipDelegate = PiPDelegate()
2021-10-28 17:14:55 +00:00
2021-11-07 16:52:42 +00:00
@Published var presentingErrorDetails = false
var playerError: Error? { didSet {
#if !os(tvOS)
if !playerError.isNil {
presentingErrorDetails = true
}
#endif
}}
@Default(.pauseOnHidingPlayer) private var pauseOnHidingPlayer
@Default(.closePiPOnNavigation) var closePiPOnNavigation
@Default(.closePiPOnOpeningPlayer) var closePiPOnOpeningPlayer
2022-08-08 18:02:46 +00:00
@Default(.resetWatchedStatusOnPlaying) var resetWatchedStatusOnPlaying
#if !os(macOS)
@Default(.closePiPAndOpenPlayerOnEnteringForeground) var closePiPAndOpenPlayerOnEnteringForeground
@Default(.closePlayerOnItemClose) private var closePlayerOnItemClose
#endif
2022-02-16 21:10:57 +00:00
private var currentArtwork: MPMediaItemArtwork?
2022-05-20 21:23:14 +00:00
#if !os(macOS)
var playerLayerView: PlayerLayerView!
#endif
2022-02-16 21:10:57 +00:00
var onPresentPlayer: (() -> Void)?
private var remoteCommandCenterConfigured = false
2022-02-16 20:23:11 +00:00
init(
accounts: AccountsModel = AccountsModel(),
comments: CommentsModel = CommentsModel(),
controls: PlayerControlsModel = PlayerControlsModel(),
2022-06-29 22:44:32 +00:00
navigation: NavigationModel = NavigationModel(),
playerTime: PlayerTimeModel = PlayerTimeModel(),
networkState: NetworkStateModel = NetworkStateModel()
) {
self.accounts = accounts
self.comments = comments
self.controls = controls
2022-06-29 22:44:32 +00:00
self.navigation = navigation
self.playerTime = playerTime
self.networkState = networkState
self.avPlayerBackend = AVPlayerBackend(
model: self,
controls: controls,
playerTime: playerTime
)
self.mpvBackend = MPVBackend(
model: self,
playerTime: playerTime,
networkState: networkState
)
2021-10-25 08:25:41 +00:00
2022-06-07 21:27:48 +00:00
Defaults[.activeBackend] = .mpv
2022-07-10 22:24:56 +00:00
playbackMode = Defaults[.playbackMode]
}
func show() {
#if os(macOS)
if presentingPlayer {
2022-01-06 15:35:45 +00:00
Windows.player.focus()
return
}
#endif
2022-08-09 19:14:05 +00:00
navigation.hideKeyboard()
2022-06-26 15:23:56 +00:00
DispatchQueue.main.async { [weak self] in
2022-08-08 18:02:46 +00:00
withAnimation(.linear(duration: 0.25)) {
2022-07-09 00:21:04 +00:00
self?.presentingPlayer = true
}
2022-06-26 15:23:56 +00:00
}
#if os(macOS)
2022-01-06 15:35:45 +00:00
Windows.player.open()
Windows.player.focus()
#endif
2021-06-15 21:21:57 +00:00
}
func hide() {
2022-08-08 18:02:46 +00:00
withAnimation(.linear(duration: 0.25)) {
presentingPlayer = false
}
2022-06-26 15:23:56 +00:00
DispatchQueue.main.async { [weak self] in
self?.playingFullScreen = false
}
#if os(iOS)
if Defaults[.lockPortraitWhenBrowsing] {
Orientation.lockOrientation(.portrait, andRotateTo: .portrait)
} else {
Orientation.lockOrientation(.allButUpsideDown)
}
#endif
}
2021-11-08 23:14:28 +00:00
func togglePlayer() {
#if os(macOS)
if !presentingPlayer {
2022-01-06 15:35:45 +00:00
Windows.player.open()
}
2022-01-06 15:35:45 +00:00
Windows.player.focus()
#else
if presentingPlayer {
hide()
} else {
show()
}
#endif
2021-11-08 23:14:28 +00:00
}
var isLoadingVideo: Bool {
guard !currentVideo.isNil else {
return false
}
2022-02-16 20:23:11 +00:00
return backend.isLoadingVideo
}
2021-10-16 22:48:58 +00:00
var isPlaying: Bool {
2022-02-16 20:23:11 +00:00
backend.isPlaying
2021-10-16 22:48:58 +00:00
}
2022-02-16 20:23:11 +00:00
var playerItemDuration: CMTime? {
guard !currentItem.isNil else {
return nil
}
return backend.playerItemDuration
}
2022-02-16 20:23:11 +00:00
var playerItemDurationWithoutSponsorSegments: CMTime? {
guard let playerItemDuration = playerItemDuration, !playerItemDuration.seconds.isZero else {
return nil
}
return playerItemDuration - .secondsInDefaultTimescale(
2022-02-16 20:23:11 +00:00
sponsorBlock.segments.reduce(0) { $0 + $1.duration }
)
2021-10-22 23:04:03 +00:00
}
2022-02-16 20:23:11 +00:00
var videoDuration: TimeInterval? {
2022-07-21 22:44:21 +00:00
playerItemDuration?.seconds ?? currentItem?.duration ?? currentVideo?.length
}
2022-02-16 20:23:11 +00:00
var time: CMTime? {
currentItem?.playbackTime
}
var live: Bool {
currentVideo?.live ?? false
}
2022-07-21 22:44:21 +00:00
var playingLive: Bool {
guard live,
let videoDuration = videoDuration,
let time = backend.currentTime?.seconds else { return false }
return videoDuration - time < 30
}
var liveStreamInAVPlayer: Bool {
live && activeBackend == .appleAVPlayer
}
func togglePlay() {
2022-02-16 20:23:11 +00:00
backend.togglePlay()
2021-06-15 16:35:21 +00:00
}
func play() {
2022-02-16 20:23:11 +00:00
backend.play()
2021-07-29 22:28:28 +00:00
}
func pause() {
2022-02-16 20:23:11 +00:00
backend.pause()
2021-09-25 08:18:22 +00:00
}
2022-05-29 14:38:37 +00:00
func play(_ video: Video, at time: CMTime? = nil, showingPlayer: Bool = true) {
2022-05-30 19:00:53 +00:00
pause()
#if os(iOS)
if !playingInPictureInPicture, showingPlayer {
onPresentPlayer = { [weak self] in self?.playNow(video, at: time) }
show()
return
}
#endif
playNow(video, at: time)
guard !playingInPictureInPicture else {
return
}
2022-05-29 14:38:37 +00:00
if showingPlayer {
show()
}
2021-10-16 22:48:58 +00:00
}
2021-07-18 22:32:46 +00:00
func playStream(
2021-10-16 22:48:58 +00:00
_ stream: Stream,
of video: Video,
preservingTime: Bool = false,
upgrading: Bool = false
2021-10-16 22:48:58 +00:00
) {
2021-11-07 16:52:42 +00:00
playerError = nil
if !upgrading {
resetSegments()
DispatchQueue.main.async { [weak self] in
self?.sponsorBlock.loadSegments(
videoID: video.videoID,
categories: Defaults[.sponsorBlockCategories]
)
2022-03-19 23:04:56 +00:00
2022-03-20 20:31:19 +00:00
guard Defaults[.enableReturnYouTubeDislike] else {
return
}
2022-03-19 23:04:56 +00:00
self?.returnYouTubeDislike.loadDislikes(videoID: video.videoID) { [weak self] dislikes in
self?.currentItem?.video?.dislikes = dislikes
}
}
}
2021-10-23 16:49:45 +00:00
playerTime.reset()
2021-10-16 22:48:58 +00:00
2022-02-16 20:23:11 +00:00
backend.playStream(
stream,
of: video,
preservingTime: preservingTime,
upgrading: upgrading
)
2022-02-16 21:10:57 +00:00
if !upgrading {
updateCurrentArtwork()
}
2022-02-16 20:23:11 +00:00
}
func saveTime(completionHandler: @escaping () -> Void = {}) {
guard let currentTime = backend.currentTime, currentTime.seconds > 0 else {
2022-05-29 14:38:37 +00:00
completionHandler()
2022-02-16 20:23:11 +00:00
return
2021-07-18 22:32:46 +00:00
}
2021-10-28 20:18:23 +00:00
2022-02-16 20:23:11 +00:00
DispatchQueue.main.async { [weak self] in
self?.preservedTime = currentTime
completionHandler()
}
2021-07-18 22:32:46 +00:00
}
2022-02-16 20:23:11 +00:00
func upgradeToStream(_ stream: Stream, force: Bool = false) {
guard let video = currentVideo else {
return
}
2022-02-16 20:23:11 +00:00
if !self.stream.isNil, force || self.stream != stream {
playStream(stream, of: video, preservingTime: true, upgrading: true)
}
}
2021-12-19 16:56:47 +00:00
private func handleAvailableStreamsChange() {
rebuildTVMenu()
guard stream.isNil else {
return
}
guard let stream = preferredStream(availableStreams) else {
return
}
streamSelection = stream
playStream(
stream,
of: currentVideo!,
preservingTime: !currentItem.playbackTime.isNil
)
}
private func handlePresentationChange() {
var delay = 0.0
#if os(iOS)
if presentingPlayer {
delay = 0.2
}
#endif
DispatchQueue.main.asyncAfter(deadline: .now() + delay) { [weak self] in
guard let self = self else { return }
self.backend.setNeedsDrawing(self.presentingPlayer)
#if os(tvOS)
if self.presentingPlayer {
self.controls.show()
}
#endif
}
2022-02-16 20:23:11 +00:00
controls.hide()
2022-04-03 15:03:56 +00:00
#if !os(macOS)
UIApplication.shared.isIdleTimerDisabled = presentingPlayer
#endif
if presentingPlayer, closePiPOnOpeningPlayer, playingInPictureInPicture {
DispatchQueue.main.asyncAfter(deadline: .now() + 0.5) { [weak self] in
self?.closePiP()
}
}
if !presentingPlayer, pauseOnHidingPlayer, !playingInPictureInPicture {
DispatchQueue.main.asyncAfter(deadline: .now() + 0.5) { [weak self] in
self?.pause()
}
}
2022-02-16 20:23:11 +00:00
if !presentingPlayer, !pauseOnHidingPlayer, backend.isPlaying {
DispatchQueue.main.asyncAfter(deadline: .now() + 1) { [weak self] in
self?.play()
2021-11-05 14:58:51 +00:00
}
}
}
2022-02-16 20:23:11 +00:00
func changeActiveBackend(from: PlayerBackendType, to: PlayerBackendType) {
2022-05-29 14:38:37 +00:00
guard activeBackend != to else {
return
}
2022-02-16 20:23:11 +00:00
Defaults[.activeBackend] = to
self.activeBackend = to
2022-02-16 20:23:11 +00:00
guard var stream = stream else {
2021-07-18 22:32:46 +00:00
return
}
2022-06-07 21:27:48 +00:00
if to == .mpv {
addVideoTrackFromStream()
} else {
musicMode = false
}
2022-02-16 20:23:11 +00:00
inactiveBackends().forEach { $0.pause() }
2022-02-16 20:23:11 +00:00
let fromBackend: PlayerBackend = from == .appleAVPlayer ? avPlayerBackend : mpvBackend
let toBackend: PlayerBackend = to == .appleAVPlayer ? avPlayerBackend : mpvBackend
2022-02-16 20:23:11 +00:00
if let stream = toBackend.stream, toBackend.video == fromBackend.video {
toBackend.seek(to: fromBackend.currentTime?.seconds ?? .zero) { finished in
guard finished else {
return
}
2022-02-16 20:23:11 +00:00
toBackend.play()
}
2021-10-16 22:48:58 +00:00
2022-02-16 20:23:11 +00:00
self.stream = stream
streamSelection = stream
2021-07-22 12:43:13 +00:00
2021-10-16 22:48:58 +00:00
return
}
if !backend.canPlay(stream) || (to == .mpv && !stream.hlsURL.isNil) {
2022-02-16 20:23:11 +00:00
guard let preferredStream = preferredStream(availableStreams) else {
return
}
2022-02-16 20:23:11 +00:00
stream = preferredStream
streamSelection = preferredStream
}
2022-02-16 20:23:11 +00:00
DispatchQueue.main.asyncAfter(deadline: .now() + 0.5) { [weak self] in
guard let self = self else {
return
}
self.upgradeToStream(stream, force: true)
self.setNeedsDrawing(self.presentingPlayer)
}
2021-10-28 20:18:23 +00:00
}
2022-02-16 20:23:11 +00:00
private func inactiveBackends() -> [PlayerBackend] {
[activeBackend == PlayerBackendType.mpv ? avPlayerBackend : mpvBackend]
2021-10-28 20:18:23 +00:00
}
2021-11-02 17:24:59 +00:00
func rateLabel(_ rate: Float) -> String {
let formatter = NumberFormatter()
formatter.minimumFractionDigits = 0
formatter.maximumFractionDigits = 2
return "\(formatter.string(from: NSNumber(value: rate))!)×"
}
2021-12-02 20:19:10 +00:00
2022-04-03 12:23:42 +00:00
func closeCurrentItem(finished: Bool = false) {
pause()
2022-04-03 12:23:42 +00:00
prepareCurrentItemForHistory(finished: finished)
2021-12-02 20:19:10 +00:00
currentItem = nil
2022-02-16 20:23:11 +00:00
backend.closeItem()
2022-07-10 01:15:15 +00:00
aspectRatio = VideoPlayerView.defaultAspectRatio
2022-07-10 22:24:56 +00:00
resetAutoplay()
closePiP()
exitFullScreen()
#if !os(macOS)
if closePlayerOnItemClose {
DispatchQueue.main.asyncAfter(deadline: .now() + 0.3) { [weak self] in self?.hide() }
}
#endif
2021-12-02 20:19:10 +00:00
}
func closePiP() {
guard playingInPictureInPicture else {
return
}
let wasPlaying = isPlaying
pause()
#if os(tvOS)
show()
#endif
2022-02-16 20:23:11 +00:00
backend.closePiP(wasPlaying: wasPlaying)
2022-06-26 14:46:29 +00:00
}
func handleQueueChange() {
Defaults[.queue] = queue
updateRemoteCommandCenter()
2022-06-26 14:46:29 +00:00
controls.objectWillChange.send()
}
2022-01-09 15:05:05 +00:00
func handleCurrentItemChange() {
2022-01-06 15:35:45 +00:00
#if os(macOS)
Windows.player.window?.title = windowTitle
#endif
2022-01-09 15:05:05 +00:00
2022-06-29 22:12:37 +00:00
DispatchQueue.main.async(qos: .background) { [weak self] in
2022-07-10 22:24:56 +00:00
guard let self = self else { return }
Defaults[.lastPlayed] = self.currentItem
if self.playbackMode == .related,
let video = self.currentVideo,
self.autoplayItemSource.isNil || self.autoplayItemSource?.videoID != video.videoID
{
self.setRelatedAutoplayItem()
}
2022-06-29 22:12:37 +00:00
}
2022-01-06 15:35:45 +00:00
}
2022-07-10 22:24:56 +00:00
func handlePlaybackModeChange() {
Defaults[.playbackMode] = playbackMode
updateRemoteCommandCenter()
2022-07-10 22:24:56 +00:00
guard playbackMode == .related else {
autoplayItem = nil
return
}
setRelatedAutoplayItem()
}
func setRelatedAutoplayItem() {
2022-07-11 17:44:49 +00:00
guard let video = currentVideo else { return }
let related = video.related.filter { $0.videoID != autoplayItem?.video?.videoID }
2022-07-10 22:24:56 +00:00
2022-07-11 17:44:49 +00:00
let watchFetchRequest = Watch.fetchRequest()
watchFetchRequest.predicate = NSPredicate(format: "videoID IN %@", related.map(\.videoID) as [String])
2022-07-10 22:24:56 +00:00
2022-07-11 17:44:49 +00:00
let results = try? context.fetch(watchFetchRequest)
context.perform { [weak self] in
guard let self = self,
let results = results else { return }
let resultsIds = results.map(\.videoID)
guard let autoplayVideo = related.filter({ !resultsIds.contains($0.videoID) }).randomElement() else {
return
}
let item = PlayerQueueItem(autoplayVideo)
self.autoplayItem = item
self.autoplayItemSource = video
DispatchQueue.main.asyncAfter(deadline: .now() + 3) { [weak self] in
guard let self = self else { return }
self.accounts.api.loadDetails(item, completionHandler: { newItem in
guard newItem.videoID == self.autoplayItem?.videoID else { return }
self.autoplayItem = newItem
self.updateRemoteCommandCenter()
self.controls.objectWillChange.send()
})
}
2022-07-10 22:24:56 +00:00
}
}
func updateRemoteCommandCenter() {
let skipForwardCommand = MPRemoteCommandCenter.shared().skipForwardCommand
let skipBackwardCommand = MPRemoteCommandCenter.shared().skipBackwardCommand
let previousTrackCommand = MPRemoteCommandCenter.shared().previousTrackCommand
let nextTrackCommand = MPRemoteCommandCenter.shared().nextTrackCommand
if !remoteCommandCenterConfigured {
remoteCommandCenterConfigured = true
#if !os(macOS)
try? AVAudioSession.sharedInstance().setCategory(
.playback,
mode: .moviePlayback
)
UIApplication.shared.beginReceivingRemoteControlEvents()
#endif
let preferredIntervals = [NSNumber(10)]
skipForwardCommand.preferredIntervals = preferredIntervals
skipBackwardCommand.preferredIntervals = preferredIntervals
skipForwardCommand.addTarget { [weak self] _ in
self?.backend.seek(relative: .secondsInDefaultTimescale(10))
return .success
}
skipBackwardCommand.addTarget { [weak self] _ in
self?.backend.seek(relative: .secondsInDefaultTimescale(-10))
return .success
}
previousTrackCommand.addTarget { [weak self] _ in
self?.backend.seek(to: .zero)
return .success
}
nextTrackCommand.addTarget { [weak self] _ in
self?.advanceToNextItem()
return .success
}
MPRemoteCommandCenter.shared().playCommand.addTarget { [weak self] _ in
self?.play()
return .success
}
MPRemoteCommandCenter.shared().pauseCommand.addTarget { [weak self] _ in
self?.pause()
return .success
}
MPRemoteCommandCenter.shared().togglePlayPauseCommand.addTarget { [weak self] _ in
self?.togglePlay()
return .success
}
MPRemoteCommandCenter.shared().changePlaybackPositionCommand.addTarget { [weak self] remoteEvent in
guard let event = remoteEvent as? MPChangePlaybackPositionCommandEvent else { return .commandFailed }
self?.backend.seek(to: event.positionTime)
return .success
}
}
switch Defaults[.systemControlsCommands] {
case .seek:
previousTrackCommand.isEnabled = false
nextTrackCommand.isEnabled = false
skipForwardCommand.isEnabled = true
skipBackwardCommand.isEnabled = true
case .restartAndAdvanceToNext:
skipForwardCommand.isEnabled = false
skipBackwardCommand.isEnabled = false
previousTrackCommand.isEnabled = true
nextTrackCommand.isEnabled = isAdvanceToNextItemAvailable
}
}
2022-07-10 22:24:56 +00:00
func resetAutoplay() {
autoplayItem = nil
autoplayItemSource = nil
}
#if os(macOS)
var windowTitle: String {
currentVideo.isNil ? "Not playing" : "\(currentVideo!.title) - \(currentVideo!.author)"
}
#else
func handleEnterForeground() {
setNeedsDrawing(presentingPlayer)
2022-06-05 17:12:00 +00:00
guard closePiPAndOpenPlayerOnEnteringForeground, playingInPictureInPicture else {
return
}
show()
closePiP()
}
2022-06-05 17:12:00 +00:00
func handleEnterBackground() {
setNeedsDrawing(false)
if Defaults[.pauseOnEnteringBackground], !playingInPictureInPicture, !musicMode {
pause()
}
2022-06-05 17:12:00 +00:00
}
2022-08-08 18:02:46 +00:00
#endif
2022-06-05 17:12:00 +00:00
2022-08-08 18:02:46 +00:00
func enterFullScreen(showControls: Bool = true) {
guard !playingFullScreen else { return }
2022-08-08 18:02:46 +00:00
logger.info("entering fullscreen")
toggleFullscreen(false, showControls: showControls)
}
2022-08-08 18:02:46 +00:00
func exitFullScreen(showControls: Bool = true) {
guard playingFullScreen else { return }
2022-08-08 18:02:46 +00:00
logger.info("exiting fullscreen")
toggleFullscreen(true, showControls: showControls)
}
2022-02-16 21:10:57 +00:00
func updateNowPlayingInfo() {
2022-02-27 20:25:29 +00:00
guard let video = currentItem?.video else {
return
}
2022-02-16 21:10:57 +00:00
let currentTime = (backend.currentTime?.seconds.isFinite ?? false) ? backend.currentTime!.seconds : 0
var nowPlayingInfo: [String: AnyObject] = [
2022-02-27 20:25:29 +00:00
MPMediaItemPropertyTitle: video.title as AnyObject,
MPMediaItemPropertyArtist: video.author as AnyObject,
2022-07-21 22:44:21 +00:00
MPNowPlayingInfoPropertyIsLiveStream: live as AnyObject,
2022-02-16 21:10:57 +00:00
MPNowPlayingInfoPropertyElapsedPlaybackTime: currentTime as AnyObject,
MPNowPlayingInfoPropertyPlaybackQueueCount: queue.count as AnyObject,
MPNowPlayingInfoPropertyPlaybackQueueIndex: 1 as AnyObject,
MPMediaItemPropertyMediaType: MPMediaType.anyVideo.rawValue as AnyObject
]
if !currentArtwork.isNil {
nowPlayingInfo[MPMediaItemPropertyArtwork] = currentArtwork as AnyObject
}
2022-02-27 20:25:29 +00:00
if !video.live {
2022-02-16 21:10:57 +00:00
let itemDuration = (backend.playerItemDuration ?? .zero).seconds
let duration = itemDuration.isFinite ? Double(itemDuration) : nil
if !duration.isNil {
nowPlayingInfo[MPMediaItemPropertyPlaybackDuration] = duration as AnyObject
}
}
MPNowPlayingInfoCenter.default().nowPlayingInfo = nowPlayingInfo
}
func updateCurrentArtwork() {
guard let video = currentVideo,
2022-06-26 21:28:03 +00:00
let thumbnailURL = video.thumbnailURL(quality: .medium)
2022-02-16 21:10:57 +00:00
else {
return
}
2022-06-26 21:28:03 +00:00
let task = URLSession.shared.dataTask(with: thumbnailURL) { [weak self] thumbnailData, _, _ in
guard let thumbnailData = thumbnailData else {
return
}
2022-02-16 21:10:57 +00:00
2022-06-26 21:28:03 +00:00
#if os(macOS)
guard let image = NSImage(data: thumbnailData) else { return }
#else
guard let image = UIImage(data: thumbnailData) else { return }
#endif
self?.currentArtwork = MPMediaItemArtwork(boundsSize: image.size) { _ in image }
2022-02-16 21:10:57 +00:00
}
2022-06-26 21:28:03 +00:00
task.resume()
2022-02-16 21:10:57 +00:00
}
2022-04-03 12:23:42 +00:00
func toggleFullscreen(_ isFullScreen: Bool, showControls: Bool = true) {
controls.presentingControls = showControls && isFullScreen
2022-04-03 12:23:42 +00:00
#if os(macOS)
2022-08-08 18:02:46 +00:00
Windows.player.toggleFullScreen()
2022-06-16 17:44:39 +00:00
#endif
2022-08-08 18:02:46 +00:00
playingFullScreen = !isFullScreen
2022-07-09 00:21:04 +00:00
#if os(iOS)
if !playingFullScreen {
let rotationOrientation = rotateToPortraitOnExitFullScreen ? UIInterfaceOrientation.portrait : nil
Orientation.lockOrientation(.allButUpsideDown, andRotateTo: rotationOrientation)
2022-04-03 12:23:42 +00:00
}
#endif
}
2022-05-29 18:26:56 +00:00
func setNeedsDrawing(_ needsDrawing: Bool) {
backends.forEach { $0.setNeedsDrawing(needsDrawing) }
}
2022-06-07 21:27:48 +00:00
func toggleMusicMode() {
musicMode.toggle()
if musicMode {
if playingInPictureInPicture {
avPlayerBackend.pause()
avPlayerBackend.switchToMPVOnPipClose = false
closePiP()
}
changeActiveBackend(from: .appleAVPlayer, to: .mpv)
controls.presentingControls = true
controls.removeTimer()
mpvBackend.setVideoToNo()
} else {
addVideoTrackFromStream()
mpvBackend.setVideoToAuto()
controls.resetTimer()
}
}
func addVideoTrackFromStream() {
if let videoTrackURL = stream?.videoAsset?.url,
mpvBackend.tracks < 2
{
logger.info("adding video track")
mpvBackend.addVideoTrack(videoTrackURL)
}
mpvBackend.setVideoToAuto()
}
func updateAspectRatio() {
guard aspectRatio != backend.aspectRatio else { return }
DispatchQueue.main.async { [weak self] in
guard let self = self else { return }
self.aspectRatio = self.backend.aspectRatio
}
}
2021-06-14 18:05:02 +00:00
}