1
0
mirror of https://github.com/yattee/yattee.git synced 2024-12-15 14:50:32 +05:30
yattee/Model/Player/PlayerQueue.swift

379 lines
11 KiB
Swift
Raw Normal View History

import AVKit
2021-10-25 13:55:41 +05:30
import Defaults
import Foundation
2021-10-17 04:18:58 +05:30
import Siesta
import SwiftUI
extension PlayerModel {
var currentVideo: Video? {
currentItem?.video
}
2022-12-18 17:41:06 +05:30
var videoForDisplay: Video? {
2023-04-24 16:27:31 +05:30
videoBeingOpened ?? currentVideo
2022-12-18 17:41:06 +05:30
}
2022-09-04 20:53:02 +05:30
func play(_ videos: [Video], shuffling: Bool = false) {
navigation.presentingChannelSheet = false
2022-09-04 20:53:02 +05:30
playbackMode = shuffling ? .shuffle : .queue
2022-08-13 20:16:45 +05:30
videos.forEach { enqueueVideo($0, loadDetails: false) }
2022-07-11 03:54:56 +05:30
#if os(iOS)
2022-08-26 13:55:07 +05:30
onPresentPlayer.append { [weak self] in self?.advanceToNextItem() }
2022-07-11 03:54:56 +05:30
#else
advanceToNextItem()
#endif
show()
}
func playNext(_ video: Video) {
enqueueVideo(video, play: currentItem.isNil, prepending: true)
}
func playNow(_ video: Video, at time: CMTime? = nil) {
navigation.presentingChannelSheet = false
if playingInPictureInPicture, closePiPOnNavigation {
closePiP()
}
2022-12-18 17:41:06 +05:30
videoBeingOpened = video
prepareCurrentItemForHistory()
enqueueVideo(video, play: true, atTime: time, prepending: true) { _, item in
2021-10-24 14:46:04 +05:30
self.advanceToItem(item, at: time)
}
}
func playItem(_ item: PlayerQueueItem, at time: CMTime? = nil) {
2022-07-11 03:54:56 +05:30
advancing = false
2022-08-14 22:36:22 +05:30
if !playingInPictureInPicture, !currentItem.isNil {
2022-02-17 01:53:11 +05:30
backend.closeItem()
}
comments.reset()
stream = nil
navigation.presentingChannelSheet = false
2022-12-18 04:38:30 +05:30
withAnimation {
2022-12-18 04:38:30 +05:30
aspectRatio = VideoPlayerView.defaultAspectRatio
currentItem = item
}
2021-10-24 14:46:04 +05:30
if !time.isNil {
currentItem.playbackTime = time
2021-10-24 14:46:04 +05:30
} else if currentItem.playbackTime.isNil {
currentItem.playbackTime = .zero
}
2021-12-18 01:31:05 +05:30
preservedTime = currentItem.playbackTime
DispatchQueue.main.async { [weak self] in
2022-09-28 19:57:01 +05:30
guard let self else { return }
2022-11-11 23:49:48 +05:30
guard let video = item.video else {
return
}
2022-11-11 23:49:48 +05:30
if video.isLocal {
2022-12-18 17:41:06 +05:30
self.videoBeingOpened = nil
2022-11-11 23:49:48 +05:30
self.availableStreams = video.streams
return
}
2022-08-17 02:46:35 +05:30
guard let playerInstance = self.playerInstance else { return }
let streamsInstance = video.streams.compactMap(\.instance).first
2023-05-21 03:17:14 +05:30
if video.streams.isEmpty || streamsInstance.isNil || streamsInstance!.apiURLString != playerInstance.apiURLString {
2022-12-18 17:41:06 +05:30
self.loadAvailableStreams(video) { [weak self] _ in
self?.videoBeingOpened = nil
}
} else {
2022-12-18 17:41:06 +05:30
self.videoBeingOpened = nil
2022-08-17 02:46:35 +05:30
self.availableStreams = self.streamsWithInstance(instance: playerInstance, streams: video.streams)
}
}
}
2022-08-17 02:46:35 +05:30
var playerInstance: Instance? {
2022-12-09 05:45:19 +05:30
InstancesModel.shared.forPlayer ?? accounts.current?.instance ?? InstancesModel.shared.all.first
2022-08-17 02:46:35 +05:30
}
2022-12-21 22:43:41 +05:30
func playerAPI(_ video: Video) -> VideosAPI? {
2022-12-10 05:53:13 +05:30
guard let url = video.instanceURL else { return accounts.api }
if accounts.current?.url == url { return accounts.api }
2022-12-09 05:45:19 +05:30
switch video.app {
case .local:
return nil
case .peerTube:
return PeerTubeAPI.withAnonymousAccountForInstanceURL(url)
case .invidious:
return InvidiousAPI.withAnonymousAccountForInstanceURL(url)
case .piped:
return PipedAPI.withAnonymousAccountForInstanceURL(url)
}
2022-08-17 02:46:35 +05:30
}
2022-08-14 22:36:22 +05:30
var qualityProfile: QualityProfile? {
qualityProfileSelection ?? QualityProfilesModel.shared.automaticProfile
}
var streamByQualityProfile: Stream? {
let profile = qualityProfile ?? .defaultProfile
if let streamPreferredForProfile = backend.bestPlayable(
availableStreams.filter { backend.canPlay($0) && profile.isPreferred($0) },
maxResolution: profile.resolution
) {
return streamPreferredForProfile
}
return backend.bestPlayable(availableStreams.filter { backend.canPlay($0) }, maxResolution: profile.resolution)
2021-11-04 05:10:01 +05:30
}
func advanceToNextItem() {
2022-07-11 03:54:56 +05:30
guard !advancing else {
return
}
advancing = true
prepareCurrentItemForHistory()
2022-07-11 03:54:56 +05:30
var nextItem: PlayerQueueItem?
switch playbackMode {
case .queue:
nextItem = queue.first
case .shuffle:
nextItem = queue.randomElement()
case .related:
nextItem = autoplayItem
case .loopOne:
nextItem = nil
}
resetAutoplay()
2022-09-28 19:57:01 +05:30
if let nextItem {
advanceToItem(nextItem)
2022-08-14 22:36:22 +05:30
} else {
advancing = false
}
}
2022-07-11 03:54:56 +05:30
var isAdvanceToNextItemAvailable: Bool {
switch playbackMode {
case .loopOne:
return false
case .queue, .shuffle:
return !queue.isEmpty
case .related:
2022-12-21 04:52:36 +05:30
return autoplayItem != nil
2022-07-11 03:54:56 +05:30
}
}
func advanceToItem(_ newItem: PlayerQueueItem, at time: CMTime? = nil) {
prepareCurrentItemForHistory()
remove(newItem)
navigation.presentingChannelSheet = false
currentItem = newItem
2022-07-22 02:28:32 +05:30
currentItem.playbackTime = time
2022-07-22 02:28:32 +05:30
let playTime = currentItem.shouldRestartPlaying ? CMTime.zero : time
guard let video = newItem.video else { return }
2022-12-21 22:43:41 +05:30
playerAPI(video)?.loadDetails(currentItem, failureHandler: { self.videoLoadFailureHandler($0, video: video) }) { newItem in
2022-07-22 02:28:32 +05:30
self.playItem(newItem, at: playTime)
}
}
@discardableResult func remove(_ item: PlayerQueueItem) -> PlayerQueueItem? {
2021-10-27 04:29:59 +05:30
if let index = queue.firstIndex(where: { $0.videoID == item.videoID }) {
return queue.remove(at: index)
}
return nil
}
func resetQueue() {
DispatchQueue.main.async { [weak self] in
2022-09-28 19:57:01 +05:30
guard let self else {
return
}
self.currentItem = nil
self.stream = nil
self.removeQueueItems()
}
2022-02-17 01:53:11 +05:30
backend.closeItem()
}
@discardableResult func enqueueVideo(
_ video: Video,
play: Bool = false,
atTime: CMTime? = nil,
prepending: Bool = false,
loadDetails: Bool = true,
videoDetailsLoadHandler: @escaping (Video, PlayerQueueItem) -> Void = { _, _ in }
) -> PlayerQueueItem? {
let item = PlayerQueueItem(video, playbackTime: atTime)
if play {
navigation.presentingChannelSheet = false
withAnimation {
2022-12-18 04:38:30 +05:30
aspectRatio = VideoPlayerView.defaultAspectRatio
navigation.presentingChannelSheet = false
currentItem = item
}
videoBeingOpened = video
}
if loadDetails {
2022-12-21 22:43:41 +05:30
playerAPI(item.video)?.loadDetails(item, failureHandler: { self.videoLoadFailureHandler($0, video: video) }) { [weak self] newItem in
2022-09-28 19:57:01 +05:30
guard let self else { return }
videoDetailsLoadHandler(newItem.video, newItem)
if play {
self.playItem(newItem)
} else {
self.queue.insert(newItem, at: prepending ? 0 : self.queue.endIndex)
}
}
} else {
2022-11-10 22:41:28 +05:30
videoDetailsLoadHandler(video, item)
queue.insert(item, at: prepending ? 0 : queue.endIndex)
}
return item
}
func prepareCurrentItemForHistory(finished: Bool = false) {
2022-11-10 22:41:28 +05:30
if let currentItem {
if Defaults[.saveHistory] {
if let video = currentVideo, !historyVideos.contains(where: { $0 == video }) {
historyVideos.append(video)
}
2023-06-08 01:55:10 +05:30
updateWatch(finished: finished, time: backend.currentTime)
2022-11-10 22:41:28 +05:30
}
if let video = currentItem.video,
video.isLocal,
video.localStreamIsFile,
2023-11-22 14:54:41 +05:30
let localURL = video.localStream?.localURL
{
2022-11-10 22:41:28 +05:30
logger.info("stopping security scoped resource access for \(localURL)")
localURL.stopAccessingSecurityScopedResource()
}
}
}
func playHistory(_ item: PlayerQueueItem, at time: CMTime? = nil) {
2022-06-30 03:27:42 +05:30
guard let video = item.video else { return }
var time = time ?? item.playbackTime
if item.shouldRestartPlaying {
time = .zero
}
2022-06-30 03:27:42 +05:30
let newItem = enqueueVideo(video, atTime: time, prepending: true)
2021-10-14 03:35:19 +05:30
advanceToItem(newItem!, at: time)
}
func removeQueueItems() {
queue.removeAll()
}
2022-01-09 20:35:05 +05:30
func restoreQueue() {
var restoredQueue = [PlayerQueueItem?]()
2022-09-28 19:57:01 +05:30
if let lastPlayed,
2023-11-22 14:54:41 +05:30
!Defaults[.queue].contains(where: { $0.videoID == lastPlayed.videoID })
{
restoredQueue.append(lastPlayed)
self.lastPlayed = nil
}
restoredQueue.append(contentsOf: Defaults[.queue])
queue = restoredQueue.compactMap { $0 }
queue.forEach { loadQueueVideoDetails($0) }
2022-06-26 16:42:32 +05:30
}
2022-01-09 20:35:05 +05:30
2022-06-26 16:42:32 +05:30
func loadQueueVideoDetails(_ item: PlayerQueueItem) {
guard !accounts.current.isNil, !item.hasDetailsLoaded else { return }
2022-06-26 16:42:32 +05:30
2022-11-10 22:41:28 +05:30
let videoID = item.video?.videoID ?? item.videoID
let video = item.video ?? Video(app: item.app ?? .local, instanceURL: item.instanceURL, videoID: videoID)
2022-11-10 22:41:28 +05:30
let replaceQueueItem: (PlayerQueueItem) -> Void = { newItem in
self.queue.filter { $0.videoID == videoID }.forEach { item in
2022-11-10 22:41:28 +05:30
if let index = self.queue.firstIndex(of: item) {
self.queue[index] = newItem
}
}
}
2022-11-10 22:41:28 +05:30
if let video = VideosCacheModel.shared.retrieveVideo(video.cacheKey) {
var item = item
item.id = UUID()
item.video = video
replaceQueueItem(item)
return
}
2022-11-10 22:41:28 +05:30
playerAPI(video)?
2023-06-17 17:39:51 +05:30
.loadDetails(item, failureHandler: nil) { [weak self] newItem in
guard let self else { return }
2022-11-10 22:41:28 +05:30
replaceQueueItem(newItem)
self.logger.info("LOADED queue details: \(videoID)")
2023-06-17 17:39:51 +05:30
}
2022-06-30 04:14:32 +05:30
}
private func videoLoadFailureHandler(_ error: RequestError, video: Video? = nil) {
var message = error.userMessage
if let errorDictionary = error.json.dictionaryObject,
let errorMessage = errorDictionary["message"] ?? errorDictionary["error"],
2023-11-22 14:54:41 +05:30
let errorString = errorMessage as? String
{
message += "\n"
message += errorString
}
2022-11-13 23:20:23 +05:30
var retryButton: Alert.Button?
if let video {
retryButton = Alert.Button.default(Text("Retry")) { [weak self] in
if let self {
self.enqueueVideo(video, play: true, prepending: true, loadDetails: true)
}
}
2022-11-13 23:20:23 +05:30
}
var alert: Alert
if let retryButton {
alert = Alert(
title: Text("Could not load video"),
message: Text(message),
primaryButton: .cancel { [weak self] in
guard let self else { return }
2023-05-27 02:50:45 +05:30
self.closeCurrentItem()
},
2022-11-13 23:20:23 +05:30
secondaryButton: retryButton
)
} else {
alert = Alert(title: Text("Could not load video"))
}
navigation.presentAlert(alert)
2022-01-09 20:35:05 +05:30
}
}