chore(deps): Update github/codeql-action action to v4.31.11

.github/workflows/ci-codeql.yml

@@ -27,13 +27,13 @@ jobs:
         uses: actions/checkout@8e8c483db84b4bee98b60c0593521ed34d9990e8 # v6.0.1
 
       - name: 🏁 Initialize CodeQL
-        uses: github/codeql-action/init@cdefb33c0f6224e58673d9004f47f7cb3e328b89 # v4.31.10
+        uses: github/codeql-action/init@19b2f06db2b6f5108140aeb04014ef02b648f789 # v4.31.11
         with:
           languages: ${{ matrix.language }}
           queries: +security-extended,security-and-quality
 
       - name: 🛠️ Autobuild
-        uses: github/codeql-action/autobuild@cdefb33c0f6224e58673d9004f47f7cb3e328b89 # v4.31.10
+        uses: github/codeql-action/autobuild@19b2f06db2b6f5108140aeb04014ef02b648f789 # v4.31.11
 
       - name: 🧪 Perform CodeQL Analysis
-        uses: github/codeql-action/analyze@cdefb33c0f6224e58673d9004f47f7cb3e328b89 # v4.31.10
+        uses: github/codeql-action/analyze@19b2f06db2b6f5108140aeb04014ef02b648f789 # v4.31.11

app/(auth)/player/direct-player.tsx

@@ -48,7 +48,6 @@ import { apiAtom, userAtom } from "@/providers/JellyfinProvider";
 import { OfflineModeProvider } from "@/providers/OfflineModeProvider";
 
 import { useSettings } from "@/utils/atoms/settings";
-import { getPrimaryImageUrl } from "@/utils/jellyfin/image/getPrimaryImageUrl";
 import { getStreamUrl } from "@/utils/jellyfin/media/getStreamUrl";
 import {
   getMpvAudioId,
@@ -505,31 +504,6 @@ export default function page() {
     return ticksToSeconds(getInitialPlaybackTicks());
   }, [getInitialPlaybackTicks]);
 
-  /** Prepare metadata for iOS native media controls (Control Center, Lock Screen) */
-  const nowPlayingMetadata = useMemo(() => {
-    if (!item || !api) return undefined;
-
-    const artworkUri = getPrimaryImageUrl({
-      api,
-      item,
-      quality: 90,
-      width: 500,
-    });
-
-    return {
-      title: item.Name || "",
-      artist:
-        item.Type === "Episode"
-          ? item.SeriesName || ""
-          : item.AlbumArtist || "",
-      albumTitle:
-        item.Type === "Episode" && item.SeasonName
-          ? item.SeasonName
-          : undefined,
-      artworkUri: artworkUri || undefined,
-    };
-  }, [item, api]);
-
   /** Build video source config for MPV */
   const videoSource = useMemo<MpvVideoSource | undefined>(() => {
     if (!stream?.url) return undefined;
@@ -958,7 +932,6 @@ export default function page() {
                 ref={videoRef}
                 source={videoSource}
                 style={{ width: "100%", height: "100%" }}
-                nowPlayingMetadata={nowPlayingMetadata}
                 onProgress={onProgress}
                 onPlaybackStateChange={onPlaybackStateChanged}
                 onLoad={() => setIsVideoLoaded(true)}

modules/mpv-player/android/src/main/java/expo/modules/mpvplayer/MpvPlayerModule.kt

@@ -43,12 +43,6 @@ class MpvPlayerModule : Module() {
                 view.loadVideo(config)
             }
 
-            // Now Playing metadata for media controls (iOS-only, no-op on Android)
-            // Android handles media session differently via MediaSessionCompat
-            Prop("nowPlayingMetadata") { _: MpvPlayerView, _: Map<String, String>? ->
-                // No-op on Android - media session integration would require MediaSessionCompat
-            }
-
             // Async function to play video
             AsyncFunction("play") { view: MpvPlayerView ->
                 view.play()

modules/mpv-player/ios/MPVLayerRenderer.swift

@@ -10,7 +10,6 @@ protocol MPVLayerRendererDelegate: AnyObject {
     func renderer(_ renderer: MPVLayerRenderer, didChangeLoading isLoading: Bool)
     func renderer(_ renderer: MPVLayerRenderer, didBecomeReadyToSeek: Bool)
     func renderer(_ renderer: MPVLayerRenderer, didBecomeTracksReady: Bool)
-    func renderer(_ renderer: MPVLayerRenderer, didSelectAudioOutput audioOutput: String)
 }
 
 /// MPV player using vo_avfoundation for video output.
@@ -348,8 +347,7 @@ final class MPVLayerRenderer {
             ("pause", MPV_FORMAT_FLAG),
             ("track-list/count", MPV_FORMAT_INT64),
             ("paused-for-cache", MPV_FORMAT_FLAG),
-            ("demuxer-cache-duration", MPV_FORMAT_DOUBLE),
-            ("current-ao", MPV_FORMAT_STRING)
+            ("demuxer-cache-duration", MPV_FORMAT_DOUBLE)
         ]
         for (name, format) in properties {
             mpv_observe_property(handle, 0, name, format)
@@ -554,15 +552,6 @@ final class MPVLayerRenderer {
                     self.delegate?.renderer(self, didBecomeTracksReady: true)
                 }
             }
-        case "current-ao":
-            // Audio output is now active - notify delegate
-            if let aoName = getStringProperty(handle: handle, name: name) {
-                print("[MPV] 🔊 Audio output selected: \(aoName)")
-                DispatchQueue.main.async { [weak self] in
-                    guard let self else { return }
-                    self.delegate?.renderer(self, didSelectAudioOutput: aoName)
-                }
-            }
         default:
             break
         }

modules/mpv-player/ios/MPVNowPlayingManager.swift

@@ -1,188 +0,0 @@
-import Foundation
-import MediaPlayer
-import UIKit
-import AVFoundation
-
-/// Simple manager for Now Playing info and remote commands.
-/// Stores all state internally and updates Now Playing when ready.
-class MPVNowPlayingManager {
-    static let shared = MPVNowPlayingManager()
-    
-    // State
-    private var title: String?
-    private var artist: String?
-    private var albumTitle: String?
-    private var cachedArtwork: MPMediaItemArtwork?
-    private var duration: TimeInterval = 0
-    private var position: TimeInterval = 0
-    private var isPlaying: Bool = false
-    private var isCommandsSetup = false
-    
-    private var artworkTask: URLSessionDataTask?
-    
-    private init() {}
-    
-    // MARK: - Audio Session
-    
-    func activateAudioSession() {
-        do {
-            let session = AVAudioSession.sharedInstance()
-            try session.setCategory(.playback, mode: .moviePlayback)
-            try session.setActive(true)
-            print("[NowPlaying] Audio session activated")
-        } catch {
-            print("[NowPlaying] Audio session error: \(error)")
-        }
-    }
-    
-    func deactivateAudioSession() {
-        do {
-            try AVAudioSession.sharedInstance().setActive(false, options: .notifyOthersOnDeactivation)
-            print("[NowPlaying] Audio session deactivated")
-        } catch {
-            print("[NowPlaying] Deactivation error: \(error)")
-        }
-    }
-    
-    // MARK: - Remote Commands
-    
-    func setupRemoteCommands(
-        playHandler: @escaping () -> Void,
-        pauseHandler: @escaping () -> Void,
-        toggleHandler: @escaping () -> Void,
-        seekHandler: @escaping (TimeInterval) -> Void,
-        skipForward: @escaping (TimeInterval) -> Void,
-        skipBackward: @escaping (TimeInterval) -> Void
-    ) {
-        guard !isCommandsSetup else { return }
-        isCommandsSetup = true
-        
-        DispatchQueue.main.async {
-            UIApplication.shared.beginReceivingRemoteControlEvents()
-        }
-        
-        let cc = MPRemoteCommandCenter.shared()
-        
-        cc.playCommand.isEnabled = true
-        cc.playCommand.addTarget { _ in playHandler(); return .success }
-        
-        cc.pauseCommand.isEnabled = true
-        cc.pauseCommand.addTarget { _ in pauseHandler(); return .success }
-        
-        cc.togglePlayPauseCommand.isEnabled = true
-        cc.togglePlayPauseCommand.addTarget { _ in toggleHandler(); return .success }
-        
-        cc.skipForwardCommand.isEnabled = true
-        cc.skipForwardCommand.preferredIntervals = [15]
-        cc.skipForwardCommand.addTarget { e in
-            if let ev = e as? MPSkipIntervalCommandEvent { skipForward(ev.interval) }
-            return .success
-        }
-        
-        cc.skipBackwardCommand.isEnabled = true
-        cc.skipBackwardCommand.preferredIntervals = [15]
-        cc.skipBackwardCommand.addTarget { e in
-            if let ev = e as? MPSkipIntervalCommandEvent { skipBackward(ev.interval) }
-            return .success
-        }
-        
-        cc.changePlaybackPositionCommand.isEnabled = true
-        cc.changePlaybackPositionCommand.addTarget { e in
-            if let ev = e as? MPChangePlaybackPositionCommandEvent { seekHandler(ev.positionTime) }
-            return .success
-        }
-        
-        print("[NowPlaying] Remote commands ready")
-    }
-    
-    func cleanupRemoteCommands() {
-        guard isCommandsSetup else { return }
-        
-        let cc = MPRemoteCommandCenter.shared()
-        cc.playCommand.removeTarget(nil)
-        cc.pauseCommand.removeTarget(nil)
-        cc.togglePlayPauseCommand.removeTarget(nil)
-        cc.skipForwardCommand.removeTarget(nil)
-        cc.skipBackwardCommand.removeTarget(nil)
-        cc.changePlaybackPositionCommand.removeTarget(nil)
-        
-        DispatchQueue.main.async {
-            UIApplication.shared.endReceivingRemoteControlEvents()
-        }
-        
-        isCommandsSetup = false
-        print("[NowPlaying] Remote commands cleaned up")
-    }
-    
-    // MARK: - State Updates (call these whenever data changes)
-    
-    /// Set metadata (title, artist, artwork URL)
-    func setMetadata(title: String?, artist: String?, albumTitle: String?, artworkUrl: String?) {
-        self.title = title
-        self.artist = artist
-        self.albumTitle = albumTitle
-        
-        print("[NowPlaying] Metadata: \(title ?? "nil")")
-        
-        // Load artwork async
-        artworkTask?.cancel()
-        if let urlString = artworkUrl, let url = URL(string: urlString) {
-            artworkTask = URLSession.shared.dataTask(with: url) { [weak self] data, _, _ in
-                if let data = data, let image = UIImage(data: data) {
-                    self?.cachedArtwork = MPMediaItemArtwork(boundsSize: image.size) { _ in image }
-                    print("[NowPlaying] Artwork loaded")
-                    DispatchQueue.main.async { self?.refresh() }
-                }
-            }
-            artworkTask?.resume()
-        }
-        
-        refresh()
-    }
-    
-    /// Update playback state (position, duration, playing)
-    func updatePlayback(position: TimeInterval, duration: TimeInterval, isPlaying: Bool) {
-        self.position = position
-        self.duration = duration
-        self.isPlaying = isPlaying
-        refresh()
-    }
-    
-    /// Clear everything
-    func clear() {
-        artworkTask?.cancel()
-        title = nil
-        artist = nil
-        albumTitle = nil
-        cachedArtwork = nil
-        duration = 0
-        position = 0
-        isPlaying = false
-        MPNowPlayingInfoCenter.default().nowPlayingInfo = nil
-        print("[NowPlaying] Cleared")
-    }
-    
-    // MARK: - Private
-    
-    /// Refresh Now Playing info if we have enough data
-    private func refresh() {
-        guard duration > 0 else {
-            print("[NowPlaying] refresh skipped - duration is 0")
-            return
-        }
-        
-        var info: [String: Any] = [
-            MPMediaItemPropertyPlaybackDuration: duration,
-            MPNowPlayingInfoPropertyElapsedPlaybackTime: position,
-            MPNowPlayingInfoPropertyPlaybackRate: isPlaying ? 1.0 : 0.0
-        ]
-        
-        if let title { info[MPMediaItemPropertyTitle] = title }
-        if let artist { info[MPMediaItemPropertyArtist] = artist }
-        if let albumTitle { info[MPMediaItemPropertyAlbumTitle] = albumTitle }
-        if let cachedArtwork { info[MPMediaItemPropertyArtwork] = cachedArtwork }
-        
-        MPNowPlayingInfoCenter.default().nowPlayingInfo = info
-        print("[NowPlaying] ✅ Set info: title=\(title ?? "nil"), dur=\(Int(duration))s, pos=\(Int(position))s, rate=\(isPlaying ? 1.0 : 0.0)")
-    }
-}

modules/mpv-player/ios/MpvPlayerModule.swift

@@ -43,21 +43,6 @@ public class MpvPlayerModule: Module {
         view.loadVideo(config: config)
       }
 
-      // Now Playing metadata for iOS Control Center and Lock Screen
-      Prop("nowPlayingMetadata") { (view: MpvPlayerView, metadata: [String: Any]?) in
-        guard let metadata = metadata else { return }
-        // Convert Any values to String, filtering out nil/null values
-        var stringMetadata: [String: String] = [:]
-        for (key, value) in metadata {
-          if let stringValue = value as? String {
-            stringMetadata[key] = stringValue
-          }
-        }
-        if !stringMetadata.isEmpty {
-          view.setNowPlayingMetadata(stringMetadata)
-        }
-      }
-
       // Async function to play video
       AsyncFunction("play") { (view: MpvPlayerView) in
         view.play()

modules/mpv-player/ios/MpvPlayerView.swift

@@ -1,7 +1,6 @@
 import AVFoundation
 import CoreMedia
 import ExpoModulesCore
-import MediaPlayer
 import UIKit
 
 /// Configuration for loading a video
@@ -42,6 +41,7 @@ class MpvPlayerView: ExpoView {
 	private var renderer: MPVLayerRenderer?
 	private var videoContainer: UIView!
 	private var pipController: PiPController?
+
 	let onLoad = EventDispatcher()
 	let onPlaybackStateChange = EventDispatcher()
 	let onProgress = EventDispatcher()
@@ -53,14 +53,11 @@ class MpvPlayerView: ExpoView {
 	private var cachedDuration: Double = 0
 	private var intendedPlayState: Bool = false
 	private var _isZoomedToFill: Bool = false
-	
-	// Reference to now playing manager
-	private let nowPlayingManager = MPVNowPlayingManager.shared
 
 	required init(appContext: AppContext? = nil) {
 		super.init(appContext: appContext)
-		setupNotifications()
 		setupView()
+		// Note: Decoder reset is handled automatically via KVO in MPVLayerRenderer
 	}
 
 	private func setupView() {
@@ -112,77 +109,6 @@ class MpvPlayerView: ExpoView {
 		CATransaction.commit()
 	}
 
-	// MARK: - Audio Session & Notifications
-
-	private func setupNotifications() {
-		// Handle audio session interruptions (e.g., incoming calls, other apps playing audio)
-		NotificationCenter.default.addObserver(
-			self, selector: #selector(handleAudioSessionInterruption),
-			name: AVAudioSession.interruptionNotification, object: nil)
-	}
-
-	@objc func handleAudioSessionInterruption(_ notification: Notification) {
-		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("[MPV] 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("[MPV] Audio session interruption ended - can resume")
-					// Don't auto-resume - let user manually resume playback
-				} else {
-					print("[MPV] Audio session interruption ended - should not resume")
-				}
-			}
-			
-		@unknown default:
-			break
-		}
-	}
-	
-	private func setupRemoteCommands() {
-		nowPlayingManager.setupRemoteCommands(
-			playHandler: { [weak self] in self?.play() },
-			pauseHandler: { [weak self] in self?.pause() },
-			toggleHandler: { [weak self] in
-				guard let self else { return }
-				if self.intendedPlayState { self.pause() } else { self.play() }
-			},
-			seekHandler: { [weak self] time in self?.seekTo(position: time) },
-			skipForward: { [weak self] interval in self?.seekBy(offset: interval) },
-			skipBackward: { [weak self] interval in self?.seekBy(offset: -interval) }
-		)
-	}
-
-	// MARK: - Now Playing Info
-
-	func setNowPlayingMetadata(_ metadata: [String: String]) {
-		print("[MPV] setNowPlayingMetadata: \(metadata["title"] ?? "nil")")
-		nowPlayingManager.setMetadata(
-			title: metadata["title"],
-			artist: metadata["artist"],
-			albumTitle: metadata["albumTitle"],
-			artworkUrl: metadata["artworkUri"]
-		)
-	}
-
-	private func clearNowPlayingInfo() {
-		nowPlayingManager.cleanupRemoteCommands()
-		nowPlayingManager.deactivateAudioSession()
-		nowPlayingManager.clear()
-	}
-
 	func loadVideo(config: VideoLoadConfig) {
 		// Skip reload if same URL is already playing
 		if currentURL == config.url {
@@ -223,7 +149,6 @@ class MpvPlayerView: ExpoView {
 
 	func play() {
 		intendedPlayState = true
-		setupRemoteCommands()
 		renderer?.play()
 		pipController?.setPlaybackRate(1.0)
 		pipController?.updatePlaybackState()
@@ -237,17 +162,10 @@ class MpvPlayerView: ExpoView {
 	}
 
 	func seekTo(position: Double) {
-		// Update cached position and Now Playing immediately for smooth Control Center feedback
-		cachedPosition = position
-		syncNowPlaying(isPlaying: !isPaused())
 		renderer?.seek(to: position)
 	}
 
 	func seekBy(offset: Double) {
-		// Update cached position and Now Playing immediately for smooth Control Center feedback
-		let newPosition = max(0, min(cachedPosition + offset, cachedDuration))
-		cachedPosition = newPosition
-		syncNowPlaying(isPlaying: !isPaused())
 		renderer?.seek(by: offset)
 	}
 
@@ -374,32 +292,23 @@ class MpvPlayerView: ExpoView {
 		pipController?.stopPictureInPicture()
 		renderer?.stop()
 		displayLayer.removeFromSuperlayer()
-		clearNowPlayingInfo()
-		NotificationCenter.default.removeObserver(self)
 	}
 }
 
 // MARK: - MPVLayerRendererDelegate
 
 extension MpvPlayerView: MPVLayerRendererDelegate {
-	
-	// MARK: - Single location for Now Playing updates
-	private func syncNowPlaying(isPlaying: Bool) {
-		print("[MPV] syncNowPlaying: pos=\(Int(cachedPosition))s, dur=\(Int(cachedDuration))s, playing=\(isPlaying)")
-		nowPlayingManager.updatePlayback(position: cachedPosition, duration: cachedDuration, isPlaying: isPlaying)
-	}
-	
 	func renderer(_: MPVLayerRenderer, didUpdatePosition position: Double, duration: Double, cacheSeconds: Double) {
 		cachedPosition = position
 		cachedDuration = duration
 		
 		DispatchQueue.main.async { [weak self] in
 			guard let self else { return }
-
+			// Update PiP current time for progress bar
 			if self.pipController?.isPictureInPictureActive == true {
 				self.pipController?.setCurrentTimeFromSeconds(position, duration: duration)
 			}
-
+			
 			self.onProgress([
 				"position": position,
 				"duration": duration,
@@ -412,10 +321,12 @@ extension MpvPlayerView: MPVLayerRendererDelegate {
 	func renderer(_: MPVLayerRenderer, didChangePause isPaused: Bool) {
 		DispatchQueue.main.async { [weak self] in
 			guard let self else { return }
+			// Don't update intendedPlayState here - it's only set by user actions (play/pause)
+			// This prevents PiP UI flicker during seeking
 			
-			print("[MPV] didChangePause: isPaused=\(isPaused), cachedDuration=\(self.cachedDuration)")
+			// Sync timebase rate with actual playback state
 			self.pipController?.setPlaybackRate(isPaused ? 0.0 : 1.0)
-			self.syncNowPlaying(isPlaying: !isPaused)
+			
 			self.onPlaybackStateChange([
 				"isPaused": isPaused,
 				"isPlaying": !isPaused,
@@ -447,13 +358,6 @@ extension MpvPlayerView: MPVLayerRendererDelegate {
 			self.onTracksReady([:])
 		}
 	}
-	
-	func renderer(_: MPVLayerRenderer, didSelectAudioOutput audioOutput: String) {
-		// Audio output is now active - this is the right time to activate audio session and set Now Playing
-		print("[MPV] Audio output ready (\(audioOutput)), activating audio session and syncing Now Playing")
-		nowPlayingManager.activateAudioSession()
-		syncNowPlaying(isPlaying: !isPaused())
-	}
 }
 
 // MARK: - PiPControllerDelegate

modules/mpv-player/src/MpvPlayer.types.ts

@@ -25,13 +25,6 @@ export type OnErrorEventPayload = {
 
 export type OnTracksReadyEventPayload = Record<string, never>;
 
-export type NowPlayingMetadata = {
-  title?: string;
-  artist?: string;
-  albumTitle?: string;
-  artworkUri?: string;
-};
-
 export type MpvPlayerModuleEvents = {
   onChange: (params: ChangeEventPayload) => void;
 };
@@ -55,8 +48,6 @@ export type VideoSource = {
 export type MpvPlayerViewProps = {
   source?: VideoSource;
   style?: StyleProp<ViewStyle>;
-  /** Metadata for iOS Control Center and Lock Screen now playing info */
-  nowPlayingMetadata?: NowPlayingMetadata;
   onLoad?: (event: { nativeEvent: OnLoadEventPayload }) => void;
   onPlaybackStateChange?: (event: {
     nativeEvent: OnPlaybackStateChangePayload;