332 lines
11 KiB
Swift
332 lines
11 KiB
Swift
//
|
|
// PlayerVC.swift
|
|
// WOKA
|
|
//
|
|
// Created by MacBook Pro on 30/05/24.
|
|
|
|
|
|
import UIKit
|
|
import JWPlayerKit
|
|
import AVKit
|
|
|
|
class PlayerVC: JWPlayerViewController, JWPlayerViewControllerDelegate {
|
|
|
|
@IBOutlet weak var backButton: UIButton!
|
|
var previousScale: CGFloat = 1.0
|
|
|
|
var contentType : VideoContentType?
|
|
|
|
var config: JWPlayerConfiguration!
|
|
var dismissTapped: (() -> Void)?
|
|
var videoIndex : Int?
|
|
var isFullScreenBtn = false
|
|
|
|
override var supportedInterfaceOrientations: UIInterfaceOrientationMask {
|
|
return .allButUpsideDown
|
|
}
|
|
|
|
override var shouldAutorotate: Bool {
|
|
return true
|
|
}
|
|
|
|
override func viewDidLoad() {
|
|
super.viewDidLoad()
|
|
// rotateView(to: .pi / 2) // Example: 90 degrees rotation
|
|
//bring back button to the front
|
|
self.view.bringSubviewToFront(backButton)
|
|
// NotificationCenter.default.addObserver(self, selector: #selector(appDidEnterBackground), name: UIApplication.didEnterBackgroundNotification, object: nil)
|
|
// NotificationCenter.default.addObserver(self, selector: #selector(appWillEnterForeground), name: UIApplication.willEnterForegroundNotification, object: nil)
|
|
}
|
|
|
|
// MARK: - Notification Center Handlers
|
|
|
|
@objc func appDidEnterBackground() {
|
|
// Code to execute when the app enters the background
|
|
print("App entered background PlayerVC")
|
|
if UIApplication.topViewController() == self{
|
|
player.stop()
|
|
}
|
|
}
|
|
|
|
@objc func appWillEnterForeground() {
|
|
// Code to execute when the app enters the foreground
|
|
print("App will enter foreground PlayerVC")
|
|
if UIApplication.topViewController() == self{
|
|
player.play()
|
|
}
|
|
}
|
|
|
|
// func rotateView(to angle: CGFloat) {
|
|
// // Apply rotation to the view's transform
|
|
// view.transform = CGAffineTransform(rotationAngle: angle)
|
|
// }
|
|
|
|
@objc func applicationDidBecomeActive() {
|
|
// self.setDeviceOrientation(orientation: .landscapeRight)
|
|
}
|
|
|
|
override func viewWillAppear(_ animated: Bool) {
|
|
super.viewWillAppear(animated)
|
|
|
|
// DispatchQueue.main.async { [weak self] in
|
|
// guard let self else{return}
|
|
appDelegate.deviceOrientation = .landscapeRight
|
|
let value = UIInterfaceOrientation.landscapeRight.rawValue
|
|
UIDevice.current.setValue(value, forKey: "orientation")
|
|
player.configurePlayer(with: config)
|
|
|
|
self.delegate = self
|
|
//Disable Picture in Picture
|
|
playerView.allowsPictureInPicturePlayback = false
|
|
playerView.captionStyle = .none
|
|
// }
|
|
}
|
|
|
|
override func viewWillDisappear(_ animated: Bool) {
|
|
super.viewWillDisappear(animated)
|
|
player.stop()
|
|
}
|
|
|
|
@IBAction func backBtnTapped(_ sender: UIButton) {
|
|
handleBackAction()
|
|
}
|
|
|
|
func handleBackAction(){
|
|
self.interfaceBehavior = .hidden
|
|
self.player.stop()
|
|
if contentType == .liveStream{
|
|
self.dismissTapped?()
|
|
}
|
|
appDelegate.deviceOrientation = .portrait
|
|
updateClicks()
|
|
|
|
let value = UIInterfaceOrientation.portrait.rawValue
|
|
UIDevice.current.setValue(value, forKey: "orientation")
|
|
UIViewController.attemptRotationToDeviceOrientation()
|
|
}
|
|
|
|
func updateClicks(){
|
|
switch contentType {
|
|
case .liveStream:
|
|
PersistentStorage.shared.addLiveTVCount()
|
|
// case .webSeries:
|
|
//// PersistentStorage.shared.addOthersCount()
|
|
case .trailer:
|
|
PersistentStorage.shared.addTrailerCount()
|
|
// case .continueWatching:
|
|
// <#code#>
|
|
// case .audioBooks:
|
|
// <#code#>
|
|
// case .games:
|
|
// <#code#>
|
|
// case .songs:
|
|
// <#code#>
|
|
case nil:
|
|
break
|
|
default:
|
|
break
|
|
}
|
|
}
|
|
|
|
// MARK: - Handle Screen Transition
|
|
|
|
override func viewWillTransition(to size: CGSize, with coordinator: UIViewControllerTransitionCoordinator) {
|
|
super.viewWillTransition(to: size, with: coordinator)
|
|
|
|
coordinator.animate(alongsideTransition: nil) { _ in
|
|
self.checkOrientation()
|
|
}
|
|
}
|
|
|
|
private func checkOrientation() {
|
|
let isPortrait = UIScreen.main.bounds.size.width < UIScreen.main.bounds.size.height
|
|
if isPortrait {
|
|
print("Device is in portrait mode")
|
|
self.dismiss(animated: true)
|
|
} else {
|
|
print("Device is in landscape mode")
|
|
if isFullScreenBtn{
|
|
appDelegate.deviceOrientation = .portrait
|
|
|
|
let value = UIInterfaceOrientation.portrait.rawValue
|
|
UIDevice.current.setValue(value, forKey: "orientation")
|
|
UIViewController.attemptRotationToDeviceOrientation()
|
|
}
|
|
}
|
|
}
|
|
|
|
// MARK: - JWPlayerViewControllerDelegate
|
|
|
|
override func jwplayer(_ player: any JWPlayer, didFinishLoadingWithTime loadTime: TimeInterval) {
|
|
super.jwplayer(player, didFinishLoadingWithTime: loadTime)
|
|
print("LoadTime", loadTime)
|
|
// if let videoIndex , contentType == .webSeries, videoIndex != 0{
|
|
// player.nextUpPlaylistIndex = videoIndex
|
|
// player.next()
|
|
// self.videoIndex = nil
|
|
// }
|
|
}
|
|
|
|
override func jwplayerIsReady(_ player: JWPlayer) {
|
|
super.jwplayerIsReady(player)
|
|
switch contentType {
|
|
case .liveStream:
|
|
player.play()
|
|
case .webSeries:
|
|
break
|
|
// player.loadPlayerItemAt(index: videoIndex ?? 0)
|
|
// self.player.play(relatedContent: videoIndex ?? 0)
|
|
// self.player.loadPlayerItemAt(index: videoIndex ?? 0)
|
|
// player.play()
|
|
// if videoIndex == 0{
|
|
// player.seek(to: 0)
|
|
// }else{
|
|
// player.nextUpPlaylistIndex = videoIndex ?? 0
|
|
// player.next()
|
|
// }
|
|
case .trailer,.songs:
|
|
break
|
|
case .continueWatching,.audioBooks, .games:
|
|
player.seek(to: 0)
|
|
player.play()
|
|
case nil:
|
|
break
|
|
}
|
|
|
|
|
|
print("IsReady")
|
|
}
|
|
|
|
override func jwplayer(_ player: JWPlayer, failedWithSetupError code: UInt, message: String) {
|
|
super.jwplayer(player, failedWithSetupError: code, message: message)
|
|
print("Setup Error: \(code) - \(message)")
|
|
}
|
|
|
|
override func jwplayer(_ player: JWPlayer, failedWithError code: UInt, message: String) {
|
|
super.jwplayer(player, failedWithError: code, message: message)
|
|
|
|
print("Error: \(code) - \(message)")
|
|
DispatchQueue.main.async {
|
|
Utilities.alertWithBtnCancelCompletion(title: "Error", msgBody: message, okBtnStr: "Connect", vc: self) { [weak self] isDone in
|
|
guard let self else{
|
|
self?.handleBackAction()
|
|
return
|
|
}
|
|
if isDone{
|
|
self.player.configurePlayer(with: config)
|
|
self.player.play()
|
|
}else{
|
|
self.handleBackAction()
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
override func jwplayer(_ player: JWPlayer, encounteredWarning code: UInt, message: String) {
|
|
super.jwplayer(player, encounteredWarning: code, message: message)
|
|
//Handle the reconnecting of video here
|
|
|
|
print("Warning: \(code) - \(message)")
|
|
}
|
|
|
|
override func jwplayer(_ player: JWPlayer, encounteredAdError code: UInt, message: String) {
|
|
super.jwplayer(player, encounteredAdError: code, message: message)
|
|
print("Ad Error: \(code) - \(message)")
|
|
}
|
|
|
|
override func jwplayer(_ player: JWPlayer, encounteredAdWarning code: UInt, message: String) {
|
|
super.jwplayer(player, encounteredAdWarning: code, message: message)
|
|
print("Ad Warning: \(code) - \(message)")
|
|
}
|
|
|
|
override func jwplayer(_ player: JWPlayer, isBufferingWithReason reason: JWBufferReason) {
|
|
super.jwplayer(player, isBufferingWithReason: reason)
|
|
print("Buffering Reason:", reason)
|
|
}
|
|
|
|
//When Player is Paused
|
|
override func jwplayer(_ player: JWPlayer, didPauseWithReason reason: JWPauseReason) {
|
|
super.jwplayer(player, didPauseWithReason: reason)
|
|
if reason == .interaction{
|
|
updateClicks()
|
|
}
|
|
// Implement custom behavior
|
|
}
|
|
|
|
//When Player is Play
|
|
override func jwplayer(_ player: JWPlayer, isPlayingWithReason reason: JWPlayReason) {
|
|
super.jwplayer(player, isPlayingWithReason: reason)
|
|
if reason == .interaction{
|
|
updateClicks()
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
// MARK: - Full Screen Handling
|
|
|
|
extension PlayerVC {
|
|
|
|
func playerViewControllerWillGoFullScreen(_ controller: JWPlayerViewController) -> JWFullScreenViewController? {
|
|
print("playerViewControllerWillGoFullScreen")
|
|
self.interfaceBehavior = .hidden
|
|
self.player.stop()
|
|
controller.player.stop()
|
|
if contentType == .liveStream{
|
|
self.dismissTapped?()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func playerViewControllerDidGoFullScreen(_ controller: JWPlayerViewController) {
|
|
print("playerViewControllerDidGoFullScreen")
|
|
self.player.pause()
|
|
self.dismissFullScreen(animated: false)
|
|
self.dismiss(animated: true)
|
|
return
|
|
}
|
|
|
|
func playerViewControllerWillDismissFullScreen(_ controller: JWPlayerViewController) {
|
|
print("playerViewControllerWillDismissFullScreen")
|
|
}
|
|
|
|
func playerViewControllerDidDismissFullScreen(_ controller: JWPlayerViewController) {
|
|
print("playerViewControllerDidDismissFullScreen")
|
|
appDelegate.deviceOrientation = .portrait
|
|
updateClicks()
|
|
let value = UIInterfaceOrientation.portrait.rawValue
|
|
UIDevice.current.setValue(value, forKey: "orientation")
|
|
UIViewController.attemptRotationToDeviceOrientation()
|
|
}
|
|
}
|
|
|
|
// MARK: - JWPlayerViewController Delegate Functions
|
|
|
|
extension PlayerVC {
|
|
|
|
func playerViewController(_ controller: JWPlayerKit.JWPlayerViewController, controlBarVisibilityChanged isVisible: Bool, frame: CGRect) {
|
|
self.backButton.isHidden = !isVisible
|
|
}
|
|
|
|
func playerViewController(_ controller: JWPlayerKit.JWPlayerViewController, sizeChangedFrom oldSize: CGSize, to newSize: CGSize) {
|
|
// Handle size change if necessary
|
|
}
|
|
|
|
func playerViewController(_ controller: JWPlayerKit.JWPlayerViewController, screenTappedAt position: CGPoint) {
|
|
// Handle screen tap if necessary
|
|
}
|
|
|
|
func playerViewController(_ controller: JWPlayerKit.JWPlayerViewController, relatedMenuOpenedWithItems items: [JWPlayerKit.JWPlayerItem], withMethod method: JWPlayerKit.JWRelatedInteraction) {
|
|
print("Related items:", items)
|
|
}
|
|
|
|
func playerViewController(_ controller: JWPlayerKit.JWPlayerViewController, relatedMenuClosedWithMethod method: JWRelatedInteraction) {
|
|
print("Related menu closed")
|
|
}
|
|
|
|
func playerViewController(_ controller: JWPlayerKit.JWPlayerViewController, relatedItemBeganPlaying item: JWPlayerKit.JWPlayerItem, atIndex index: Int, withMethod method: JWPlayerKit.JWRelatedMethod) {
|
|
print("Item ", item)
|
|
}
|
|
|
|
}
|