499 lines
21 KiB
Swift
499 lines
21 KiB
Swift
//
|
|
// VLCPlayer.swift
|
|
// JellyfinPlayer
|
|
//
|
|
// Created by Aiden Vigue on 5/10/21.
|
|
//
|
|
|
|
//me realizing i shouldve just written the whole app in the mvvm system bc it makes so much more sense
|
|
|
|
import SwiftUI
|
|
import MobileVLCKit
|
|
import SwiftyJSON
|
|
import SwiftyRequest
|
|
|
|
enum VideoType {
|
|
case hls;
|
|
case direct;
|
|
}
|
|
|
|
struct Subtitle {
|
|
var name: String;
|
|
var id: Int32;
|
|
var url: URL;
|
|
var delivery: String;
|
|
var codec: String;
|
|
}
|
|
|
|
struct AudioTrack {
|
|
var name: String;
|
|
var id: Int32;
|
|
}
|
|
|
|
class PlaybackItem: ObservableObject {
|
|
@Published var videoType: VideoType = .hls;
|
|
@Published var videoUrl: URL = URL(string: "https://example.com")!;
|
|
@Published var subtitles: [Subtitle] = [];
|
|
}
|
|
|
|
protocol PlayerViewControllerDelegate: AnyObject {
|
|
func hideLoadingView(_ viewController: PlayerViewController)
|
|
func showLoadingView(_ viewController: PlayerViewController)
|
|
func exitPlayer(_ viewController: PlayerViewController)
|
|
}
|
|
|
|
class PlayerViewController: UIViewController, VLCMediaDelegate, VLCMediaPlayerDelegate {
|
|
|
|
weak var delegate: PlayerViewControllerDelegate?
|
|
|
|
var mediaPlayer = VLCMediaPlayer()
|
|
var globalData = GlobalData()
|
|
|
|
@IBOutlet weak var timeText: UILabel!
|
|
@IBOutlet weak var videoContentView: UIView!
|
|
@IBOutlet weak var videoControlsView: UIView!
|
|
@IBOutlet weak var seekSlider: UISlider!
|
|
@IBOutlet weak var titleLabel: UILabel!
|
|
|
|
var shouldShowLoadingScreen: Bool = false;
|
|
var ssTargetValueOffset: Int = 0;
|
|
var ssStartValue: Int = 0;
|
|
|
|
var paused: Bool = true;
|
|
var lastTime: Float = 0.0;
|
|
var startTime: Int = 0;
|
|
var selectedAudioTrack: Int32 = 0;
|
|
var selectedCaptionTrack: Int32 = 0;
|
|
var playSessionId: String = "";
|
|
|
|
var subtitleTrackArray: [Subtitle] = [];
|
|
var audioTrackArray: [AudioTrack] = [];
|
|
|
|
var manifest: DetailItem = DetailItem();
|
|
var playbackItem = PlaybackItem();
|
|
|
|
@IBAction func seekSliderStart(_ sender: Any) {
|
|
print("ss start")
|
|
mediaPlayer.pause()
|
|
}
|
|
@IBAction func seekSliderValueChanged(_ sender: Any) {
|
|
print("ss mv " + String(seekSlider.value))
|
|
}
|
|
@IBAction func seekSliderEnd(_ sender: Any) {
|
|
print("ss end")
|
|
mediaPlayer.play()
|
|
}
|
|
|
|
@IBAction func exitButtonPressed(_ sender: Any) {
|
|
print("exit tap")
|
|
delegate?.exitPlayer(self)
|
|
}
|
|
|
|
@IBAction func controlViewTapped(_ sender: Any) {
|
|
print("control view tap")
|
|
videoControlsView.isHidden = !videoControlsView.isHidden
|
|
}
|
|
|
|
@IBAction func contentViewTapped(_ sender: Any) {
|
|
print("content view tap")
|
|
videoControlsView.isHidden = !videoControlsView.isHidden
|
|
}
|
|
|
|
|
|
@IBOutlet weak var mainActionButton: UIButton!
|
|
@IBAction func mainActionButtonPressed(_ sender: Any) {
|
|
print("mab press")
|
|
print(mediaPlayer.state.rawValue)
|
|
if(paused) {
|
|
mediaPlayer.play()
|
|
mainActionButton.setImage(UIImage(systemName: "pause"), for: .normal)
|
|
paused = false;
|
|
} else {
|
|
mediaPlayer.pause()
|
|
mainActionButton.setImage(UIImage(systemName: "play"), for: .normal)
|
|
paused = true;
|
|
}
|
|
}
|
|
|
|
override func viewDidLoad() {
|
|
super.viewDidLoad()
|
|
|
|
//View has loaded.
|
|
//Show loading screen
|
|
delegate?.showLoadingView(self)
|
|
|
|
//Fetch max bitrate from UserDefaults depending on current connection mode
|
|
let defaults = UserDefaults.standard
|
|
let maxBitrate = globalData.isInNetwork ? defaults.integer(forKey: "InNetworkBandwidth") : defaults.integer(forKey: "OutOfNetworkBandwidth")
|
|
|
|
//Build a device profile
|
|
let builder = DeviceProfileBuilder()
|
|
builder.setMaxBitrate(bitrate: maxBitrate)
|
|
let profile = builder.buildProfile()
|
|
|
|
let jsonEncoder = JSONEncoder()
|
|
let jsonData = try! jsonEncoder.encode(profile)
|
|
|
|
let url = (globalData.server?.baseURI ?? "") + "/Items/\(manifest.Id)/PlaybackInfo?UserId=\(globalData.user?.user_id ?? "")&StartTimeTicks=\(Int(manifest.Progress))&IsPlayback=true&AutoOpenLiveStream=true&MaxStreamingBitrate=\(profile.DeviceProfile.MaxStreamingBitrate)";
|
|
|
|
let request = RestRequest(method: .post, url: url)
|
|
|
|
request.headerParameters["X-Emby-Authorization"] = globalData.authHeader
|
|
request.contentType = "application/json"
|
|
request.acceptType = "application/json"
|
|
request.messageBody = jsonData
|
|
|
|
request.responseData() { [self] (result: Result<RestResponse<Data>, RestError>) in
|
|
switch result {
|
|
case .success(let response):
|
|
let body = response.body
|
|
do {
|
|
let json = try JSON(data: body)
|
|
playSessionId = json["PlaySessionId"].string ?? "";
|
|
if(json["MediaSources"][0]["TranscodingUrl"].string != nil) {
|
|
let streamURL: URL = URL(string: "\(globalData.server?.baseURI ?? "")\((json["MediaSources"][0]["TranscodingUrl"].string ?? ""))")!
|
|
let item = PlaybackItem()
|
|
item.videoType = .hls
|
|
item.videoUrl = streamURL
|
|
let disableSubtitleTrack = Subtitle(name: "Disabled", id: -1, url: URL(string: "https://example.com")!, delivery: "Embed", codec: "")
|
|
subtitleTrackArray.append(disableSubtitleTrack);
|
|
|
|
for (_,stream):(String, JSON) in json["MediaSources"][0]["MediaStreams"] {
|
|
if(stream["Type"].string == "Subtitle") { //ignore ripped subtitles - we don't want to extract subtitles
|
|
let deliveryUrl = URL(string: "\(globalData.server?.baseURI ?? "")\(stream["DeliveryUrl"].string ?? "")")!
|
|
let subtitle = Subtitle(name: stream["DisplayTitle"].string ?? "", id: Int32(stream["Index"].int ?? 0), url: deliveryUrl, delivery: stream["DeliveryMethod"].string ?? "", codec: stream["Codec"].string ?? "")
|
|
subtitleTrackArray.append(subtitle);
|
|
}
|
|
|
|
if(stream["Type"].string == "Audio") {
|
|
let deliveryUrl = URL(string: "https://example.com")!
|
|
let subtitle = AudioTrack(name: stream["DisplayTitle"].string ?? "", id: Int32(stream["Index"].int ?? 0))
|
|
if(stream["IsDefault"].boolValue) {
|
|
selectedAudioTrack = Int32(stream["Index"].int ?? 0);
|
|
}
|
|
audioTrackArray.append(subtitle);
|
|
}
|
|
}
|
|
|
|
if(selectedAudioTrack == -1) {
|
|
if(audioTrackArray.count > 0) {
|
|
selectedAudioTrack = audioTrackArray[0].id;
|
|
}
|
|
}
|
|
|
|
self.sendPlayReport()
|
|
item.subtitles = subtitleTrackArray
|
|
playbackItem = item;
|
|
} else {
|
|
print("Direct playing!");
|
|
let streamURL: URL = URL(string: "\(globalData.server?.baseURI ?? "")/Videos/\(manifest.Id)/stream?Static=true&mediaSourceId=\(manifest.Id)&deviceId=\(globalData.user?.device_uuid ?? "")&api_key=\(globalData.authToken)&Tag=\(json["MediaSources"][0]["ETag"])")!;
|
|
let item = PlaybackItem()
|
|
item.videoUrl = streamURL
|
|
item.videoType = .direct
|
|
|
|
let disableSubtitleTrack = Subtitle(name: "Disabled", id: -1, url: URL(string: "https://example.com")!, delivery: "Embed", codec: "")
|
|
subtitleTrackArray.append(disableSubtitleTrack);
|
|
for (_,stream):(String, JSON) in json["MediaSources"][0]["MediaStreams"] {
|
|
if(stream["Type"].string == "Subtitle") {
|
|
let deliveryUrl = URL(string: "\(globalData.server?.baseURI ?? "")\(stream["DeliveryUrl"].string ?? "")")!
|
|
let subtitle = Subtitle(name: stream["DisplayTitle"].string ?? "", id: Int32(stream["Index"].int ?? 0), url: deliveryUrl, delivery: stream["DeliveryMethod"].string ?? "", codec: stream["Codec"].string ?? "")
|
|
subtitleTrackArray.append(subtitle);
|
|
}
|
|
|
|
if(stream["Type"].string == "Audio") {
|
|
let deliveryUrl = URL(string: "https://example.com")!
|
|
let subtitle = AudioTrack(name: stream["DisplayTitle"].string ?? "", id: Int32(stream["Index"].int ?? 0))
|
|
if(stream["IsDefault"].boolValue) {
|
|
selectedAudioTrack = Int32(stream["Index"].int ?? 0);
|
|
}
|
|
audioTrackArray.append(subtitle);
|
|
}
|
|
}
|
|
|
|
if(selectedAudioTrack == -1) {
|
|
if(audioTrackArray.count > 0) {
|
|
selectedAudioTrack = audioTrackArray[0].id;
|
|
}
|
|
}
|
|
|
|
sendPlayReport()
|
|
item.subtitles = subtitleTrackArray
|
|
playbackItem = item;
|
|
}
|
|
} catch {
|
|
|
|
}
|
|
break
|
|
case .failure(let error):
|
|
debugPrint(error)
|
|
break
|
|
}
|
|
}
|
|
|
|
mediaPlayer.media = media
|
|
|
|
mediaPlayer.delegate = self
|
|
mediaPlayer.drawable = videoContentView
|
|
|
|
if(manifest.Type == "Episode") {
|
|
titleLabel.text = "\(manifest.Name) - S\(String(manifest.ParentIndexNumber ?? 0)):E\(String(manifest.IndexNumber ?? 0)) - \(manifest.SeriesName ?? "")"
|
|
} else {
|
|
titleLabel.text = manifest.Name
|
|
}
|
|
mediaPlayer.play()
|
|
}
|
|
|
|
override func viewWillAppear(_ animated: Bool) {
|
|
super.viewWillAppear(animated)
|
|
self.tabBarController?.tabBar.isHidden = true;
|
|
}
|
|
|
|
|
|
//MARK: VLCMediaPlayer Delegates
|
|
func mediaPlayerStateChanged(_ aNotification: Notification!) {
|
|
let currentState: VLCMediaPlayerState = mediaPlayer.state
|
|
switch currentState {
|
|
case .stopped :
|
|
print("Video is done playing)")
|
|
|
|
case .ended :
|
|
print("Video is done playing)")
|
|
|
|
case .playing :
|
|
print("Video is playing")
|
|
delegate?.hideLoadingView(self)
|
|
paused = false;
|
|
|
|
case .paused :
|
|
print("Video is paused)")
|
|
paused = true;
|
|
|
|
case .opening :
|
|
print("Video is opening)")
|
|
|
|
case .buffering :
|
|
print("Video is buffering)")
|
|
delegate?.showLoadingView(self)
|
|
mediaPlayer.pause()
|
|
usleep(10000)
|
|
mediaPlayer.play()
|
|
|
|
case .error :
|
|
print("Video has error)")
|
|
|
|
case .esAdded:
|
|
print("Es Added")
|
|
mainActionButton.setImage(UIImage(systemName: "pause"), for: .normal)
|
|
@unknown default:
|
|
break
|
|
}
|
|
}
|
|
|
|
func mediaPlayerTimeChanged(_ aNotification: Notification!) {
|
|
let time = mediaPlayer.position;
|
|
if(time != lastTime) {
|
|
paused = false;
|
|
delegate?.hideLoadingView(self)
|
|
} else {
|
|
paused = true;
|
|
}
|
|
lastTime = time;
|
|
}
|
|
|
|
//MARK: Jellyfin Playstate updates
|
|
func sendProgressReport(eventName: String) {
|
|
var progressBody: String = "";
|
|
progressBody = "{\"VolumeLevel\":100,\"IsMuted\":false,\"IsPaused\":\(mediaPlayer.state == .paused ? "true" : "false"),\"RepeatMode\":\"RepeatNone\",\"ShuffleMode\":\"Sorted\",\"MaxStreamingBitrate\":120000000,\"PositionTicks\":\(Int(mediaPlayer.position * Float(manifest.RuntimeTicks))),\"PlaybackStartTimeTicks\":\(startTime),\"AudioStreamIndex\":\(selectedAudioTrack),\"BufferedRanges\":[{\"start\":0,\"end\":569735888.888889}],\"PlayMethod\":\"\(playbackItem.videoType == .hls ? "Transcode" : "DirectStream")\",\"PlaySessionId\":\"\(playSessionId)\",\"PlaylistItemId\":\"playlistItem0\",\"MediaSourceId\":\"\(manifest.Id)\",\"CanSeek\":true,\"ItemId\":\"\(manifest.Id)\",\"EventName\":\"\(eventName)\"}";
|
|
|
|
print("");
|
|
print("Sending progress report")
|
|
print(progressBody)
|
|
|
|
let request = RestRequest(method: .post, url: (globalData.server?.baseURI ?? "") + "/Sessions/Playing/Progress")
|
|
request.headerParameters["X-Emby-Authorization"] = globalData.authHeader
|
|
request.contentType = "application/json"
|
|
request.acceptType = "application/json"
|
|
request.messageBody = progressBody.data(using: .ascii);
|
|
request.responseData() { (result: Result<RestResponse<Data>, RestError>) in
|
|
switch result {
|
|
case .success(let resp):
|
|
print(resp.body)
|
|
break
|
|
case .failure(let error):
|
|
debugPrint(error)
|
|
break
|
|
}
|
|
}
|
|
}
|
|
|
|
func sendStopReport() {
|
|
var progressBody: String = "";
|
|
|
|
progressBody = "{\"VolumeLevel\":100,\"IsMuted\":false,\"IsPaused\":true,\"RepeatMode\":\"RepeatNone\",\"ShuffleMode\":\"Sorted\",\"MaxStreamingBitrate\":120000000,\"PositionTicks\":\(Int(mediaPlayer.position * Float(manifest.RuntimeTicks))),\"PlaybackStartTimeTicks\":\(startTime),\"AudioStreamIndex\":\(selectedAudioTrack),\"BufferedRanges\":[{\"start\":0,\"end\":100000}],\"PlayMethod\":\"\(playbackItem.videoType == .hls ? "Transcode" : "DirectStream")\",\"PlaySessionId\":\"\(playSessionId)\",\"PlaylistItemId\":\"playlistItem0\",\"MediaSourceId\":\"\(manifest.Id)\",\"CanSeek\":true,\"ItemId\":\"\(manifest.Id)\",\"NowPlayingQueue\":[{\"Id\":\"\(manifest.Id)\",\"PlaylistItemId\":\"playlistItem0\"}]}";
|
|
|
|
print("");
|
|
print("Sending stop report")
|
|
print(progressBody)
|
|
|
|
let request = RestRequest(method: .post, url: (globalData.server?.baseURI ?? "") + "/Sessions/Playing/Stopped")
|
|
request.headerParameters["X-Emby-Authorization"] = globalData.authHeader
|
|
request.contentType = "application/json"
|
|
request.acceptType = "application/json"
|
|
request.messageBody = progressBody.data(using: .ascii);
|
|
request.responseData() { (result: Result<RestResponse<Data>, RestError>) in
|
|
switch result {
|
|
case .success(let resp):
|
|
print(resp.body)
|
|
break
|
|
case .failure(let error):
|
|
debugPrint(error)
|
|
break
|
|
}
|
|
}
|
|
}
|
|
|
|
func sendPlayReport() {
|
|
var progressBody: String = "";
|
|
startTime = Int(Date().timeIntervalSince1970) * 10000000
|
|
|
|
progressBody = "{\"VolumeLevel\":100,\"IsMuted\":false,\"IsPaused\":false,\"RepeatMode\":\"RepeatNone\",\"ShuffleMode\":\"Sorted\",\"MaxStreamingBitrate\":120000000,\"PositionTicks\":\(Int(manifest.Progress)),\"PlaybackStartTimeTicks\":\(startTime),\"AudioStreamIndex\":\(selectedAudioTrack),\"BufferedRanges\":[],\"PlayMethod\":\"\(playbackItem.videoType == .hls ? "Transcode" : "DirectStream")\",\"PlaySessionId\":\"\(playSessionId)\",\"PlaylistItemId\":\"playlistItem0\",\"MediaSourceId\":\"\(manifest.Id)\",\"CanSeek\":true,\"ItemId\":\"\(manifest.Id)\",\"NowPlayingQueue\":[{\"Id\":\"\(manifest.Id)\",\"PlaylistItemId\":\"playlistItem0\"}]}";
|
|
|
|
print("");
|
|
print("Sending play report")
|
|
print(progressBody)
|
|
|
|
let request = RestRequest(method: .post, url: (globalData.server?.baseURI ?? "") + "/Sessions/Playing")
|
|
request.headerParameters["X-Emby-Authorization"] = globalData.authHeader
|
|
request.contentType = "application/json"
|
|
request.acceptType = "application/json"
|
|
request.messageBody = progressBody.data(using: .ascii);
|
|
request.responseData() { (result: Result<RestResponse<Data>, RestError>) in
|
|
switch result {
|
|
case .success(let resp):
|
|
print(resp.body)
|
|
break
|
|
case .failure(let error):
|
|
debugPrint(error)
|
|
break
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
struct VLCPlayerWithControls: UIViewControllerRepresentable {
|
|
var item: DetailItem
|
|
@Environment(\.presentationMode) var presentationMode
|
|
@EnvironmentObject private var globalData: GlobalData;
|
|
|
|
var loadBinding: Binding<Bool>
|
|
var pBinding: Binding<Bool>
|
|
|
|
class Coordinator: NSObject, PlayerViewControllerDelegate {
|
|
let loadBinding: Binding<Bool>
|
|
let pBinding: Binding<Bool>
|
|
|
|
init(loadBinding: Binding<Bool>, pBinding: Binding<Bool>) {
|
|
self.loadBinding = loadBinding
|
|
self.pBinding = pBinding
|
|
}
|
|
|
|
func hideLoadingView(_ viewController: PlayerViewController) {
|
|
self.loadBinding.wrappedValue = false;
|
|
}
|
|
|
|
func showLoadingView(_ viewController: PlayerViewController) {
|
|
self.loadBinding.wrappedValue = true;
|
|
}
|
|
|
|
func exitPlayer(_ viewController: PlayerViewController) {
|
|
self.pBinding.wrappedValue = false;
|
|
}
|
|
}
|
|
|
|
func makeCoordinator() -> Coordinator {
|
|
Coordinator(loadBinding: self.loadBinding, pBinding: self.pBinding)
|
|
}
|
|
|
|
|
|
typealias UIViewControllerType = PlayerViewController
|
|
func makeUIViewController(context: UIViewControllerRepresentableContext<VLCPlayerWithControls>) -> VLCPlayerWithControls.UIViewControllerType {
|
|
let storyboard = UIStoryboard(name: "VideoPlayer", bundle: nil)
|
|
let customViewController = storyboard.instantiateViewController(withIdentifier: "VideoPlayer") as! PlayerViewController
|
|
customViewController.manifest = item;
|
|
customViewController.delegate = context.coordinator;
|
|
customViewController.globalData = globalData;
|
|
return customViewController
|
|
}
|
|
|
|
func updateUIViewController(_ uiViewController: VLCPlayerWithControls.UIViewControllerType, context: UIViewControllerRepresentableContext<VLCPlayerWithControls>) {
|
|
}
|
|
}
|
|
|
|
/*
|
|
struct VLCPlayer: UIViewRepresentable{
|
|
var url: Binding<PlaybackItem>;
|
|
var player: Binding<VLCMediaPlayer>;
|
|
var startTime: Int;
|
|
|
|
func updateUIView(_ uiView: PlayerUIView, context: UIViewRepresentableContext<VLCPlayer>) {
|
|
uiView.url = self.url
|
|
if(self.url.wrappedValue.videoUrl.absoluteString != "https://example.com") {
|
|
uiView.videoSetup()
|
|
}
|
|
}
|
|
|
|
func makeUIView(context: Context) -> PlayerUIView {
|
|
return PlayerUIView(frame: .zero, url: url, player: self.player, startTime: self.startTime);
|
|
}
|
|
}
|
|
|
|
class PlayerUIView: UIView, VLCMediaPlayerDelegate {
|
|
|
|
private var mediaPlayer: Binding<VLCMediaPlayer>;
|
|
var url:Binding<PlaybackItem>
|
|
var lastUrl: PlaybackItem?
|
|
var startTime: Int
|
|
|
|
init(frame: CGRect, url: Binding<PlaybackItem>, player: Binding<VLCMediaPlayer>, startTime: Int) {
|
|
self.mediaPlayer = player;
|
|
self.url = url;
|
|
self.startTime = startTime;
|
|
super.init(frame: frame)
|
|
mediaPlayer.wrappedValue.delegate = self
|
|
mediaPlayer.wrappedValue.drawable = self
|
|
}
|
|
|
|
func videoSetup() {
|
|
if(lastUrl == nil || lastUrl?.videoUrl != url.wrappedValue.videoUrl) {
|
|
lastUrl = url.wrappedValue
|
|
mediaPlayer.wrappedValue.stop()
|
|
mediaPlayer.wrappedValue.media = VLCMedia(url: url.wrappedValue.videoUrl)
|
|
self.url.wrappedValue.subtitles.forEach() { sub in
|
|
if(sub.id != -1 && sub.delivery == "External" && sub.codec != "subrip") {
|
|
mediaPlayer.wrappedValue.addPlaybackSlave(sub.url, type: .subtitle, enforce: false)
|
|
}
|
|
}
|
|
|
|
mediaPlayer.wrappedValue.perform(Selector(("setTextRendererFontSize:")), with: 14)
|
|
//mediaPlayer.wrappedValue.perform(Selector(("setTextRendererFont:")), with: "Copperplate")
|
|
|
|
DispatchQueue.global(qos: .utility).async { [weak self] in
|
|
self?.mediaPlayer.wrappedValue.play()
|
|
if(self?.startTime != 0) {
|
|
print(self?.startTime ?? "")
|
|
self?.mediaPlayer.wrappedValue.jumpForward(Int32(self!.startTime/10000000))
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
required init?(coder: NSCoder) {
|
|
fatalError("init(coder:) has not been implemented")
|
|
}
|
|
|
|
override func layoutSubviews() {
|
|
super.layoutSubviews()
|
|
}
|
|
}
|
|
*/
|