1
0
mirror of https://github.com/yattee/yattee.git synced 2024-12-13 22:00:31 +05:30
yattee/Model/Player/PlayerModel.swift

559 lines
15 KiB
Swift
Raw Normal View History

import AVKit
import CoreData
#if os(iOS)
import CoreMotion
#endif
import Defaults
2021-06-14 23:35:02 +05:30
import Foundation
2021-06-15 22:05:21 +05:30
import Logging
2021-10-29 01:48:23 +05:30
import MediaPlayer
2021-10-17 04:18:58 +05:30
import Siesta
2021-10-23 22:19:45 +05:30
import SwiftUI
2021-10-17 04:18:58 +05:30
import SwiftyJSON
#if !os(macOS)
import UIKit
#endif
2021-06-14 23:35:02 +05:30
2021-09-25 13:48:22 +05:30
final class PlayerModel: ObservableObject {
2021-11-02 22:54:59 +05:30
static let availableRates: [Float] = [0.5, 0.67, 0.8, 1, 1.25, 1.5, 2]
2021-11-07 19:02:01 +05:30
let logger = Logger(label: "stream.yattee.app")
2021-06-15 22:05:21 +05:30
2022-02-28 02:01:17 +05:30
var avPlayerView = AppleAVPlayerView()
var playerItem: AVPlayerItem?
2021-06-16 02:51:57 +05:30
2022-02-17 01:53:11 +05:30
var mpvPlayerView = MPVPlayerView()
@Published var presentingPlayer = false { didSet { handlePresentationChange() } }
2022-02-17 01:53:11 +05:30
@Published var activeBackend = PlayerBackendType.mpv
var avPlayerBackend: AVPlayerBackend!
var mpvBackend: MPVBackend!
var backends: [PlayerBackend] {
[avPlayerBackend, mpvBackend]
}
2021-06-18 15:47:01 +05:30
2022-02-17 01:53:11 +05:30
var backend: PlayerBackend! {
switch activeBackend {
case .mpv:
return mpvBackend
case .appleAVPlayer:
return avPlayerBackend
}
}
2022-03-27 17:12:20 +05:30
@Published var playerSize: CGSize = .zero { didSet {
backend.setSize(playerSize.width, playerSize.height)
}}
@Published var stream: Stream?
2022-02-17 01:53:11 +05:30
@Published var currentRate: Float = 1.0 { didSet { backend.setRate(currentRate) } }
2021-06-15 22:05:21 +05:30
@Published var availableStreams = [Stream]() { didSet { handleAvailableStreamsChange() } }
2021-10-23 22:19:45 +05:30
@Published var streamSelection: Stream? { didSet { rebuildTVMenu() } }
2021-10-17 04:18:58 +05:30
@Published var queue = [PlayerQueueItem]() { didSet { Defaults[.queue] = queue } }
2022-01-09 20:35:05 +05:30
@Published var currentItem: PlayerQueueItem! { didSet { handleCurrentItemChange() } }
@Published var historyVideos = [Video]()
2021-06-15 22:05:21 +05:30
2021-12-18 01:31:05 +05:30
@Published var preservedTime: CMTime?
2021-06-18 04:13:29 +05:30
2021-10-23 22:19:45 +05:30
@Published var sponsorBlock = SponsorBlockAPI()
@Published var segmentRestorationTime: CMTime?
@Published var lastSkipped: Segment? { didSet { rebuildTVMenu() } }
@Published var restoredSegments = [Segment]()
2022-03-20 04:34:56 +05:30
@Published var returnYouTubeDislike = ReturnYouTubeDislikeAPI()
#if os(iOS)
@Published var motionManager: CMMotionManager!
@Published var lockedOrientation: UIInterfaceOrientation?
@Published var lastOrientation: UIInterfaceOrientation?
#endif
2021-10-17 04:18:58 +05:30
var accounts: AccountsModel
2021-12-05 01:05:41 +05:30
var comments: CommentsModel
2022-02-17 01:53:11 +05:30
var controls: PlayerControlsModel { didSet {
backends.forEach { backend in
var backend = backend
backend.controls = controls
}
}}
var context: NSManagedObjectContext = PersistenceController.shared.container.viewContext
2022-02-17 01:53:11 +05:30
@Published var playingInPictureInPicture = false
2022-05-21 02:53:14 +05:30
var pipController: AVPictureInPictureController?
var pipDelegate = PiPDelegate()
2021-10-28 22:44:55 +05:30
2021-11-07 22:22:42 +05:30
@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
#if !os(macOS)
@Default(.closePiPAndOpenPlayerOnEnteringForeground) var closePiPAndOpenPlayerOnEnteringForeground
#endif
2022-02-17 02:40:57 +05:30
private var currentArtwork: MPMediaItemArtwork?
2022-05-21 02:53:14 +05:30
#if !os(macOS)
var playerLayerView: PlayerLayerView!
#endif
2022-02-17 02:40:57 +05:30
2022-02-17 01:53:11 +05:30
init(accounts: AccountsModel? = nil, comments: CommentsModel? = nil, controls: PlayerControlsModel? = nil) {
2021-10-17 04:18:58 +05:30
self.accounts = accounts ?? AccountsModel()
2021-12-05 01:05:41 +05:30
self.comments = comments ?? CommentsModel()
2022-02-17 01:53:11 +05:30
self.controls = controls ?? PlayerControlsModel()
self.avPlayerBackend = AVPlayerBackend(model: self, controls: controls)
self.mpvBackend = MPVBackend(model: self)
2021-10-25 13:55:41 +05:30
2022-02-17 01:53:11 +05:30
self.activeBackend = Defaults[.activeBackend]
}
func show() {
#if os(macOS)
if presentingPlayer {
2022-01-06 21:05:45 +05:30
Windows.player.focus()
return
}
#endif
presentingPlayer = true
#if os(macOS)
2022-01-06 21:05:45 +05:30
Windows.player.open()
Windows.player.focus()
#endif
2021-06-16 02:51:57 +05:30
}
func hide() {
controls.playingFullscreen = false
presentingPlayer = false
#if os(iOS)
if Defaults[.lockPortraitWhenBrowsing] {
Orientation.lockOrientation(.portrait, andRotateTo: .portrait)
}
#endif
}
2021-11-09 04:44:28 +05:30
func togglePlayer() {
#if os(macOS)
if !presentingPlayer {
2022-01-06 21:05:45 +05:30
Windows.player.open()
}
2022-01-06 21:05:45 +05:30
Windows.player.focus()
#else
if presentingPlayer {
hide()
} else {
show()
}
#endif
2021-11-09 04:44:28 +05:30
}
var isLoadingVideo: Bool {
guard !currentVideo.isNil else {
return false
}
2022-02-17 01:53:11 +05:30
return backend.isLoadingVideo
}
2021-10-17 04:18:58 +05:30
var isPlaying: Bool {
2022-02-17 01:53:11 +05:30
backend.isPlaying
2021-10-17 04:18:58 +05:30
}
2022-02-17 01:53:11 +05:30
var playerItemDuration: CMTime? {
backend.playerItemDuration
}
2022-02-17 01:53:11 +05:30
var playerItemDurationWithoutSponsorSegments: CMTime? {
(backend.playerItemDuration ?? .zero) - .secondsInDefaultTimescale(
sponsorBlock.segments.reduce(0) { $0 + $1.duration }
)
2021-10-23 04:34:03 +05:30
}
2022-02-17 01:53:11 +05:30
var videoDuration: TimeInterval? {
currentItem?.duration ?? currentVideo?.length ?? playerItemDuration?.seconds
}
2022-02-17 01:53:11 +05:30
var time: CMTime? {
currentItem?.playbackTime
}
var live: Bool {
currentVideo?.live ?? false
}
func togglePlay() {
2022-02-17 01:53:11 +05:30
backend.togglePlay()
2021-06-15 22:05:21 +05:30
}
func play() {
2022-02-17 01:53:11 +05:30
backend.play()
2021-07-30 03:58:28 +05:30
}
func pause() {
2022-02-17 01:53:11 +05:30
backend.pause()
2021-09-25 13:48:22 +05:30
}
2022-05-29 20:08:37 +05:30
func play(_ video: Video, at time: CMTime? = nil, showingPlayer: Bool = true) {
2022-05-31 00:30:53 +05:30
pause()
var delay = 0.0
2022-05-31 00:30:53 +05:30
#if os(iOS)
delay = 0.5
#endif
DispatchQueue.main.asyncAfter(deadline: .now() + delay) { [weak self] in
guard let self = self else {
return
}
self.playNow(video, at: time)
}
guard !playingInPictureInPicture else {
return
}
2022-05-29 20:08:37 +05:30
if showingPlayer {
show()
}
2021-10-17 04:18:58 +05:30
}
2021-07-19 04:02:46 +05:30
func playStream(
2021-10-17 04:18:58 +05:30
_ stream: Stream,
of video: Video,
preservingTime: Bool = false,
upgrading: Bool = false
2021-10-17 04:18:58 +05:30
) {
2021-11-07 22:22:42 +05:30
playerError = nil
if !upgrading {
resetSegments()
DispatchQueue.main.async { [weak self] in
self?.sponsorBlock.loadSegments(
videoID: video.videoID,
categories: Defaults[.sponsorBlockCategories]
)
2022-03-20 04:34:56 +05:30
2022-03-21 02:01:19 +05:30
guard Defaults[.enableReturnYouTubeDislike] else {
return
}
2022-03-20 04:34:56 +05:30
self?.returnYouTubeDislike.loadDislikes(videoID: video.videoID) { [weak self] dislikes in
self?.currentItem?.video?.dislikes = dislikes
}
}
}
2021-10-23 22:19:45 +05:30
2022-02-17 01:53:11 +05:30
controls.reset()
2021-10-17 04:18:58 +05:30
2022-02-17 01:53:11 +05:30
backend.playStream(
stream,
of: video,
preservingTime: preservingTime,
upgrading: upgrading
)
2022-02-17 02:40:57 +05:30
if !upgrading {
updateCurrentArtwork()
}
2022-02-17 01:53:11 +05:30
}
func saveTime(completionHandler: @escaping () -> Void = {}) {
guard let currentTime = backend.currentTime, currentTime.seconds > 0 else {
2022-05-29 20:08:37 +05:30
completionHandler()
2022-02-17 01:53:11 +05:30
return
2021-07-19 04:02:46 +05:30
}
2021-10-29 01:48:23 +05:30
2022-02-17 01:53:11 +05:30
DispatchQueue.main.async { [weak self] in
self?.preservedTime = currentTime
completionHandler()
}
2021-07-19 04:02:46 +05:30
}
2022-02-17 01:53:11 +05:30
func upgradeToStream(_ stream: Stream, force: Bool = false) {
guard let video = currentVideo else {
return
}
2022-02-17 01:53:11 +05:30
if !self.stream.isNil, force || self.stream != stream {
playStream(stream, of: video, preservingTime: true, upgrading: true)
}
}
2021-12-19 22:26:47 +05:30
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
self?.backend.setNeedsDrawing(self?.presentingPlayer ?? false)
}
2022-02-17 01:53:11 +05:30
controls.hide()
2022-04-03 20:33:56 +05:30
#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-17 01:53:11 +05:30
if !presentingPlayer, !pauseOnHidingPlayer, backend.isPlaying {
DispatchQueue.main.asyncAfter(deadline: .now() + 1) { [weak self] in
self?.play()
2021-11-05 20:28:51 +05:30
}
}
}
2022-02-17 01:53:11 +05:30
func changeActiveBackend(from: PlayerBackendType, to: PlayerBackendType) {
2022-05-29 20:08:37 +05:30
guard activeBackend != to else {
return
}
2022-02-17 01:53:11 +05:30
Defaults[.activeBackend] = to
self.activeBackend = to
2022-02-17 01:53:11 +05:30
guard var stream = stream else {
2021-07-19 04:02:46 +05:30
return
}
2022-02-17 01:53:11 +05:30
inactiveBackends().forEach { $0.pause() }
2022-02-17 01:53:11 +05:30
let fromBackend: PlayerBackend = from == .appleAVPlayer ? avPlayerBackend : mpvBackend
let toBackend: PlayerBackend = to == .appleAVPlayer ? avPlayerBackend : mpvBackend
2022-02-17 01:53:11 +05:30
if let stream = toBackend.stream, toBackend.video == fromBackend.video {
toBackend.seek(to: fromBackend.currentTime?.seconds ?? .zero) { finished in
guard finished else {
return
}
2022-02-17 01:53:11 +05:30
toBackend.play()
}
2021-10-17 04:18:58 +05:30
2022-02-17 01:53:11 +05:30
self.stream = stream
streamSelection = stream
2021-07-22 18:13:13 +05:30
2021-10-17 04:18:58 +05:30
return
}
if !backend.canPlay(stream) || (to == .mpv && !stream.hlsURL.isNil) {
2022-02-17 01:53:11 +05:30
guard let preferredStream = preferredStream(availableStreams) else {
return
}
2022-02-17 01:53:11 +05:30
stream = preferredStream
streamSelection = preferredStream
}
2022-02-17 01:53:11 +05:30
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-29 01:48:23 +05:30
}
2022-02-17 01:53:11 +05:30
private func inactiveBackends() -> [PlayerBackend] {
[activeBackend == PlayerBackendType.mpv ? avPlayerBackend : mpvBackend]
2021-10-29 01:48:23 +05:30
}
2021-11-02 22:54:59 +05:30
func rateLabel(_ rate: Float) -> String {
let formatter = NumberFormatter()
formatter.minimumFractionDigits = 0
formatter.maximumFractionDigits = 2
return "\(formatter.string(from: NSNumber(value: rate))!)×"
}
2021-12-03 01:49:10 +05:30
2022-04-03 17:53:42 +05:30
func closeCurrentItem(finished: Bool = false) {
prepareCurrentItemForHistory(finished: finished)
2021-12-03 01:49:10 +05:30
currentItem = nil
2022-02-17 01:53:11 +05:30
backend.closeItem()
2021-12-03 01:49:10 +05:30
}
func closePiP() {
guard playingInPictureInPicture else {
return
}
let wasPlaying = isPlaying
pause()
#if os(tvOS)
show()
#endif
2022-02-17 01:53:11 +05:30
backend.closePiP(wasPlaying: wasPlaying)
}
2022-01-09 20:35:05 +05:30
func handleCurrentItemChange() {
2022-01-06 21:05:45 +05:30
#if os(macOS)
Windows.player.window?.title = windowTitle
#endif
2022-01-09 20:35:05 +05:30
Defaults[.lastPlayed] = currentItem
2022-01-06 21:05:45 +05:30
}
#if os(macOS)
var windowTitle: String {
currentVideo.isNil ? "Not playing" : "\(currentVideo!.title) - \(currentVideo!.author)"
}
#else
func handleEnterForeground() {
guard closePiPAndOpenPlayerOnEnteringForeground, playingInPictureInPicture else {
return
}
show()
closePiP()
}
func enterFullScreen() {
2022-02-17 01:53:11 +05:30
guard !controls.playingFullscreen else {
return
}
logger.info("entering fullscreen")
2022-02-17 01:53:11 +05:30
backend.enterFullScreen()
}
func exitFullScreen() {
2022-02-17 01:53:11 +05:30
guard controls.playingFullscreen else {
return
}
logger.info("exiting fullscreen")
if controls.playingFullscreen {
toggleFullscreen(true)
}
2022-02-17 01:53:11 +05:30
backend.exitFullScreen()
}
#endif
2022-02-17 02:40:57 +05:30
func updateNowPlayingInfo() {
2022-02-28 01:55:29 +05:30
guard let video = currentItem?.video else {
return
}
2022-02-17 02:40:57 +05:30
let currentTime = (backend.currentTime?.seconds.isFinite ?? false) ? backend.currentTime!.seconds : 0
var nowPlayingInfo: [String: AnyObject] = [
2022-02-28 01:55:29 +05:30
MPMediaItemPropertyTitle: video.title as AnyObject,
MPMediaItemPropertyArtist: video.author as AnyObject,
MPNowPlayingInfoPropertyIsLiveStream: video.live as AnyObject,
2022-02-17 02:40:57 +05:30
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-28 01:55:29 +05:30
if !video.live {
2022-02-17 02:40:57 +05:30
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,
let thumbnailData = try? Data(contentsOf: video.thumbnailURL(quality: .medium)!)
else {
return
}
#if os(macOS)
let image = NSImage(data: thumbnailData)
#else
let image = UIImage(data: thumbnailData)
#endif
if image.isNil {
return
}
currentArtwork = MPMediaItemArtwork(boundsSize: image!.size) { _ in image! }
}
2022-04-03 17:53:42 +05:30
func toggleFullscreen(_ isFullScreen: Bool) {
controls.resetTimer()
#if os(macOS)
Windows.player.toggleFullScreen()
#endif
controls.playingFullscreen = !isFullScreen
#if os(iOS)
if controls.playingFullscreen {
guard !(UIApplication.shared.windows.first?.windowScene?.interfaceOrientation.isLandscape ?? true) else {
return
}
Orientation.lockOrientation(.landscape, andRotateTo: .landscapeRight)
} else {
Orientation.lockOrientation(.allButUpsideDown, andRotateTo: .portrait)
}
#endif
}
2022-05-29 23:56:56 +05:30
func setNeedsDrawing(_ needsDrawing: Bool) {
backends.forEach { $0.setNeedsDrawing(needsDrawing) }
}
2021-06-14 23:35:02 +05:30
}