react-native-nitro-player 1.4.4-alpha.0 → 1.5.0-alpha.0

package/android/src/main/java/com/margelo/nitro/nitroplayer/media/NitroCastOptionsProvider.kt

@@ -0,0 +1,30 @@
+package com.margelo.nitro.nitroplayer.media
+
+import android.content.Context
+import com.google.android.gms.cast.framework.CastOptions
+import com.google.android.gms.cast.framework.OptionsProvider
+import com.google.android.gms.cast.framework.SessionProvider
+
+/**
+ * Supplies [CastOptions] used to initialize the Cast `CastContext` singleton.
+ *
+ * Registered via the `com.google.android.gms.cast.framework.OPTIONS_PROVIDER_CLASS_NAME`
+ * manifest meta-data (declared in this library's AndroidManifest, merged into the
+ * host app). Apps that ship their own OptionsProvider (e.g. when also using
+ * react-native-google-cast) must override the meta-data with `tools:replace`.
+ *
+ * The receiver ID is read from [NitroCastConfig], so `Cast.configure(id)` can
+ * change it before Cast is first used.
+ */
+class NitroCastOptionsProvider : OptionsProvider {
+    override fun getCastOptions(context: Context): CastOptions =
+        CastOptions.Builder()
+            .setReceiverApplicationId(NitroCastConfig.effectiveReceiverId)
+            // Keep the local session alive when the app is backgrounded so
+            // playback control survives notification/lock-screen interaction.
+            .setResumeSavedSession(true)
+            .setEnableReconnectionService(true)
+            .build()
+
+    override fun getAdditionalSessionProviders(context: Context): List<SessionProvider>? = null
+}

package/android/src/main/java/com/margelo/nitro/nitroplayer/media/NitroMediaItemConverter.kt

@@ -0,0 +1,53 @@
+package com.margelo.nitro.nitroplayer.media
+
+import androidx.media3.cast.DefaultMediaItemConverter
+import androidx.media3.cast.MediaItemConverter
+import androidx.media3.common.MediaItem
+import androidx.media3.common.util.UnstableApi
+import com.google.android.gms.cast.MediaQueueItem
+
+/**
+ * [MediaItemConverter] for [androidx.media3.cast.CastPlayer].
+ *
+ * The library builds [MediaItem]s with a URI + metadata but **no MIME type**
+ * (local ExoPlayer infers it from the stream, and forcing one would risk picking
+ * the wrong extractor). The Cast SDK's [DefaultMediaItemConverter] however throws
+ * when the MIME type is missing, so this converter infers a sensible content type
+ * from the URL before delegating. Local playback is untouched — this only runs
+ * for items sent to a Cast device.
+ */
+@UnstableApi
+class NitroMediaItemConverter : MediaItemConverter {
+    private val delegate = DefaultMediaItemConverter()
+
+    override fun toMediaItem(mediaQueueItem: MediaQueueItem): MediaItem =
+        delegate.toMediaItem(mediaQueueItem)
+
+    override fun toMediaQueueItem(mediaItem: MediaItem): MediaQueueItem =
+        delegate.toMediaQueueItem(ensureMimeType(mediaItem))
+
+    private fun ensureMimeType(mediaItem: MediaItem): MediaItem {
+        val config = mediaItem.localConfiguration ?: return mediaItem
+        if (config.mimeType != null) return mediaItem
+        return mediaItem
+            .buildUpon()
+            .setMimeType(inferMimeType(config.uri.toString()))
+            .build()
+    }
+
+    /** Best-effort content type the Cast receiver can load; defaults to MP3 audio. */
+    private fun inferMimeType(url: String): String {
+        val path = url.substringBefore('?').substringBefore('#').lowercase()
+        return when {
+            path.endsWith(".m3u8") -> "application/x-mpegurl"
+            path.endsWith(".mpd") -> "application/dash+xml"
+            path.endsWith(".flac") -> "audio/flac"
+            path.endsWith(".wav") -> "audio/wav"
+            path.endsWith(".opus") -> "audio/opus"
+            path.endsWith(".ogg") -> "audio/ogg"
+            path.endsWith(".aac") -> "audio/aac"
+            path.endsWith(".m4a") || path.endsWith(".mp4") -> "audio/mp4"
+            else -> "audio/mpeg"
+        }
+    }
+}

package/android/src/main/java/com/margelo/nitro/nitroplayer/media/PlaybackService.kt

@@ -5,11 +5,13 @@ import android.os.Binder
 import android.os.Handler
 import android.os.IBinder
 import android.os.Looper
+import androidx.media3.cast.CastPlayer
 import androidx.media3.common.util.UnstableApi
 import androidx.media3.exoplayer.ExoPlayer
 import androidx.media3.session.DefaultMediaNotificationProvider
 import androidx.media3.session.MediaSession
 import androidx.media3.session.MediaSessionService
+import com.google.android.gms.cast.framework.CastContext
 import com.margelo.nitro.nitroplayer.core.NitroPlayerLogger
 import com.margelo.nitro.nitroplayer.core.TrackPlayerCore
 import com.margelo.nitro.nitroplayer.playlist.PlaylistManager
@@ -50,6 +52,9 @@ class NitroPlayerPlaybackService : MediaSessionService() {
     private var notificationProvider: DefaultMediaNotificationProvider? = null
     private val mainHandler = Handler(Looper.getMainLooper())
 
+    /** Owns the CastPlayer + Cast session lifecycle; null when Cast is unavailable. */
+    private var castSessionController: CastSessionController? = null
+
     @Volatile
     var trackPlayerCore: TrackPlayerCore? = null
 
@@ -59,6 +64,7 @@ class NitroPlayerPlaybackService : MediaSessionService() {
         val exoPlayer: ExoPlayer get() = player
         val session: MediaSession get() = mediaSession!!
         val handler: Handler get() = mainHandler
+        val castController: CastSessionController? get() = castSessionController
     }
 
     private val localBinder = lazy { LocalBinder() }
@@ -86,6 +92,31 @@ class NitroPlayerPlaybackService : MediaSessionService() {
         setMediaNotificationProvider(provider)
 
         addSession(mediaSession!!)
+
+        initCast()
+    }
+
+    /**
+     * Initialize Google Cast. Best-effort: when Google Play services or the Cast
+     * framework are unavailable (older devices, no Play services), the controller
+     * stays null and all Cast features become inert no-ops.
+     */
+    private fun initCast() {
+        try {
+            val castContext = CastContext.getSharedInstance(this)
+            val castPlayer = CastPlayer(castContext, NitroMediaItemConverter())
+            castSessionController =
+                CastSessionController(
+                    castContext = castContext,
+                    castPlayer = castPlayer,
+                    localPlayer = player,
+                    mediaSession = mediaSession!!,
+                    mainHandler = mainHandler,
+                )
+        } catch (e: Exception) {
+            NitroPlayerLogger.log("PlaybackService") { "Cast unavailable: ${e.message}" }
+            castSessionController = null
+        }
     }
 
     private fun applyNotificationSmallIcon() {
@@ -133,6 +164,8 @@ class NitroPlayerPlaybackService : MediaSessionService() {
         NitroPlayerLogger.log("PlaybackService") { "onDestroy" }
         if (instance === this) instance = null
         notificationProvider = null
+        castSessionController?.release()
+        castSessionController = null
         mediaSession?.release()
         mediaSession = null
         player.release()

package/ios/HybridCast.swift

@@ -0,0 +1,63 @@
+//
+//  HybridCast.swift
+//  NitroPlayer
+//
+//  Nitro module exposing the Google Cast control surface to JS. Actual playback
+//  routing to/from the Cast device lives in TrackPlayerCore (see TrackPlayerCast).
+//
+
+import Foundation
+import NitroModules
+
+final class HybridCast: HybridCastSpec {
+  private let core: TrackPlayerCore
+  private var listenerIds: [Int64] = []
+
+  override init() {
+    core = TrackPlayerCore.shared
+    super.init()
+  }
+
+  func configure(receiverApplicationId: String?) throws -> Promise<Void> {
+    Promise.async { self.core.castConfigure(receiverApplicationId: receiverApplicationId) }
+  }
+
+  func isCasting() throws -> Bool {
+    core.isCasting
+  }
+
+  func getCastState() throws -> CastState {
+    core.castGetState()
+  }
+
+  func getCastDeviceName() throws -> Variant_NullType_String {
+    if let name = core.castGetDeviceName() {
+      return .second(name)
+    }
+    return .first(NullType.null)
+  }
+
+  func showCastPicker() throws {
+    core.castShowPicker()
+  }
+
+  func endCastSession() throws -> Promise<Void> {
+    Promise.async { self.core.castEndSession() }
+  }
+
+  func onCastStateChange(callback: @escaping (CastState, Variant_NullType_String?) -> Void) throws {
+    // Replace any prior listener so JS reloads don't accumulate handlers.
+    for id in listenerIds { core.removeOnCastStateChangeListener(id: id) }
+    listenerIds.removeAll()
+
+    let id = core.addOnCastStateChangeListener { state, deviceName in
+      callback(state, deviceName.map { .second($0) })
+    }
+    listenerIds.append(id)
+  }
+
+  deinit {
+    for id in listenerIds { core.removeOnCastStateChangeListener(id: id) }
+    listenerIds.removeAll()
+  }
+}

package/ios/core/CastSessionManager.swift

@@ -0,0 +1,367 @@
+//
+//  CastSessionManager.swift
+//  NitroPlayer
+//
+//  Owns the Google Cast session lifecycle and remote media client, and bridges
+//  Cast events back into TrackPlayerCore. All GoogleCast usage is guarded by
+//  `#if canImport(GoogleCast)` so the library still builds when the SDK is not
+//  linked — in that case every method is an inert no-op and casting is disabled.
+//
+
+import Foundation
+import MediaPlayer
+
+#if canImport(GoogleCast)
+import GoogleCast
+#endif
+
+final class CastSessionManager: NSObject {
+  weak var core: TrackPlayerCore?
+
+  private var isConfigured = false
+  private var loadedTracks: [TrackItem] = []
+  private var lastCurrentTrackId: String?
+  // GoogleCast reads are main-thread-affine; Nitro sync getters run off-main, so
+  // serve them from a cache refreshed on the main thread by the Cast callbacks.
+  private var cachedState: CastState = .noDevicesAvailable
+  private var cachedDeviceName: String?
+  /// Last position reported by the receiver, used to resume locally on disconnect.
+  private(set) var lastKnownRemotePosition: Double = 0
+  private var progressTimer: Timer?
+
+  // MARK: - Configuration
+
+  func configure(receiverApplicationId: String?) {
+    #if canImport(GoogleCast)
+    DispatchQueue.main.async { [weak self] in
+      guard let self, !self.isConfigured else { return }
+      self.isConfigured = true
+
+      let appId = receiverApplicationId ?? kGCKDefaultMediaReceiverApplicationID
+      let criteria = GCKDiscoveryCriteria(applicationID: appId)
+      let options = GCKCastOptions(discoveryCriteria: criteria)
+      options.suspendSessionsWhenBackgrounded = false
+      GCKCastContext.setSharedInstanceWith(options)
+
+      let context = GCKCastContext.sharedInstance()
+      context.sessionManager.add(self)
+      NotificationCenter.default.addObserver(
+        self,
+        selector: #selector(self.castStateDidChange),
+        name: NSNotification.Name.gckCastStateDidChange,
+        object: nil
+      )
+      self.emitCastState()
+    }
+    #endif
+  }
+
+  // MARK: - State
+
+  var isCasting: Bool {
+    #if canImport(GoogleCast)
+    return isConfigured && GCKCastContext.sharedInstance().sessionManager.currentCastSession != nil
+    #else
+    return false
+    #endif
+  }
+
+  /// Cached — safe to call from the JS thread.
+  func currentCastState() -> CastState { cachedState }
+
+  /// Cached — safe to call from the JS thread.
+  func deviceName() -> String? { cachedDeviceName }
+
+  // MARK: - UI / session control
+
+  func showCastPicker() {
+    #if canImport(GoogleCast)
+    DispatchQueue.main.async {
+      guard self.isConfigured else { return }
+      GCKCastContext.sharedInstance().presentCastDialog()
+    }
+    #endif
+  }
+
+  func endSession() {
+    #if canImport(GoogleCast)
+    DispatchQueue.main.async {
+      guard self.isConfigured else { return }
+      GCKCastContext.sharedInstance().sessionManager.endSessionAndStopCasting(true)
+    }
+    #endif
+  }
+
+  // MARK: - Transport (all dispatched to main — GoogleCast is main-thread only)
+
+  func play() {
+    #if canImport(GoogleCast)
+    onMain { self.remoteClient?.play() }
+    #endif
+  }
+
+  func pause() {
+    #if canImport(GoogleCast)
+    onMain { self.remoteClient?.pause() }
+    #endif
+  }
+
+  func seek(to position: Double) {
+    #if canImport(GoogleCast)
+    onMain {
+      let options = GCKMediaSeekOptions()
+      options.interval = position
+      self.remoteClient?.seek(with: options)
+    }
+    #endif
+  }
+
+  func skipToNext() {
+    #if canImport(GoogleCast)
+    onMain { self.remoteClient?.queueNextItem() }
+    #endif
+  }
+
+  func skipToPrevious() {
+    #if canImport(GoogleCast)
+    onMain { self.remoteClient?.queuePreviousItem() }
+    #endif
+  }
+
+  func setVolume(_ volume0to1: Float) {
+    #if canImport(GoogleCast)
+    onMain { self.remoteClient?.setStreamVolume(volume0to1) }
+    #endif
+  }
+
+  func setPlaybackRate(_ rate: Float) {
+    #if canImport(GoogleCast)
+    onMain { self.remoteClient?.setPlaybackRate(rate) }
+    #endif
+  }
+
+  func jump(toQueueIndex index: Int) {
+    #if canImport(GoogleCast)
+    onMain {
+      guard let client = self.remoteClient,
+            let status = client.mediaStatus,
+            index >= 0, index < Int(status.queueItemCount) else { return }
+      if let item = status.queueItem(at: UInt(index)) {
+        client.queueJumpToItem(withID: item.itemID)
+      }
+    }
+    #endif
+  }
+
+  // MARK: - Queue loading
+
+  func loadQueue(tracks: [TrackItem], startIndex: Int, position: Double, autoplay: Bool) {
+    #if canImport(GoogleCast)
+    onMain {
+      guard let client = self.remoteClient, !tracks.isEmpty else { return }
+      self.loadedTracks = tracks
+      let items = tracks.compactMap { self.makeQueueItem(for: $0, autoplay: autoplay) }
+      guard !items.isEmpty else { return }
+
+      let options = GCKMediaQueueLoadOptions()
+      options.startIndex = UInt(max(0, min(startIndex, items.count - 1)))
+      options.playPosition = position.isFinite ? position : 0
+      options.repeatMode = .off
+      client.queueLoad(items, with: options)
+    }
+    #endif
+  }
+
+  // MARK: - Private helpers
+
+  private func onMain(_ block: @escaping () -> Void) {
+    if Thread.isMainThread { block() } else { DispatchQueue.main.async(execute: block) }
+  }
+
+  #if canImport(GoogleCast)
+  private var remoteClient: GCKRemoteMediaClient? {
+    guard isConfigured else { return nil }
+    return GCKCastContext.sharedInstance().sessionManager.currentCastSession?.remoteMediaClient
+  }
+
+  private func makeQueueItem(for track: TrackItem, autoplay: Bool) -> GCKMediaQueueItem? {
+    let urlString = DownloadManagerCore.shared.getEffectiveUrl(track: track)
+    guard let contentURL = URL(string: urlString) else { return nil }
+
+    let metadata = GCKMediaMetadata(metadataType: .musicTrack)
+    metadata.setString(track.title, forKey: kGCKMetadataKeyTitle)
+    metadata.setString(track.artist, forKey: kGCKMetadataKeyArtist)
+    metadata.setString(track.album, forKey: kGCKMetadataKeyAlbumTitle)
+    if let artwork = track.artwork, case let .second(art) = artwork, let artURL = URL(string: art) {
+      metadata.addImage(GCKImage(url: artURL, width: 0, height: 0))
+    }
+
+    let infoBuilder = GCKMediaInformationBuilder(contentURL: contentURL)
+    infoBuilder.streamType = .buffered
+    infoBuilder.contentType = inferMimeType(urlString)
+    infoBuilder.metadata = metadata
+    infoBuilder.customData = ["trackId": track.id]
+
+    let itemBuilder = GCKMediaQueueItemBuilder()
+    itemBuilder.mediaInformation = infoBuilder.build()
+    itemBuilder.autoplay = autoplay
+    itemBuilder.preloadTime = 5
+    return itemBuilder.build()
+  }
+
+  private func inferMimeType(_ url: String) -> String {
+    let path = url.components(separatedBy: "?").first?.lowercased() ?? url.lowercased()
+    if path.hasSuffix(".m3u8") { return "application/x-mpegurl" }
+    if path.hasSuffix(".mpd") { return "application/dash+xml" }
+    if path.hasSuffix(".flac") { return "audio/flac" }
+    if path.hasSuffix(".wav") { return "audio/wav" }
+    if path.hasSuffix(".opus") { return "audio/opus" }
+    if path.hasSuffix(".ogg") { return "audio/ogg" }
+    if path.hasSuffix(".aac") { return "audio/aac" }
+    if path.hasSuffix(".m4a") || path.hasSuffix(".mp4") { return "audio/mp4" }
+    return "audio/mpeg"
+  }
+
+  private func startProgressTimer() {
+    onMain {
+      self.progressTimer?.invalidate()
+      self.progressTimer = Timer.scheduledTimer(withTimeInterval: 1.0, repeats: true) { [weak self] _ in
+        self?.tickProgress()
+      }
+    }
+  }
+
+  private func stopProgressTimer() {
+    onMain {
+      self.progressTimer?.invalidate()
+      self.progressTimer = nil
+    }
+  }
+
+  private func tickProgress() {
+    guard let client = remoteClient else { return }
+    let position = client.approximateStreamPosition()
+    let duration = client.mediaStatus?.mediaInformation?.streamDuration ?? 0
+    let safeDuration = (duration.isFinite && duration > 0) ? duration : 0
+    if position.isFinite { lastKnownRemotePosition = position }
+    core?.emitCastProgress(position.isFinite ? position : 0, safeDuration)
+    updateNowPlaying(position: position, duration: safeDuration)
+  }
+
+  /// Resolve the track currently playing on the receiver from its custom data.
+  private func currentRemoteTrack(_ status: GCKMediaStatus?) -> TrackItem? {
+    guard let status else { return nil }
+    let item = status.queueItem(withItemID: status.currentItemID)
+    let info = item?.mediaInformation ?? status.mediaInformation
+    if let customData = info?.customData as? [String: Any],
+       let trackId = customData["trackId"] as? String {
+      return loadedTracks.first { $0.id == trackId }
+    }
+    if let url = info?.contentURL?.absoluteString {
+      return loadedTracks.first { DownloadManagerCore.shared.getEffectiveUrl(track: $0) == url }
+    }
+    return nil
+  }
+
+  private func mapPlayerState(_ state: GCKMediaPlayerState) -> TrackPlayerState {
+    switch state {
+    case .playing: return .playing
+    case .paused: return .paused
+    case .buffering, .loading: return .buffering
+    case .idle: return .stopped
+    default: return .paused
+    }
+  }
+
+  private func updateNowPlaying(position: Double, duration: Double) {
+    guard let track = lastCurrentTrackId.flatMap({ id in loadedTracks.first { $0.id == id } }) else { return }
+    var info = MPNowPlayingInfoCenter.default().nowPlayingInfo ?? [:]
+    info[MPMediaItemPropertyTitle] = track.title
+    info[MPMediaItemPropertyArtist] = track.artist
+    info[MPMediaItemPropertyAlbumTitle] = track.album
+    if duration > 0 { info[MPMediaItemPropertyPlaybackDuration] = duration }
+    if position.isFinite { info[MPNowPlayingInfoPropertyElapsedPlaybackTime] = position }
+    info[MPNowPlayingInfoPropertyPlaybackRate] = (remoteClient?.mediaStatus?.playerState == .playing) ? 1.0 : 0.0
+    MPNowPlayingInfoCenter.default().nowPlayingInfo = info
+  }
+  #endif
+
+  @objc private func castStateDidChange() {
+    emitCastState()
+  }
+
+  /// Refreshes the cache from live Cast state and notifies listeners. Callers must be on the main thread.
+  private func emitCastState() {
+    refreshCacheOnMain()
+    core?.notifyCastStateChangeListeners(cachedState, cachedDeviceName)
+  }
+
+  /// Re-read live Cast state into the cache. MUST be called on the main thread.
+  private func refreshCacheOnMain() {
+    #if canImport(GoogleCast)
+    guard isConfigured else {
+      cachedState = .noDevicesAvailable
+      cachedDeviceName = nil
+      return
+    }
+    switch GCKCastContext.sharedInstance().castState {
+    case .noDevicesAvailable: cachedState = .noDevicesAvailable
+    case .notConnected: cachedState = .notConnected
+    case .connecting: cachedState = .connecting
+    case .connected: cachedState = .connected
+    @unknown default: cachedState = .notConnected
+    }
+    cachedDeviceName = GCKCastContext.sharedInstance().sessionManager.currentCastSession?.device.friendlyName
+    #endif
+  }
+}
+
+#if canImport(GoogleCast)
+// MARK: - GCKSessionManagerListener
+
+extension CastSessionManager: GCKSessionManagerListener {
+  func sessionManager(_ sessionManager: GCKSessionManager, didStart session: GCKSession) {
+    handleSessionStarted(session)
+  }
+
+  func sessionManager(_ sessionManager: GCKSessionManager, didResumeSession session: GCKSession) {
+    handleSessionStarted(session)
+  }
+
+  func sessionManager(_ sessionManager: GCKSessionManager, willEnd session: GCKSession) {
+    (session as? GCKCastSession)?.remoteMediaClient?.remove(self)
+  }
+
+  func sessionManager(_ sessionManager: GCKSessionManager, didEnd session: GCKSession, withError error: Error?) {
+    stopProgressTimer()
+    lastCurrentTrackId = nil
+    core?.handleCastDisconnected()
+    emitCastState()
+  }
+
+  private func handleSessionStarted(_ session: GCKSession) {
+    (session as? GCKCastSession)?.remoteMediaClient?.add(self)
+    startProgressTimer()
+    core?.handleCastConnected()
+    emitCastState()
+  }
+}
+
+// MARK: - GCKRemoteMediaClientListener
+
+extension CastSessionManager: GCKRemoteMediaClientListener {
+  func remoteMediaClient(_ client: GCKRemoteMediaClient, didUpdate mediaStatus: GCKMediaStatus?) {
+    guard let core else { return }
+
+    // Track change
+    if let track = currentRemoteTrack(mediaStatus), track.id != lastCurrentTrackId {
+      lastCurrentTrackId = track.id
+      core.emitCastTrackChange(track)
+    }
+
+    // Playback state
+    let state = mapPlayerState(mediaStatus?.playerState ?? .unknown)
+    core.emitCastPlaybackState(state)
+  }
+}
+#endif

package/ios/core/TrackPlayerCast.swift

@@ -0,0 +1,109 @@
+//
+//  TrackPlayerCast.swift
+//  NitroPlayer
+//
+//  Google Cast backend integration for TrackPlayerCore.
+//
+//  Casting is modelled as routing: while `isCasting` is true, the public
+//  playback methods forward to the CastSessionManager (remote device) instead of
+//  the local AVQueuePlayer, the local player is paused, and the queue is mirrored
+//  to the receiver. The same queue model (currentTracks / temp queues) stays the
+//  single source of truth, so disconnect can restore local playback seamlessly.
+//
+
+import AVFoundation
+import Foundation
+
+extension TrackPlayerCore {
+
+  // MARK: - Session lifecycle (called by CastSessionManager)
+
+  /// A Cast session became active — transfer current playback to the device.
+  func handleCastConnected() {
+    playerQueue.async { [weak self] in
+      guard let self else { return }
+      let wasPlaying = (self.player?.rate ?? 0) > 0 || self.intendedToPlay
+      let rawPosition = self.player?.currentTime().seconds ?? 0
+      let position = rawPosition.isFinite ? rawPosition : 0
+
+      self.isCasting = true
+      self.player?.pause() // silence local output — audio now comes from the device
+
+      self.loadCastQueue(autoplay: wasPlaying, position: position)
+    }
+  }
+
+  /// The Cast session ended — rebuild local playback at the last remote position.
+  func handleCastDisconnected() {
+    playerQueue.async { [weak self] in
+      guard let self else { return }
+      guard self.isCasting else { return }
+      self.isCasting = false
+
+      let resumePosition = self.castManager?.lastKnownRemotePosition ?? 0
+      let index = self.currentTrackIndex
+      guard index >= 0 && index < self.currentTracks.count else { return }
+
+      _ = self.rebuildQueueFromPlaylistIndex(index: index)
+      if resumePosition.isFinite && resumePosition > 0 {
+        let time = CMTime(seconds: resumePosition, preferredTimescale: CMTimeScale(NSEC_PER_SEC))
+        self.player?.seek(to: time)
+      }
+      if self.intendedToPlay {
+        self.player?.rate = Float(self.currentPlaybackSpeed)
+      }
+    }
+  }
+
+  /// Mirror the current effective queue to the Cast device, starting at the current track.
+  /// Must be called on `playerQueue`.
+  func loadCastQueue(autoplay: Bool, position: Double) {
+    let queue = getActualQueueInternal()
+    guard !queue.isEmpty else { return }
+    let current = getCurrentTrack()
+    let startIndex = current
+      .flatMap { c in queue.firstIndex(where: { $0.id == c.id }) }
+      ?? max(0, currentTrackIndex)
+    castManager?.loadQueue(tracks: queue, startIndex: startIndex, position: position, autoplay: autoplay)
+  }
+
+  // MARK: - Emit (cast-derived events → JS listeners)
+  // These bypass getStateInternal()/notify* which read the (paused) local player.
+
+  func emitCastTrackChange(_ track: TrackItem) {
+    if let idx = currentTracks.firstIndex(where: { $0.id == track.id }) {
+      currentTrackIndex = idx
+      currentTemporaryType = .none
+    }
+    onChangeTrackListeners.forEach { $0(track, .skip) }
+  }
+
+  func emitCastPlaybackState(_ state: TrackPlayerState) {
+    onPlaybackStateChangeListeners.forEach { $0(state, nil) }
+  }
+
+  func emitCastProgress(_ position: Double, _ duration: Double) {
+    onProgressListeners.forEach { $0(position, duration, nil) }
+  }
+
+  func notifyCastStateChangeListeners(_ state: CastState, _ deviceName: String?) {
+    onCastStateChangeListeners.forEach { $0(state, deviceName) }
+  }
+
+  // MARK: - Accessors (used by HybridCast)
+
+  func castConfigure(receiverApplicationId: String?) {
+    castManager?.configure(receiverApplicationId: receiverApplicationId)
+  }
+
+  func castGetState() -> CastState {
+    if isCasting { return .connected }
+    return castManager?.currentCastState() ?? .noDevicesAvailable
+  }
+
+  func castGetDeviceName() -> String? { castManager?.deviceName() }
+
+  func castShowPicker() { castManager?.showCastPicker() }
+
+  func castEndSession() { castManager?.endSession() }
+}