mirror of
https://github.com/streamyfin/streamyfin.git
synced 2026-01-15 15:48:05 +00:00
725 lines
25 KiB
Swift
725 lines
25 KiB
Swift
import ExpoModulesCore
|
|
import MediaPlayer
|
|
import AVFoundation
|
|
|
|
#if os(tvOS)
|
|
import TVVLCKit
|
|
#else
|
|
import MobileVLCKit
|
|
#endif
|
|
|
|
class VlcPlayerView: ExpoView {
|
|
private var mediaPlayer: VLCMediaPlayer?
|
|
private var videoView: UIView?
|
|
private var progressUpdateInterval: TimeInterval = 1.0 // Update interval set to 1 second
|
|
private var isPaused: Bool = false
|
|
private var currentGeometryCString: [CChar]?
|
|
private var lastReportedState: VLCMediaPlayerState?
|
|
private var lastReportedIsPlaying: Bool?
|
|
private var customSubtitles: [(internalName: String, originalName: String)] = []
|
|
private var startPosition: Int32 = 0
|
|
private var externalSubtitles: [[String: String]]?
|
|
private var externalTrack: [String: String]?
|
|
private var progressTimer: DispatchSourceTimer?
|
|
private var isStopping: Bool = false // Define isStopping here
|
|
private var lastProgressCall = Date().timeIntervalSince1970
|
|
var hasSource = false
|
|
var isTranscoding = false
|
|
private var initialSeekPerformed: Bool = false
|
|
private var nowPlayingMetadata: [String: String]?
|
|
private var artworkImage: UIImage?
|
|
private var artworkDownloadTask: URLSessionDataTask?
|
|
|
|
// MARK: - Initialization
|
|
|
|
required init(appContext: AppContext? = nil) {
|
|
super.init(appContext: appContext)
|
|
setupView()
|
|
setupNotifications()
|
|
setupRemoteCommandCenter()
|
|
setupAudioSession()
|
|
}
|
|
|
|
// MARK: - Setup
|
|
|
|
private func setupView() {
|
|
DispatchQueue.main.async {
|
|
self.backgroundColor = .black
|
|
self.videoView = UIView()
|
|
self.videoView?.translatesAutoresizingMaskIntoConstraints = false
|
|
|
|
if let videoView = self.videoView {
|
|
self.addSubview(videoView)
|
|
NSLayoutConstraint.activate([
|
|
videoView.leadingAnchor.constraint(equalTo: self.leadingAnchor),
|
|
videoView.trailingAnchor.constraint(equalTo: self.trailingAnchor),
|
|
videoView.topAnchor.constraint(equalTo: self.topAnchor),
|
|
videoView.bottomAnchor.constraint(equalTo: self.bottomAnchor),
|
|
])
|
|
}
|
|
}
|
|
}
|
|
|
|
private func setupNotifications() {
|
|
NotificationCenter.default.addObserver(
|
|
self, selector: #selector(applicationWillResignActive),
|
|
name: UIApplication.willResignActiveNotification, object: nil)
|
|
NotificationCenter.default.addObserver(
|
|
self, selector: #selector(applicationDidBecomeActive),
|
|
name: UIApplication.didBecomeActiveNotification, object: nil)
|
|
|
|
#if !os(tvOS)
|
|
// Handle audio session interruptions (e.g., incoming calls, other apps playing audio)
|
|
NotificationCenter.default.addObserver(
|
|
self, selector: #selector(handleAudioSessionInterruption),
|
|
name: AVAudioSession.interruptionNotification, object: nil)
|
|
#endif
|
|
}
|
|
|
|
private func setupAudioSession() {
|
|
#if !os(tvOS)
|
|
do {
|
|
let audioSession = AVAudioSession.sharedInstance()
|
|
try audioSession.setCategory(.playback, mode: .moviePlayback, options: [])
|
|
try audioSession.setActive(true)
|
|
print("Audio session configured for media controls")
|
|
} catch {
|
|
print("Failed to setup audio session: \(error)")
|
|
}
|
|
#endif
|
|
}
|
|
|
|
private func setupRemoteCommandCenter() {
|
|
#if !os(tvOS)
|
|
let commandCenter = MPRemoteCommandCenter.shared()
|
|
|
|
// Play command
|
|
commandCenter.playCommand.isEnabled = true
|
|
commandCenter.playCommand.addTarget { [weak self] _ in
|
|
self?.play()
|
|
return .success
|
|
}
|
|
|
|
// Pause command
|
|
commandCenter.pauseCommand.isEnabled = true
|
|
commandCenter.pauseCommand.addTarget { [weak self] _ in
|
|
self?.pause()
|
|
return .success
|
|
}
|
|
|
|
// Toggle play/pause command
|
|
commandCenter.togglePlayPauseCommand.isEnabled = true
|
|
commandCenter.togglePlayPauseCommand.addTarget { [weak self] _ in
|
|
guard let self = self, let player = self.mediaPlayer else {
|
|
return .commandFailed
|
|
}
|
|
|
|
if player.isPlaying {
|
|
self.pause()
|
|
} else {
|
|
self.play()
|
|
}
|
|
return .success
|
|
}
|
|
|
|
// Seek forward command
|
|
commandCenter.skipForwardCommand.isEnabled = true
|
|
commandCenter.skipForwardCommand.preferredIntervals = [15]
|
|
commandCenter.skipForwardCommand.addTarget { [weak self] event in
|
|
guard let self = self, let player = self.mediaPlayer else {
|
|
return .commandFailed
|
|
}
|
|
|
|
let skipInterval = (event as? MPSkipIntervalCommandEvent)?.interval ?? 15
|
|
let currentTime = player.time.intValue
|
|
self.seekTo(currentTime + Int32(skipInterval * 1000))
|
|
return .success
|
|
}
|
|
|
|
// Seek backward command
|
|
commandCenter.skipBackwardCommand.isEnabled = true
|
|
commandCenter.skipBackwardCommand.preferredIntervals = [15]
|
|
commandCenter.skipBackwardCommand.addTarget { [weak self] event in
|
|
guard let self = self, let player = self.mediaPlayer else {
|
|
return .commandFailed
|
|
}
|
|
|
|
let skipInterval = (event as? MPSkipIntervalCommandEvent)?.interval ?? 15
|
|
let currentTime = player.time.intValue
|
|
self.seekTo(max(0, currentTime - Int32(skipInterval * 1000)))
|
|
return .success
|
|
}
|
|
|
|
// Change playback position command (scrubbing)
|
|
commandCenter.changePlaybackPositionCommand.isEnabled = true
|
|
commandCenter.changePlaybackPositionCommand.addTarget { [weak self] event in
|
|
guard let self = self,
|
|
let event = event as? MPChangePlaybackPositionCommandEvent else {
|
|
return .commandFailed
|
|
}
|
|
|
|
let positionTime = event.positionTime
|
|
self.seekTo(Int32(positionTime * 1000))
|
|
return .success
|
|
}
|
|
|
|
print("Remote command center configured")
|
|
#endif
|
|
}
|
|
|
|
private func cleanupRemoteCommandCenter() {
|
|
#if !os(tvOS)
|
|
let commandCenter = MPRemoteCommandCenter.shared()
|
|
|
|
// Remove all command targets to prevent memory leaks
|
|
commandCenter.playCommand.removeTarget(nil)
|
|
commandCenter.pauseCommand.removeTarget(nil)
|
|
commandCenter.togglePlayPauseCommand.removeTarget(nil)
|
|
commandCenter.skipForwardCommand.removeTarget(nil)
|
|
commandCenter.skipBackwardCommand.removeTarget(nil)
|
|
commandCenter.changePlaybackPositionCommand.removeTarget(nil)
|
|
|
|
// Disable commands
|
|
commandCenter.playCommand.isEnabled = false
|
|
commandCenter.pauseCommand.isEnabled = false
|
|
commandCenter.togglePlayPauseCommand.isEnabled = false
|
|
commandCenter.skipForwardCommand.isEnabled = false
|
|
commandCenter.skipBackwardCommand.isEnabled = false
|
|
commandCenter.changePlaybackPositionCommand.isEnabled = false
|
|
|
|
print("Remote command center cleaned up")
|
|
#endif
|
|
}
|
|
|
|
// MARK: - Public Methods
|
|
func startPictureInPicture() {}
|
|
|
|
@objc func play() {
|
|
DispatchQueue.main.async {
|
|
self.mediaPlayer?.play()
|
|
self.isPaused = false
|
|
self.updateNowPlayingInfo()
|
|
print("Play")
|
|
}
|
|
}
|
|
|
|
@objc func pause() {
|
|
DispatchQueue.main.async {
|
|
self.mediaPlayer?.pause()
|
|
self.isPaused = true
|
|
self.updateNowPlayingInfo()
|
|
}
|
|
}
|
|
|
|
@objc func handleAudioSessionInterruption(_ notification: Notification) {
|
|
#if !os(tvOS)
|
|
guard let userInfo = notification.userInfo,
|
|
let typeValue = userInfo[AVAudioSessionInterruptionTypeKey] as? UInt,
|
|
let type = AVAudioSession.InterruptionType(rawValue: typeValue) else {
|
|
return
|
|
}
|
|
|
|
switch type {
|
|
case .began:
|
|
// Interruption began - pause the video
|
|
print("Audio session interrupted - pausing video")
|
|
self.pause()
|
|
|
|
case .ended:
|
|
// Interruption ended - check if we should resume
|
|
if let optionsValue = userInfo[AVAudioSessionInterruptionOptionKey] as? UInt {
|
|
let options = AVAudioSession.InterruptionOptions(rawValue: optionsValue)
|
|
if options.contains(.shouldResume) {
|
|
print("Audio session interruption ended - can resume")
|
|
// Don't auto-resume - let user manually resume playback
|
|
} else {
|
|
print("Audio session interruption ended - should not resume")
|
|
}
|
|
}
|
|
|
|
@unknown default:
|
|
break
|
|
}
|
|
#endif
|
|
}
|
|
|
|
@objc func seekTo(_ time: Int32) {
|
|
DispatchQueue.main.async {
|
|
guard let player = self.mediaPlayer else { return }
|
|
|
|
let wasPlaying = player.isPlaying
|
|
if wasPlaying {
|
|
player.pause()
|
|
}
|
|
|
|
if let duration = player.media?.length.intValue {
|
|
print("Seeking to time: \(time) Video Duration \(duration)")
|
|
|
|
// If the specified time is greater than the duration, seek to the end
|
|
let seekTime = time > duration ? duration - 1000 : time
|
|
player.time = VLCTime(int: seekTime)
|
|
if wasPlaying {
|
|
player.play()
|
|
}
|
|
self.updatePlayerState()
|
|
self.updateNowPlayingInfo()
|
|
} else {
|
|
print("Error: Unable to retrieve video duration")
|
|
}
|
|
}
|
|
}
|
|
|
|
@objc func setSource(_ source: [String: Any]) {
|
|
DispatchQueue.main.async { [weak self] in
|
|
guard let self = self else { return }
|
|
if self.hasSource {
|
|
return
|
|
}
|
|
|
|
let mediaOptions = source["mediaOptions"] as? [String: Any] ?? [:]
|
|
self.externalTrack = source["externalTrack"] as? [String: String]
|
|
var initOptions = source["initOptions"] as? [Any] ?? []
|
|
self.startPosition = source["startPosition"] as? Int32 ?? 0
|
|
self.externalSubtitles = source["externalSubtitles"] as? [[String: String]]
|
|
|
|
guard let uri = source["uri"] as? String, !uri.isEmpty else {
|
|
print("Error: Invalid or empty URI")
|
|
self.onVideoError?(["error": "Invalid or empty URI"])
|
|
return
|
|
}
|
|
|
|
self.isTranscoding = uri.contains("m3u8")
|
|
|
|
if !self.isTranscoding, self.startPosition > 0 {
|
|
initOptions.append("--start-time=\(self.startPosition)")
|
|
}
|
|
|
|
let autoplay = source["autoplay"] as? Bool ?? false
|
|
let isNetwork = source["isNetwork"] as? Bool ?? false
|
|
|
|
self.onVideoLoadStart?(["target": self.reactTag ?? NSNull()])
|
|
self.mediaPlayer = VLCMediaPlayer(options: initOptions)
|
|
self.mediaPlayer?.delegate = self
|
|
self.mediaPlayer?.drawable = self.videoView
|
|
self.mediaPlayer?.scaleFactor = 0
|
|
self.initialSeekPerformed = false
|
|
|
|
let media: VLCMedia
|
|
if isNetwork {
|
|
print("Loading network file: \(uri)")
|
|
media = VLCMedia(url: URL(string: uri)!)
|
|
} else {
|
|
print("Loading local file: \(uri)")
|
|
if uri.starts(with: "file://"), let url = URL(string: uri) {
|
|
media = VLCMedia(url: url)
|
|
} else {
|
|
media = VLCMedia(path: uri)
|
|
}
|
|
}
|
|
|
|
print("Debug: Media options: \(mediaOptions)")
|
|
media.addOptions(mediaOptions)
|
|
|
|
self.mediaPlayer?.media = media
|
|
self.setInitialExternalSubtitles()
|
|
self.hasSource = true
|
|
if autoplay {
|
|
print("Playing...")
|
|
self.play()
|
|
}
|
|
}
|
|
}
|
|
|
|
@objc func setAudioTrack(_ trackIndex: Int) {
|
|
self.mediaPlayer?.currentAudioTrackIndex = Int32(trackIndex)
|
|
}
|
|
|
|
@objc func getAudioTracks() -> [[String: Any]]? {
|
|
guard let trackNames = mediaPlayer?.audioTrackNames,
|
|
let trackIndexes = mediaPlayer?.audioTrackIndexes
|
|
else {
|
|
return nil
|
|
}
|
|
|
|
return zip(trackNames, trackIndexes).map { name, index in
|
|
return ["name": name, "index": index]
|
|
}
|
|
}
|
|
|
|
@objc func setSubtitleTrack(_ trackIndex: Int) {
|
|
print("Debug: Attempting to set subtitle track to index: \(trackIndex)")
|
|
self.mediaPlayer?.currentVideoSubTitleIndex = Int32(trackIndex)
|
|
print(
|
|
"Debug: Current subtitle track index after setting: \(self.mediaPlayer?.currentVideoSubTitleIndex ?? -1)"
|
|
)
|
|
}
|
|
|
|
@objc func setSubtitleURL(_ subtitleURL: String, name: String) {
|
|
guard let url = URL(string: subtitleURL) else {
|
|
print("Error: Invalid subtitle URL")
|
|
return
|
|
}
|
|
|
|
let result = self.mediaPlayer?.addPlaybackSlave(url, type: .subtitle, enforce: false)
|
|
if let result = result {
|
|
let internalName = "Track \(self.customSubtitles.count)"
|
|
print("Subtitle added with result: \(result) \(internalName)")
|
|
self.customSubtitles.append((internalName: internalName, originalName: name))
|
|
} else {
|
|
print("Failed to add subtitle")
|
|
}
|
|
}
|
|
|
|
private func setInitialExternalSubtitles() {
|
|
if let externalSubtitles = self.externalSubtitles {
|
|
for subtitle in externalSubtitles {
|
|
if let subtitleName = subtitle["name"],
|
|
let subtitleURL = subtitle["DeliveryUrl"]
|
|
{
|
|
print("Setting external subtitle: \(subtitleName) \(subtitleURL)")
|
|
self.setSubtitleURL(subtitleURL, name: subtitleName)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
@objc func getSubtitleTracks() -> [[String: Any]]? {
|
|
guard let mediaPlayer = self.mediaPlayer else {
|
|
return nil
|
|
}
|
|
|
|
let count = mediaPlayer.numberOfSubtitlesTracks
|
|
print("Debug: Number of subtitle tracks: \(count)")
|
|
|
|
guard count > 0 else {
|
|
return nil
|
|
}
|
|
|
|
var tracks: [[String: Any]] = []
|
|
|
|
if let names = mediaPlayer.videoSubTitlesNames as? [String],
|
|
let indexes = mediaPlayer.videoSubTitlesIndexes as? [NSNumber]
|
|
{
|
|
for (index, name) in zip(indexes, names) {
|
|
if let customSubtitle = customSubtitles.first(where: { $0.internalName == name }) {
|
|
tracks.append(["name": customSubtitle.originalName, "index": index.intValue])
|
|
} else {
|
|
tracks.append(["name": name, "index": index.intValue])
|
|
}
|
|
}
|
|
}
|
|
|
|
print("Debug: Subtitle tracks: \(tracks)")
|
|
return tracks
|
|
}
|
|
|
|
@objc func setVideoAspectRatio(_ aspectRatio: String?) {
|
|
DispatchQueue.main.async {
|
|
if let aspectRatio = aspectRatio {
|
|
// Convert String to C string for VLC
|
|
let cString = strdup(aspectRatio)
|
|
self.mediaPlayer?.videoAspectRatio = cString
|
|
} else {
|
|
// Reset to default (let VLC determine aspect ratio)
|
|
self.mediaPlayer?.videoAspectRatio = nil
|
|
}
|
|
}
|
|
}
|
|
|
|
@objc func setVideoScaleFactor(_ scaleFactor: Float) {
|
|
DispatchQueue.main.async {
|
|
self.mediaPlayer?.scaleFactor = scaleFactor
|
|
print("Set video scale factor: \(scaleFactor)")
|
|
}
|
|
}
|
|
|
|
@objc func setRate(_ rate: Float) {
|
|
DispatchQueue.main.async {
|
|
self.mediaPlayer?.rate = rate
|
|
print("Set playback rate: \(rate)")
|
|
}
|
|
}
|
|
|
|
@objc func setNowPlayingMetadata(_ metadata: [String: String]) {
|
|
// Cancel any existing artwork download to prevent race conditions
|
|
artworkDownloadTask?.cancel()
|
|
artworkDownloadTask = nil
|
|
|
|
self.nowPlayingMetadata = metadata
|
|
print("[NowPlaying] Metadata received: \(metadata)")
|
|
|
|
// Load artwork asynchronously if provided
|
|
if let artworkUri = metadata["artworkUri"], let url = URL(string: artworkUri) {
|
|
print("[NowPlaying] Loading artwork from: \(artworkUri)")
|
|
artworkDownloadTask = URLSession.shared.dataTask(with: url) { [weak self] data, _, error in
|
|
guard let self = self else { return }
|
|
|
|
if let error = error as NSError?, error.code == NSURLErrorCancelled {
|
|
print("[NowPlaying] Artwork download cancelled")
|
|
return
|
|
}
|
|
|
|
if let error = error {
|
|
print("[NowPlaying] Artwork loading error: \(error)")
|
|
DispatchQueue.main.async {
|
|
self.updateNowPlayingInfo()
|
|
}
|
|
} else if let data = data, let image = UIImage(data: data) {
|
|
print("[NowPlaying] Artwork loaded successfully, size: \(image.size)")
|
|
self.artworkImage = image
|
|
DispatchQueue.main.async {
|
|
self.updateNowPlayingInfo()
|
|
}
|
|
} else {
|
|
print("[NowPlaying] Failed to create image from data")
|
|
// Update Now Playing info without artwork on failure
|
|
DispatchQueue.main.async {
|
|
self.updateNowPlayingInfo()
|
|
}
|
|
}
|
|
}
|
|
artworkDownloadTask?.resume()
|
|
} else {
|
|
// No artwork URI provided - update immediately
|
|
print("[NowPlaying] No artwork URI provided")
|
|
artworkImage = nil
|
|
DispatchQueue.main.async {
|
|
self.updateNowPlayingInfo()
|
|
}
|
|
}
|
|
}
|
|
|
|
@objc func stop(completion: (() -> Void)? = nil) {
|
|
guard !isStopping else {
|
|
completion?()
|
|
return
|
|
}
|
|
isStopping = true
|
|
|
|
// If we're not on the main thread, dispatch to main thread
|
|
if !Thread.isMainThread {
|
|
DispatchQueue.main.async { [weak self] in
|
|
self?.performStop(completion: completion)
|
|
}
|
|
} else {
|
|
performStop(completion: completion)
|
|
}
|
|
}
|
|
|
|
// MARK: - Private Methods
|
|
|
|
@objc private func applicationWillResignActive() {
|
|
|
|
}
|
|
|
|
@objc private func applicationDidBecomeActive() {
|
|
|
|
}
|
|
|
|
private func performStop(completion: (() -> Void)? = nil) {
|
|
// Stop the media player
|
|
mediaPlayer?.stop()
|
|
|
|
// Cancel any in-flight artwork downloads
|
|
artworkDownloadTask?.cancel()
|
|
artworkDownloadTask = nil
|
|
artworkImage = nil
|
|
|
|
// Cleanup remote command center targets
|
|
cleanupRemoteCommandCenter()
|
|
|
|
#if !os(tvOS)
|
|
// Deactivate audio session to allow other apps to use audio
|
|
do {
|
|
try AVAudioSession.sharedInstance().setActive(false, options: .notifyOthersOnDeactivation)
|
|
print("Audio session deactivated")
|
|
} catch {
|
|
print("Failed to deactivate audio session: \(error)")
|
|
}
|
|
|
|
// Clear Now Playing info
|
|
MPNowPlayingInfoCenter.default().nowPlayingInfo = nil
|
|
#endif
|
|
|
|
// Remove observer
|
|
NotificationCenter.default.removeObserver(self)
|
|
|
|
// Clear the video view
|
|
videoView?.removeFromSuperview()
|
|
videoView = nil
|
|
|
|
// Release the media player
|
|
mediaPlayer?.delegate = nil
|
|
mediaPlayer = nil
|
|
|
|
isStopping = false
|
|
completion?()
|
|
}
|
|
|
|
private func updateVideoProgress() {
|
|
guard let player = self.mediaPlayer else { return }
|
|
|
|
let currentTimeMs = player.time.intValue
|
|
let durationMs = player.media?.length.intValue ?? 0
|
|
|
|
|
|
print("Debug: Current time: \(currentTimeMs)")
|
|
if currentTimeMs >= 0 && currentTimeMs < durationMs {
|
|
if self.isTranscoding, !self.initialSeekPerformed, self.startPosition > 0 {
|
|
player.time = VLCTime(int: self.startPosition * 1000)
|
|
self.initialSeekPerformed = true
|
|
}
|
|
self.onVideoProgress?([
|
|
"currentTime": currentTimeMs,
|
|
"duration": durationMs,
|
|
])
|
|
}
|
|
|
|
// Update Now Playing info to sync elapsed playback time
|
|
// iOS needs periodic updates to keep progress indicator in sync
|
|
DispatchQueue.main.async {
|
|
self.updateNowPlayingInfo()
|
|
}
|
|
}
|
|
|
|
private func updateNowPlayingInfo() {
|
|
#if !os(tvOS)
|
|
guard let player = self.mediaPlayer else { return }
|
|
|
|
var nowPlayingInfo = [String: Any]()
|
|
|
|
// Playback rate (0.0 = paused, 1.0 = playing at normal speed)
|
|
nowPlayingInfo[MPNowPlayingInfoPropertyPlaybackRate] = player.isPlaying ? player.rate : 0.0
|
|
|
|
// Current playback time in seconds
|
|
let currentTimeSeconds = Double(player.time.intValue) / 1000.0
|
|
nowPlayingInfo[MPNowPlayingInfoPropertyElapsedPlaybackTime] = currentTimeSeconds
|
|
|
|
// Total duration in seconds
|
|
if let duration = player.media?.length.intValue {
|
|
let durationSeconds = Double(duration) / 1000.0
|
|
nowPlayingInfo[MPMediaItemPropertyPlaybackDuration] = durationSeconds
|
|
}
|
|
|
|
// Add metadata if available
|
|
if let metadata = self.nowPlayingMetadata {
|
|
if let title = metadata["title"] {
|
|
nowPlayingInfo[MPMediaItemPropertyTitle] = title
|
|
print("[NowPlaying] Setting title: \(title)")
|
|
}
|
|
if let artist = metadata["artist"] {
|
|
nowPlayingInfo[MPMediaItemPropertyArtist] = artist
|
|
print("[NowPlaying] Setting artist: \(artist)")
|
|
}
|
|
if let albumTitle = metadata["albumTitle"] {
|
|
nowPlayingInfo[MPMediaItemPropertyAlbumTitle] = albumTitle
|
|
print("[NowPlaying] Setting album: \(albumTitle)")
|
|
}
|
|
}
|
|
|
|
// Add artwork if available
|
|
if let artwork = self.artworkImage {
|
|
print("[NowPlaying] Setting artwork with size: \(artwork.size)")
|
|
let artworkItem = MPMediaItemArtwork(boundsSize: artwork.size) { _ in
|
|
return artwork
|
|
}
|
|
nowPlayingInfo[MPMediaItemPropertyArtwork] = artworkItem
|
|
}
|
|
|
|
MPNowPlayingInfoCenter.default().nowPlayingInfo = nowPlayingInfo
|
|
#endif
|
|
}
|
|
|
|
// MARK: - Expo Events
|
|
|
|
@objc var onPlaybackStateChanged: RCTDirectEventBlock?
|
|
@objc var onVideoLoadStart: RCTDirectEventBlock?
|
|
@objc var onVideoStateChange: RCTDirectEventBlock?
|
|
@objc var onVideoProgress: RCTDirectEventBlock?
|
|
@objc var onVideoLoadEnd: RCTDirectEventBlock?
|
|
@objc var onVideoError: RCTDirectEventBlock?
|
|
@objc var onPipStarted: RCTDirectEventBlock?
|
|
|
|
// MARK: - Deinitialization
|
|
|
|
deinit {
|
|
performStop()
|
|
}
|
|
}
|
|
|
|
extension VlcPlayerView: VLCMediaPlayerDelegate {
|
|
func mediaPlayerTimeChanged(_ aNotification: Notification) {
|
|
// self?.updateVideoProgress()
|
|
let timeNow = Date().timeIntervalSince1970
|
|
if timeNow - lastProgressCall >= 1 {
|
|
lastProgressCall = timeNow
|
|
updateVideoProgress()
|
|
}
|
|
}
|
|
|
|
func mediaPlayerStateChanged(_ aNotification: Notification) {
|
|
self.updatePlayerState()
|
|
}
|
|
|
|
private func updatePlayerState() {
|
|
guard let player = self.mediaPlayer else { return }
|
|
let currentState = player.state
|
|
|
|
var stateInfo: [String: Any] = [
|
|
"target": self.reactTag ?? NSNull(),
|
|
"currentTime": player.time.intValue,
|
|
"duration": player.media?.length.intValue ?? 0,
|
|
"error": false,
|
|
]
|
|
|
|
if player.isPlaying {
|
|
stateInfo["isPlaying"] = true
|
|
stateInfo["isBuffering"] = false
|
|
stateInfo["state"] = "Playing"
|
|
} else {
|
|
stateInfo["isPlaying"] = false
|
|
stateInfo["state"] = "Paused"
|
|
}
|
|
|
|
if player.state == VLCMediaPlayerState.buffering {
|
|
stateInfo["isBuffering"] = true
|
|
stateInfo["state"] = "Buffering"
|
|
} else if player.state == VLCMediaPlayerState.error {
|
|
print("player.state ~ error")
|
|
stateInfo["state"] = "Error"
|
|
self.onVideoLoadEnd?(stateInfo)
|
|
} else if player.state == VLCMediaPlayerState.opening {
|
|
print("player.state ~ opening")
|
|
stateInfo["state"] = "Opening"
|
|
}
|
|
|
|
if self.lastReportedState != currentState
|
|
|| self.lastReportedIsPlaying != player.isPlaying
|
|
{
|
|
self.lastReportedState = currentState
|
|
self.lastReportedIsPlaying = player.isPlaying
|
|
self.onVideoStateChange?(stateInfo)
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
extension VlcPlayerView: VLCMediaDelegate {
|
|
// Implement VLCMediaDelegate methods if needed
|
|
}
|
|
|
|
extension VLCMediaPlayerState {
|
|
var description: String {
|
|
switch self {
|
|
case .opening: return "Opening"
|
|
case .buffering: return "Buffering"
|
|
case .playing: return "Playing"
|
|
case .paused: return "Paused"
|
|
case .stopped: return "Stopped"
|
|
case .ended: return "Ended"
|
|
case .error: return "Error"
|
|
case .esAdded: return "ESAdded"
|
|
@unknown default: return "Unknown"
|
|
}
|
|
}
|
|
} |