feat: Re-add native apple controls for mpv (#1411)

modules/mpv-player/ios/MPVNowPlayingManager.swift

@@ -0,0 +1,188 @@
+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)")
+    }
+}