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

package/README.md

@@ -677,7 +677,9 @@ Cast requires native configuration in your **app** (not just the library).
 <key>NSBonjourServices</key>
 <array>
   <string>_googlecast._tcp</string>
-  <!-- If using a custom receiver, also add _<RECEIVER_APP_ID>._googlecast._tcp -->
+  <!-- Receiver-specific service. Use _CC1AD845._googlecast._tcp for the Default
+       Media Receiver, or _<YOUR_RECEIVER_APP_ID>._googlecast._tcp for a custom one. -->
+  <string>_CC1AD845._googlecast._tcp</string>
 </array>
 <!-- Only if you use Cast guest mode (full SDK): -->
 <key>NSBluetoothAlwaysUsageDescription</key>

package/android/src/main/java/com/margelo/nitro/nitroplayer/core/ExoPlayerCore.kt

@@ -80,6 +80,8 @@ class ExoPlayerCore(
         }
     val currentMediaItem: MediaItem? get() = player.currentMediaItem
     val currentMediaItemIndex: Int get() = player.currentMediaItemIndex
+
+    fun getMediaItemAt(index: Int): MediaItem = player.getMediaItemAt(index)
     val currentPosition: Long get() = player.currentPosition
     val duration: Long get() = player.duration
     val mediaItemCount: Int get() = player.mediaItemCount

package/android/src/main/java/com/margelo/nitro/nitroplayer/core/TrackPlayerCast.kt

@@ -3,9 +3,9 @@
 package com.margelo.nitro.nitroplayer.core
 
 import android.app.Activity
-import androidx.media3.common.MediaItem
 import androidx.media3.common.Player
 import com.margelo.nitro.nitroplayer.CastState
+import com.margelo.nitro.nitroplayer.TrackItem
 import com.margelo.nitro.nitroplayer.media.NitroCastConfig
 
 /**
@@ -21,35 +21,91 @@ import com.margelo.nitro.nitroplayer.media.NitroCastConfig
  */
 
 // ── Backend switching ──────────────────────────────────────────────────────
+// The queue is rebuilt for the target backend (not item-copied): cast needs remote URLs, local prefers download paths.
 
 internal fun TrackPlayerCore.switchToCastPlayer() {
     val controller = castSessionController ?: return
-    switchToPlayer(controller.castPlayer)
-    isCastingField = true
+    if (!isExoInitialized) return
+    val local = exo.player
+    if (local === controller.castPlayer) return
+
+    // Capture context BEFORE swapping — the queue helpers read `exo`, and the cast timeline is still empty.
+    val currentId = local.currentMediaItem?.mediaId?.let { extractTrackId(it) }
+    val currentTrack = getCurrentTrack() ?: currentTracks.getOrNull(currentTrackIndex)
+    val upcoming = buildUpcomingQueueTracks(currentId)
+    val positionMs = local.currentPosition.coerceAtLeast(0L)
+    val wasPlaying = local.playWhenReady
+    val repeat = local.repeatMode
+
+    playerListener?.let { local.removeListener(it) }
+    local.playWhenReady = false // silence local output — audio now comes from the device
+
+    isCastingField = true // before building items so makeMediaItem picks remote URLs
+    exo = ExoPlayerCore(controller.castPlayer)
+    playerListener?.let { controller.castPlayer.addListener(it) }
+    setMediaSessionPlayer(controller.castPlayer)
+
+    val castList = ArrayList<TrackItem>()
+    currentTrack?.let { castList.add(it) }
+    castList.addAll(upcoming)
+    val playable = castableUpcoming(castList)
+
+    if (playable.isNotEmpty()) {
+        lastCastWaitTrackId = null
+        val items = playable.map { makeMediaItem(it, mediaIdFor(it)) }
+        // Resume mid-track only when the receiver starts on the locally playing track.
+        val resumeFromCurrent = currentTrack != null && playable.first().id == currentTrack.id
+        controller.castPlayer.setMediaItems(items, 0, if (resumeFromCurrent) positionMs else 0L)
+        controller.castPlayer.repeatMode = repeat
+        controller.castPlayer.playWhenReady = wasPlaying
+        controller.castPlayer.prepare()
+    } else {
+        // Nothing castable yet (lazy queue) — request URLs; updateTracks will load.
+        checkUpcomingTracksForUrls(lookaheadCount)
+    }
+
     notifyCastStateChange(CastState.CONNECTED, controller.currentDeviceName())
 }
 
 internal fun TrackPlayerCore.switchToLocalPlayer() {
     val controller = castSessionController ?: return
-    switchToPlayer(controller.localPlayer)
-    isCastingField = false
-    notifyCastStateChange(controller.getCastState(), controller.currentDeviceName())
-}
-
-private fun TrackPlayerCore.switchToPlayer(target: Player) {
     if (!isExoInitialized) return
-    val current = exo.player
-    if (current === target) return
-
-    // Move listener, queue and position from the current player to the target,
-    // then make the target authoritative for the MediaSession & notification.
-    playerListener?.let { current.removeListener(it) }
-    transferPlaybackState(current, target)
-    current.playWhenReady = false // silence the player we're leaving
+    val cast = exo.player
+    if (cast === controller.localPlayer) return
+
+    // Capture context before swapping (the cast timeline empties once the session ends).
+    val currentId = cast.currentMediaItem?.mediaId?.let { extractTrackId(it) }
+    val currentTrack = getCurrentTrack() ?: currentTracks.getOrNull(currentTrackIndex)
+    val upcoming = buildUpcomingQueueTracks(currentId)
+    val positionMs = cast.currentPosition.coerceAtLeast(0L)
+    val wasPlaying = cast.playWhenReady
+    val repeat = cast.repeatMode
+
+    playerListener?.let { cast.removeListener(it) }
+    cast.playWhenReady = false
+
+    isCastingField = false // before building items so makeMediaItem restores download paths
+    lastCastWaitTrackId = null
+    exo = ExoPlayerCore(controller.localPlayer)
+    playerListener?.let { controller.localPlayer.addListener(it) }
+    setMediaSessionPlayer(controller.localPlayer)
+
+    val localList = ArrayList<TrackItem>()
+    currentTrack?.let { localList.add(it) }
+    localList.addAll(upcoming)
+
+    if (localList.isNotEmpty()) {
+        val items = localList.map { makeMediaItem(it, mediaIdFor(it)) }
+        controller.localPlayer.setMediaItems(items, 0, positionMs)
+        controller.localPlayer.repeatMode = repeat
+        controller.localPlayer.playWhenReady = wasPlaying
+        controller.localPlayer.prepare()
+    }
 
-    exo = ExoPlayerCore(target)
-    playerListener?.let { target.addListener(it) }
+    notifyCastStateChange(controller.getCastState(), controller.currentDeviceName())
+}
 
+private fun TrackPlayerCore.setMediaSessionPlayer(target: Player) {
     try {
         castSessionController?.let { it.mediaSession.player = target }
     } catch (e: Exception) {
@@ -57,24 +113,6 @@ private fun TrackPlayerCore.switchToPlayer(target: Player) {
     }
 }
 
-/** Copy the queue, index, position, repeat mode and play-when-ready from one player to another. */
-private fun transferPlaybackState(
-    from: Player,
-    to: Player,
-) {
-    val count = from.mediaItemCount
-    if (count == 0) return
-    val items = ArrayList<MediaItem>(count)
-    for (i in 0 until count) items.add(from.getMediaItemAt(i))
-    val index = from.currentMediaItemIndex.coerceAtLeast(0)
-    val position = if (from.currentPosition >= 0) from.currentPosition else 0L
-
-    to.setMediaItems(items, index, position)
-    to.repeatMode = from.repeatMode
-    to.playWhenReady = from.playWhenReady
-    to.prepare()
-}
-
 // ── Notifications ──────────────────────────────────────────────────────────
 
 internal fun TrackPlayerCore.notifyCastStateChange(

package/android/src/main/java/com/margelo/nitro/nitroplayer/core/TrackPlayerCore.kt

@@ -100,6 +100,9 @@ class TrackPlayerCore private constructor(
     /** True while the active backend is the CastPlayer (audio routed to a remote device). */
     @Volatile internal var isCastingField: Boolean = false
 
+    /** Last track announced from a cast "waiting for URL" state — dedups onChangeTrack across updateTracks re-entries. */
+    internal var lastCastWaitTrackId: String? = null
+
     // ── Progress & playlist-update runnables ───────────────────────────────
     internal val progressUpdateRunnable =
         object : Runnable {

package/android/src/main/java/com/margelo/nitro/nitroplayer/core/TrackPlayerQueueBuild.kt

@@ -6,6 +6,7 @@ import android.net.Uri
 import androidx.media3.common.MediaItem
 import androidx.media3.common.MediaMetadata
 import androidx.media3.common.Player
+import com.margelo.nitro.nitroplayer.Reason
 import com.margelo.nitro.nitroplayer.TrackItem
 
 /**
@@ -15,17 +16,63 @@ import com.margelo.nitro.nitroplayer.TrackItem
  * when jumping to a specific index.
  */
 
+// ── Cast-safety helpers ────────────────────────────────────────────────────
+
+/** A track the Cast receiver can actually load: non-empty remote (non-local) URL. */
+internal fun TrackPlayerCore.isTrackCastable(track: TrackItem): Boolean =
+    track.url.isNotEmpty() &&
+        !track.url.startsWith("/") &&
+        !track.url.startsWith("file:")
+
+/** Receiver-safe run: keeps castable tracks, skips local-only ones, stops at the first lazy (empty-URL) track whose resolution is pending — receivers auto-skip failed loads instead of waiting like ExoPlayer. */
+internal fun TrackPlayerCore.castableUpcoming(tracks: List<TrackItem>): List<TrackItem> {
+    val result = ArrayList<TrackItem>(tracks.size)
+    for (track in tracks) {
+        when {
+            isTrackCastable(track) -> result.add(track)
+            track.url.isEmpty() -> break
+            // local-only → skip and keep scanning
+        }
+    }
+    return result
+}
+
+internal fun TrackPlayerCore.mediaIdFor(track: TrackItem): String {
+    val playlistId = currentPlaylistId ?: ""
+    return if (playlistId.isNotEmpty()) "$playlistId:${track.id}" else track.id
+}
+
 // ── Full rebuild (jump to index) ───────────────────────────────────────────
 
 internal fun TrackPlayerCore.rebuildQueueAndPlayFromIndex(index: Int) {
     if (!isExoInitialized) return
     if (index < 0 || index >= currentTracks.size) return
 
-    val playlistId = currentPlaylistId ?: ""
+    if (isCastingField) {
+        currentTrackIndex = index
+        val target = currentTracks[index]
+        val castTracks = castableUpcoming(currentTracks.subList(index, currentTracks.size))
+        if (castTracks.isEmpty()) {
+            // Lazy target — silence the receiver and wait for updateTracks to reload (dedup so re-entries don't spam JS).
+            if (exo.mediaItemCount > 0) exo.clearMediaItems()
+            if (lastCastWaitTrackId != target.id) {
+                lastCastWaitTrackId = target.id
+                notifyTrackChange(target, Reason.SKIP)
+            }
+            checkUpcomingTracksForUrls(lookaheadCount)
+            return
+        }
+        lastCastWaitTrackId = null
+        // Single atomic queueLoad — no separate clear (each queue op is a receiver RPC).
+        exo.setMediaItems(castTracks.map { makeMediaItem(it, mediaIdFor(it)) }, true)
+        exo.prepare()
+        checkUpcomingTracksForUrls(lookaheadCount)
+        return
+    }
+
     val mediaItems =
         currentTracks.subList(index, currentTracks.size).map { track ->
-            val mediaId = if (playlistId.isNotEmpty()) "$playlistId:${track.id}" else track.id
-            makeMediaItem(track, mediaId)
+            makeMediaItem(track, mediaIdFor(track))
         }
 
     currentTrackIndex = index
@@ -63,8 +110,38 @@ internal fun TrackPlayerCore.rebuildQueueFromCurrentPosition() {
         }
     }
 
-    val newQueueTracks = ArrayList<TrackItem>(playNextStack.size + upNextQueue.size + currentTracks.size)
     val currentId = exo.currentMediaItem?.mediaId?.let { extractTrackId(it) }
+    var newQueueTracks: List<TrackItem> = buildUpcomingQueueTracks(currentId)
+
+    if (isCastingField) {
+        newQueueTracks = castableUpcoming(newQueueTracks)
+
+        // Every queue edit is a receiver RPC — skip the rebuild when the remote queue already matches.
+        val itemCount = exo.mediaItemCount
+        if (itemCount - currentIndex - 1 == newQueueTracks.size) {
+            var inSync = true
+            for (i in newQueueTracks.indices) {
+                val existingId = extractTrackId(exo.getMediaItemAt(currentIndex + 1 + i).mediaId)
+                if (existingId != newQueueTracks[i].id) {
+                    inSync = false
+                    break
+                }
+            }
+            if (inSync) return
+        }
+    }
+
+    val newMediaItems = newQueueTracks.map { makeMediaItem(it, mediaIdFor(it)) }
+
+    if (exo.mediaItemCount > currentIndex + 1) {
+        exo.removeMediaItems(currentIndex + 1, exo.mediaItemCount)
+    }
+    exo.addMediaItems(newMediaItems)
+}
+
+/** Desired upcoming list after the current track: playNext + upNext + remaining originals, with the playing temp track ([currentId]) skipped. */
+internal fun TrackPlayerCore.buildUpcomingQueueTracks(currentId: String?): List<TrackItem> {
+    val newQueueTracks = ArrayList<TrackItem>(playNextStack.size + upNextQueue.size + currentTracks.size)
 
     // playNext stack — skip the currently playing track by ID (not position)
     if (currentTemporaryType == TrackPlayerCore.TemporaryType.PLAY_NEXT && currentId != null) {
@@ -94,34 +171,39 @@ internal fun TrackPlayerCore.rebuildQueueFromCurrentPosition() {
         newQueueTracks.addAll(upNextQueue)
     }
 
-    // Remaining original tracks (after currentTrackIndex, not after ExoPlayer's currentIndex)
+    // Remaining original tracks (after currentTrackIndex, not after the player's currentIndex)
     if (currentTrackIndex + 1 < currentTracks.size) {
         newQueueTracks.addAll(currentTracks.subList(currentTrackIndex + 1, currentTracks.size))
     }
-
-    val playlistId = currentPlaylistId ?: ""
-    val newMediaItems =
-        newQueueTracks.map { track ->
-            val mediaId = if (playlistId.isNotEmpty()) "$playlistId:${track.id}" else track.id
-            makeMediaItem(track, mediaId)
-        }
-
-    if (exo.mediaItemCount > currentIndex + 1) {
-        exo.removeMediaItems(currentIndex + 1, exo.mediaItemCount)
-    }
-    exo.addMediaItems(newMediaItems)
+    return newQueueTracks
 }
 
 // ── Full queue set (initial load or no active item) ───────────────────────
 
 internal fun TrackPlayerCore.updatePlayerQueue(tracks: List<TrackItem>) {
     currentTracks = tracks
-    val playlistId = currentPlaylistId ?: ""
-    val mediaItems =
-        tracks.map { track ->
-            val mediaId = if (playlistId.isNotEmpty()) "$playlistId:${track.id}" else track.id
-            makeMediaItem(track, mediaId)
+
+    if (isCastingField) {
+        currentTrackIndex = 0
+        val castTracks = castableUpcoming(tracks)
+        if (castTracks.isEmpty()) {
+            // Lazy first track — silence the receiver and wait for updateTracks to supply URLs.
+            if (exo.mediaItemCount > 0) exo.clearMediaItems()
+            val first = tracks.firstOrNull()
+            if (first != null && lastCastWaitTrackId != first.id) {
+                lastCastWaitTrackId = first.id
+                notifyTrackChange(first, null)
+            }
+            checkUpcomingTracksForUrls(lookaheadCount)
+            return
         }
+        lastCastWaitTrackId = null
+        exo.setMediaItems(castTracks.map { makeMediaItem(it, mediaIdFor(it)) }, true)
+        exo.prepare()
+        return
+    }
+
+    val mediaItems = tracks.map { makeMediaItem(it, mediaIdFor(it)) }
     exo.setMediaItems(mediaItems, true)
     if (exo.playbackState == Player.STATE_IDLE && mediaItems.isNotEmpty()) {
         exo.prepare()
@@ -148,7 +230,8 @@ internal fun TrackPlayerCore.makeMediaItem(
         }
     }
 
-    val effectiveUrl = downloadManager.getEffectiveUrl(track)
+    // The receiver fetches media itself, so local download paths are unplayable there — cast uses the remote URL.
+    val effectiveUrl = if (isCastingField) track.url else downloadManager.getEffectiveUrl(track)
 
     // Register custom HTTP headers (e.g. Authorization) from extraPayload.headers so they are
     // injected into the request for this URL. Applies to remote streams only — see ExoPlayerBuilder.

package/android/src/main/java/com/margelo/nitro/nitroplayer/core/TrackPlayerUrlLoader.kt

@@ -36,12 +36,13 @@ suspend fun TrackPlayerCore.updateTracks(tracks: List<TrackItem>) =
 
         val affectedPlaylists: Map<String, Int> = playlistManager.updateTracks(safeTracks)
 
-        // Replace current track's MediaItem if it was empty-URL and now has a URL
-        if (currentTrackUpdate != null && currentTrackIsEmpty && currentTrackUpdate.url.isNotEmpty()) {
+        // Replace the current MediaItem when its URL just resolved (local only — the cast branch below reloads instead).
+        val currentTrackResolvedNow = currentTrackUpdate != null && currentTrackIsEmpty && currentTrackUpdate.url.isNotEmpty()
+        if (!isCastingField && currentTrackResolvedNow) {
             val exoIndex = exo.currentMediaItemIndex
             if (exoIndex >= 0) {
                 val playlistId = currentPlaylistId ?: ""
-                val mediaId = if (playlistId.isNotEmpty()) "$playlistId:${currentTrackUpdate.id}" else currentTrackUpdate.id
+                val mediaId = if (playlistId.isNotEmpty()) "$playlistId:${currentTrackUpdate!!.id}" else currentTrackUpdate!!.id
                 exo.replaceMediaItem(exoIndex, makeMediaItem(currentTrackUpdate, mediaId))
                 if (exo.playbackState == Player.STATE_IDLE) exo.prepare()
             }
@@ -55,6 +56,17 @@ suspend fun TrackPlayerCore.updateTracks(tracks: List<TrackItem>) =
                 playNextStack.forEachIndexed { i, t -> updatedById[t.id]?.let { if (it !== t) playNextStack[i] = it } }
                 upNextQueue.forEachIndexed { i, t -> updatedById[t.id]?.let { if (it !== t) upNextQueue[i] = it } }
             }
+
+            if (isCastingField) {
+                // Resolved current track (or empty receiver) → atomic reload from the current index; otherwise resync only the upcoming items.
+                if (currentTrackResolvedNow || exo.mediaItemCount == 0) {
+                    rebuildQueueAndPlayFromIndex(currentTrackIndex)
+                } else {
+                    rebuildQueueFromCurrentPosition()
+                }
+                return@withPlayerContext
+            }
+
             rebuildQueueFromCurrentPosition()
         }
     }