refactor: Feature/offline mode rework (#859)

Co-authored-by: lostb1t <coding-mosses0z@icloud.com>
Co-authored-by: Fredrik Burmester <fredrik.burmester@gmail.com>
Co-authored-by: Gauvain <68083474+Gauvino@users.noreply.github.com>
Co-authored-by: Gauvino <uruknarb20@gmail.com>
Co-authored-by: storm1er <le.storm1er@gmail.com>
Co-authored-by: renovate[bot] <29139614+renovate[bot]@users.noreply.github.com>
Co-authored-by: Chris <182387676+whoopsi-daisy@users.noreply.github.com>
Co-authored-by: arch-fan <55891793+arch-fan@users.noreply.github.com>
Co-authored-by: Alex Kim <alexkim@Alexs-MacBook-Pro.local>

modules/vlc-player/android/src/main/java/expo/modules/vlcplayer/VlcPlayerView.kt

@@ -62,6 +62,7 @@ class VlcPlayerView(context: Context, appContext: AppContext) : ExpoView(context
     private var startPosition: Int? = 0
     private var isMediaReady: Boolean = false
     private var externalTrack: Map<String, String>? = null
+    private var externalSubtitles: List<Map<String, String>>? = null
     var hasSource: Boolean = false
 
     private val handler = Handler(Looper.getMainLooper())
@@ -220,6 +221,7 @@ class VlcPlayerView(context: Context, appContext: AppContext) : ExpoView(context
         val autoplay = source["autoplay"] as? Boolean ?: false
         val isNetwork = source["isNetwork"] as? Boolean ?: false
         externalTrack = source["externalTrack"] as? Map<String, String>
+        externalSubtitles = source["externalSubtitles"] as? List<Map<String, String>>
         startPosition = (source["startPosition"] as? Double)?.toInt() ?: 0
 
         val initOptions = source["initOptions"] as? MutableList<String> ?: mutableListOf()
@@ -240,20 +242,11 @@ class VlcPlayerView(context: Context, appContext: AppContext) : ExpoView(context
         media = Media(libVLC, Uri.parse(uri))
         mediaPlayer?.media = media
 
-
         log.debug("Debug: Media options: $mediaOptions")
         // media.addOptions(mediaOptions)
 
-        // Apply subtitle options
-        // val subtitleTrackIndex = source["subtitleTrackIndex"] as? Int ?: -1
-        // Log.d("VlcPlayerView", "Debug: Subtitle track index from source: $subtitleTrackIndex")
-
-        // if (subtitleTrackIndex >= -1) {
-        //     setSubtitleTrack(subtitleTrackIndex)
-        //     Log.d("VlcPlayerView", "Debug: Set subtitle track to index: $subtitleTrackIndex")
-        // } else {
-        //     Log.d("VlcPlayerView", "Debug: Subtitle track index is less than -1, not setting")
-        // }
+        // Set initial external subtitles immediately like iOS
+        setInitialExternalSubtitles()
 
         hasSource = true
 
@@ -342,6 +335,19 @@ class VlcPlayerView(context: Context, appContext: AppContext) : ExpoView(context
         mediaPlayer?.addSlave(IMedia.Slave.Type.Subtitle, Uri.parse(subtitleURL), true)
     }
 
+    private fun setInitialExternalSubtitles() {
+        externalSubtitles?.let { subtitles ->
+            for (subtitle in subtitles) {
+                val subtitleName = subtitle["name"]
+                val subtitleURL = subtitle["DeliveryUrl"]
+                if (!subtitleName.isNullOrEmpty() && !subtitleURL.isNullOrEmpty()) {
+                    log.debug("Setting external subtitle: $subtitleName $subtitleURL")
+                    setSubtitleURL(subtitleURL, subtitleName)
+                }
+            }
+        }
+    }
+
     override fun onDetachedFromWindow() {
         log.debug("onDetachedFromWindow")
         super.onDetachedFromWindow()

modules/vlc-player/expo-module.config.json

@@ -1,8 +1,7 @@
 {
   "platforms": ["ios", "tvos", "android", "web"],
   "ios": {
-    "modules": ["VlcPlayerModule"],
-    "appDelegateSubscribers": ["AppLifecycleDelegate"]
+    "modules": ["VlcPlayerModule"]
   },
   "android": {
     "modules": ["expo.modules.vlcplayer.VlcPlayerModule"]

modules/vlc-player/ios/AppLifecycleDelegate.swift

@@ -1,32 +0,0 @@
-import ExpoModulesCore
-
-protocol SimpleAppLifecycleListener {
-    func applicationDidEnterBackground() -> Void
-    func applicationDidEnterForeground() -> Void
-}
-
-public class AppLifecycleDelegate: ExpoAppDelegateSubscriber {
-  public func applicationDidBecomeActive(_ application: UIApplication) {
-    // The app has become active.
-  }
-
-  public func applicationWillResignActive(_ application: UIApplication) {
-    // The app is about to become inactive.
-  }
-
-  public func applicationDidEnterBackground(_ application: UIApplication) {
-    VLCManager.shared.listeners.forEach { listener in
-        listener.applicationDidEnterBackground()
-    }
-  }
-
-  public func applicationWillEnterForeground(_ application: UIApplication) {
-        VLCManager.shared.listeners.forEach { listener in
-            listener.applicationDidEnterForeground()
-        }
-  }
-
-  public func applicationWillTerminate(_ application: UIApplication) {
-    // The app is about to terminate.
-  }
-}

modules/vlc-player/ios/VLCManager.swift

@@ -1,4 +0,0 @@
-class VLCManager {
-    static let shared = VLCManager()
-    var listeners: [SimpleAppLifecycleListener] = []
-}

modules/vlc-player/ios/VlcPlayer.podspec

@@ -1,22 +1,23 @@
 Pod::Spec.new do |s|
   s.name           = 'VlcPlayer'
-  s.version        = '4.0.0a10'
+  s.version        = '3.6.1b1'
   s.summary        = 'A sample project summary'
   s.description    = 'A sample project description'
   s.author         = ''
   s.homepage       = 'https://docs.expo.dev/modules/'
-  s.platforms      = { :ios => '13.4', :tvos => '16' }
+  s.platforms      = { :ios => '13.4', :tvos => '13.4' }
   s.source         = { git: '' }
   s.static_framework = true
 
   s.dependency 'ExpoModulesCore'
-  s.ios.dependency 'VLCKit', s.version
-  s.tvos.dependency 'VLCKit', s.version
+  s.ios.dependency 'MobileVLCKit', s.version
+  s.tvos.dependency 'TVVLCKit', s.version
 
   # Swift/Objective-C compatibility
   s.pod_target_xcconfig = {
     'DEFINES_MODULE' => 'YES',
     'SWIFT_COMPILATION_MODE' => 'wholemodule'
   }
+
   s.source_files = "*.{h,m,mm,swift,hpp,cpp}"
 end

modules/vlc-player/ios/VlcPlayerModule.swift

@@ -54,6 +54,10 @@ public class VlcPlayerModule: Module {
                 return view.getAudioTracks()
             }
 
+            AsyncFunction("setSubtitleURL") { (view: VlcPlayerView, url: String, name: String) in
+                view.setSubtitleURL(url, name: name)
+            }
+
             AsyncFunction("setSubtitleTrack") { (view: VlcPlayerView, trackIndex: Int) in
                 view.setSubtitleTrack(trackIndex)
             }
@@ -61,11 +65,6 @@ public class VlcPlayerModule: Module {
             AsyncFunction("getSubtitleTracks") { (view: VlcPlayerView) -> [[String: Any]]? in
                 return view.getSubtitleTracks()
             }
-
-            AsyncFunction("setSubtitleURL") {
-                (view: VlcPlayerView, url: String, name: String) in
-                view.setSubtitleURL(url, name: name)
-            }
         }
     }
 }

modules/vlc-player/ios/VlcPlayerView.swift

@@ -1,175 +1,56 @@
 import ExpoModulesCore
-import UIKit
-import VLCKit
-import os
 
-public class VLCPlayerView: UIView {
-    func setupView(parent: UIView) {
-        self.backgroundColor = .black
-        self.translatesAutoresizingMaskIntoConstraints = false
-        NSLayoutConstraint.activate([
-            self.leadingAnchor.constraint(equalTo: parent.leadingAnchor),
-            self.trailingAnchor.constraint(equalTo: parent.trailingAnchor),
-            self.topAnchor.constraint(equalTo: parent.topAnchor),
-            self.bottomAnchor.constraint(equalTo: parent.bottomAnchor),
-        ])
-    }
-
-    public override func layoutSubviews() {
-        super.layoutSubviews()
-
-        for subview in subviews {
-            subview.frame = bounds
-        }
-    }
-}
-
-class VLCPlayerWrapper: NSObject {
-    private var lastProgressCall = Date().timeIntervalSince1970
-    public var player: VLCMediaPlayer = VLCMediaPlayer()
-    private var updatePlayerState: (() -> Void)?
-    private var updateVideoProgress: (() -> Void)?
-    private var playerView: VLCPlayerView = VLCPlayerView()
-    public weak var pipController: VLCPictureInPictureWindowControlling?
-
-    override public init() {
-        super.init()
-        player.delegate = self
-        player.drawable = self
-        player.scaleFactor = 0
-    }
-
-    public func setup(
-        parent: UIView,
-        updatePlayerState: (() -> Void)?,
-        updateVideoProgress: (() -> Void)?
-    ) {
-        self.updatePlayerState = updatePlayerState
-        self.updateVideoProgress = updateVideoProgress
-
-        player.delegate = self
-        parent.addSubview(playerView)
-        playerView.setupView(parent: parent)
-    }
-
-    public func getPlayerView() -> UIView {
-        return playerView
-    }
-}
-
-// MARK: - VLCPictureInPictureDrawable
-extension VLCPlayerWrapper: VLCPictureInPictureDrawable {
-    public func mediaController() -> (any VLCPictureInPictureMediaControlling)! {
-        return self
-    }
-
-    public func pictureInPictureReady() -> (((any VLCPictureInPictureWindowControlling)?) -> Void)!
-    {
-        return { [weak self] controller in
-            self?.pipController = controller
-        }
-    }
-}
-
-// MARK: - VLCPictureInPictureMediaControlling
-extension VLCPlayerWrapper: VLCPictureInPictureMediaControlling {
-    func mediaTime() -> Int64 {
-        return player.time.value?.int64Value ?? 0
-    }
-
-    func mediaLength() -> Int64 {
-        return player.media?.length.value?.int64Value ?? 0
-    }
-
-    func play() {
-        player.play()
-    }
-
-    func pause() {
-        player.pause()
-    }
-
-    func seek(by offset: Int64, completion: @escaping () -> Void) {
-        player.jump(withOffset: Int32(offset), completion: completion)
-    }
-
-    func isMediaSeekable() -> Bool {
-        return player.isSeekable
-    }
-
-    func isMediaPlaying() -> Bool {
-        return player.isPlaying
-    }
-}
-
-// MARK: - VLCDrawable
-extension VLCPlayerWrapper: VLCDrawable {
-    public func addSubview(_ view: UIView) {
-        playerView.addSubview(view)
-    }
-
-    public func bounds() -> CGRect {
-        return playerView.bounds
-    }
-}
-
-// MARK: - VLCMediaPlayerDelegate
-extension VLCPlayerWrapper: VLCMediaPlayerDelegate {
-    func mediaPlayerTimeChanged(_ aNotification: Notification) {
-        DispatchQueue.main.async { [weak self] in
-            guard let self = self else { return }
-            let timeNow = Date().timeIntervalSince1970
-            if timeNow - self.lastProgressCall >= 1 {
-                self.lastProgressCall = timeNow
-                self.updateVideoProgress?()
-            }
-        }
-    }
-
-    func mediaPlayerStateChanged(_ state: VLCMediaPlayerState) {
-        DispatchQueue.main.async { [weak self] in
-            guard let self = self else { return }
-            self.updatePlayerState?()
-
-            guard let pipController = self.pipController else { return }
-            pipController.invalidatePlaybackState()
-        }
-    }
-}
-
-// MARK: - VLCMediaDelegate
-extension VLCPlayerWrapper: VLCMediaDelegate {
-    // Implement VLCMediaDelegate methods if needed
-}
+#if os(tvOS)
+    import TVVLCKit
+#else
+    import MobileVLCKit
+#endif
 
 class VlcPlayerView: ExpoView {
-    let logger = Logger(subsystem: Bundle.main.bundleIdentifier!, category: "VlcPlayerView")
-
-    private var vlc: VLCPlayerWrapper = VLCPlayerWrapper()
+    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 externalTrack: [String: String]?
-    private var isStopping: Bool = false  // Define isStopping here
     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
 
     // MARK: - Initialization
+
     required init(appContext: AppContext? = nil) {
         super.init(appContext: appContext)
-        setupVLC()
+        setupView()
         setupNotifications()
-        VLCManager.shared.listeners.append(self)
     }
 
     // MARK: - Setup
-    private func setupVLC() {
-        vlc.setup(
-            parent: self,
-            updatePlayerState: updatePlayerState,
-            updateVideoProgress: updateVideoProgress
-        )
+
+    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() {
@@ -182,86 +63,83 @@ class VlcPlayerView: ExpoView {
     }
 
     // MARK: - Public Methods
-    func startPictureInPicture() {
-        self.vlc.pipController?.stateChangeEventHandler = { (isStarted: Bool) in
-            self.onPipStarted?(["pipStarted": isStarted])
-        }
-        self.vlc.pipController?.startPictureInPicture()
-    }
+    func startPictureInPicture() {}
 
     @objc func play() {
-        self.vlc.player.play()
+        self.mediaPlayer?.play()
         self.isPaused = false
-        logger.debug("Play")
+        print("Play")
     }
 
     @objc func pause() {
-        self.vlc.player.pause()
+        self.mediaPlayer?.pause()
         self.isPaused = true
     }
 
     @objc func seekTo(_ time: Int32) {
-        let wasPlaying = vlc.player.isPlaying
+        guard let player = self.mediaPlayer else { return }
+
+        let wasPlaying = player.isPlaying
         if wasPlaying {
             self.pause()
         }
 
-        if let duration = vlc.player.media?.length.intValue {
-            logger.debug("Seeking to time: \(time) Video Duration \(duration)")
+        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
-            vlc.player.time = VLCTime(int: seekTime)
-            self.updatePlayerState()
-
-            // Let mediaPlayerStateChanged handle play state change
-            DispatchQueue.main.asyncAfter(deadline: .now() + 0.5) {
-                if wasPlaying {
-                    self.play()
-                }
+            player.time = VLCTime(int: seekTime)
+            if wasPlaying {
+                self.play()
             }
+            self.updatePlayerState()
         } else {
-            logger.error("Unable to retrieve video duration")
+            print("Error: Unable to retrieve video duration")
         }
     }
 
     @objc func setSource(_ source: [String: Any]) {
-        logger.debug("Setting source...")
         DispatchQueue.main.async { [weak self] in
             guard let self = self else { return }
             if self.hasSource {
                 return
             }
 
-            var mediaOptions = source["mediaOptions"] as? [String: Any] ?? [:]
+            let mediaOptions = source["mediaOptions"] as? [String: Any] ?? [:]
             self.externalTrack = source["externalTrack"] as? [String: String]
-            let initOptions: [String] = source["initOptions"] as? [String] ?? []
+            var initOptions = source["initOptions"] as? [Any] ?? []
             self.startPosition = source["startPosition"] as? Int32 ?? 0
             self.externalSubtitles = source["externalSubtitles"] as? [[String: String]]
 
-            for item in initOptions {
-                let option = item.components(separatedBy: "=")
-                mediaOptions.updateValue(
-                    option[1], forKey: option[0].replacingOccurrences(of: "--", with: ""))
-            }
-
             guard let uri = source["uri"] as? String, !uri.isEmpty else {
-                logger.error("Invalid or empty URI")
+                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!
+            let media: VLCMedia
             if isNetwork {
-                logger.debug("Loading network file: \(uri)")
+                print("Loading network file: \(uri)")
                 media = VLCMedia(url: URL(string: uri)!)
             } else {
-                logger.debug("Loading local file: \(uri)")
+                print("Loading local file: \(uri)")
                 if uri.starts(with: "file://"), let url = URL(string: uri) {
                     media = VLCMedia(url: url)
                 } else {
@@ -269,84 +147,103 @@ class VlcPlayerView: ExpoView {
                 }
             }
 
-            logger.debug("Media options: \(mediaOptions)")
+            print("Debug: Media options: \(mediaOptions)")
             media.addOptions(mediaOptions)
 
-            self.vlc.player.media = media
+            self.mediaPlayer?.media = media
             self.setInitialExternalSubtitles()
             self.hasSource = true
             if autoplay {
-                logger.info("Playing...")
+                print("Playing...")
                 self.play()
-                self.vlc.player.time = VLCTime(number: NSNumber(value: self.startPosition * 1000))
             }
         }
     }
 
     @objc func setAudioTrack(_ trackIndex: Int) {
-        print("Setting audio track: \(trackIndex)")
-        let track = self.vlc.player.audioTracks[trackIndex]
-        track.isSelectedExclusively = true
+        self.mediaPlayer?.currentAudioTrackIndex = Int32(trackIndex)
     }
 
     @objc func getAudioTracks() -> [[String: Any]]? {
-        return vlc.player.audioTracks.enumerated().map {
-            return ["name": $1.trackName, "index": $0]
+        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) {
-        logger.debug("Attempting to set subtitle track to index: \(trackIndex)")
-        if trackIndex == -1 {
-            logger.debug("Disabling all subtitles")
-            for track in self.vlc.player.textTracks {
-                track.isSelected = false
-            }
-            return
-        }
-        let track = self.vlc.player.textTracks[trackIndex]
-        track.isSelectedExclusively = true;
-        logger.debug("Current subtitle track index after setting: \(track.trackName)")
+        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 {
-            logger.error("Invalid subtitle URL")
+            print("Error: Invalid subtitle URL")
             return
         }
-        let result = self.vlc.player.addPlaybackSlave(url, type: .subtitle, enforce: false)
-        if result == 0 {
+
+        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))
-            logger.debug("Subtitle added with result: \(result) \(internalName)")
         } else {
-            logger.debug("Failed to add subtitle")
+            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]]? {
-        if self.vlc.player.textTracks.count == 0 {
+        guard let mediaPlayer = self.mediaPlayer else {
             return nil
         }
 
-        logger.debug("Number of subtitle tracks: \(self.vlc.player.textTracks.count)")
+        let count = mediaPlayer.numberOfSubtitlesTracks
+        print("Debug: Number of subtitle tracks: \(count)")
 
-        let tracks = self.vlc.player.textTracks.enumerated().map { (index, track) in
-            if let customSubtitle = customSubtitles.first(where: {
-                $0.internalName == track.trackName
-            }) {
-                return ["name": customSubtitle.originalName, "index": index]
-            } else {
-                return ["name": track.trackName, "index": index]
+        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])
+                }
             }
         }
 
-       logger.debug("Subtitle tracks: \(tracks)")
-       return tracks
+        print("Debug: Subtitle tracks: \(tracks)")
+        return tracks
     }
 
     @objc func stop(completion: (() -> Void)? = nil) {
-        logger.debug("Stopping media...")
         guard !isStopping else {
             completion?()
             return
@@ -373,60 +270,47 @@ class VlcPlayerView: ExpoView {
 
     }
 
-    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)
-                }
-            }
-        }
-    }
-
     private func performStop(completion: (() -> Void)? = nil) {
         // Stop the media player
-        vlc.player.stop()
+        mediaPlayer?.stop()
 
         // Remove observer
         NotificationCenter.default.removeObserver(self)
 
         // Clear the video view
-        vlc.getPlayerView().removeFromSuperview()
+        videoView?.removeFromSuperview()
+        videoView = nil
+
+        // Release the media player
+        mediaPlayer?.delegate = nil
+        mediaPlayer = nil
 
         isStopping = false
         completion?()
     }
 
     private func updateVideoProgress() {
-        guard self.vlc.player.media != nil else { return }
+        guard let player = self.mediaPlayer else { return }
 
-        let currentTimeMs = self.vlc.player.time.intValue
-        let durationMs = self.vlc.player.media?.length.intValue ?? 0
+        let currentTimeMs = player.time.intValue
+        let durationMs = player.media?.length.intValue ?? 0
+        
 
-        logger.debug("Current time: \(currentTimeMs)")
-        self.onVideoProgress?([
-            "currentTime": currentTimeMs,
-            "duration": durationMs,
-        ])
-    }
-
-    private func updatePlayerState() {
-        let player = self.vlc.player
-        self.onVideoStateChange?([
-            "target": self.reactTag ?? NSNull(),
-            "currentTime": player.time.intValue,
-            "duration": player.media?.length.intValue ?? 0,
-            "error": false,
-            "isPlaying": player.isPlaying,
-            "isBuffering": !player.isPlaying && player.state == VLCMediaPlayerState.buffering,
-            "state": player.state.description,
-        ])
+        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,
+            ])
+        }
     }
 
     // MARK: - Expo Events
+
     @objc var onPlaybackStateChanged: RCTDirectEventBlock?
     @objc var onVideoLoadStart: RCTDirectEventBlock?
     @objc var onVideoStateChange: RCTDirectEventBlock?
@@ -438,37 +322,71 @@ class VlcPlayerView: ExpoView {
     // MARK: - Deinitialization
 
     deinit {
-        logger.debug("Deinitialization")
         performStop()
-        VLCManager.shared.listeners.removeAll()
     }
 }
 
-// MARK: - SimpleAppLifecycleListener
-extension VlcPlayerView: SimpleAppLifecycleListener {
-    func applicationDidEnterBackground() {
-        logger.debug("Entering background")
+extension VlcPlayerView: VLCMediaPlayerDelegate {
+    func mediaPlayerTimeChanged(_ aNotification: Notification) {
+        // self?.updateVideoProgress()
+        let timeNow = Date().timeIntervalSince1970
+        if timeNow - lastProgressCall >= 1 {
+            lastProgressCall = timeNow
+            updateVideoProgress()
+        }
     }
 
-    func applicationDidEnterForeground() {
-        logger.debug("Entering foreground, is player visible? \(self.vlc.getPlayerView().superview != nil)")
-        if !self.vlc.getPlayerView().isDescendant(of: self) {
-            logger.debug("Player view is missing. Adding back as subview")
-            self.addSubview(self.vlc.getPlayerView())
+    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"
         }
 
-        // Current solution to fixing black screen when re-entering application
-        if let videoTrack = self.vlc.player.videoTracks.first(where: { $0.isSelected == true }),
-            !self.vlc.isMediaPlaying()
+        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
         {
-            videoTrack.isSelected = false
-            videoTrack.isSelectedExclusively = true
-            self.vlc.player.play()
-            self.vlc.player.pause()
+            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 {
@@ -477,9 +395,10 @@ extension VLCMediaPlayerState {
         case .playing: return "Playing"
         case .paused: return "Paused"
         case .stopped: return "Stopped"
+        case .ended: return "Ended"
         case .error: return "Error"
-        case .stopping: return "Stopping"
+        case .esAdded: return "ESAdded"
         @unknown default: return "Unknown"
         }
     }
-}
+}