react-native-nitro-player 0.7.1-alpha.3 → 1.0.2

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

@@ -153,6 +153,12 @@ class HybridTrackPlayer : HybridTrackPlayerSpec() {
     }
 
     override fun onAndroidAutoConnectionChange(callback: (connected: Boolean) -> Unit) {
+        // Replace any prior listener registered through this HybridObject so JS
+        // reloads (Fast Refresh, hot reload) don't accumulate handlers.
+        val existing = listenerIds.filter { it.first == "onAndroidAutoConnectionChange" }
+        existing.forEach { (_, oldId) -> core.removeOnAndroidAutoConnectionListener(oldId) }
+        listenerIds.removeAll { it.first == "onAndroidAutoConnectionChange" }
+
         val id = core.addOnAndroidAutoConnectionListener(callback)
         listenerIds += "onAndroidAutoConnectionChange" to id
     }

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

@@ -120,6 +120,7 @@ class TrackPlayerCore private constructor(
             } else {
                 updatePlayerQueue(playlist.tracks)
             }
+            checkUpcomingTracksForUrls(lookaheadCount)
         }
 
     // ── Service binding ────────────────────────────────────────────────────

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

@@ -319,7 +319,29 @@ class NitroPlayerMediaBrowserService : MediaBrowserServiceCompat() {
      * Fallback: Load playlists when no media library is set
      */
     private suspend fun loadFallbackPlaylists(): MutableList<MediaBrowserCompat.MediaItem> {
-        val playlists = trackPlayerCore?.getAllPlaylists() ?: emptyList()
+        // Apps frequently create internal queue playlists named with raw UUIDs
+        // (e.g. `PlayerQueue.createPlaylist(uuid.v4())`). Showing those in
+        // Android Auto surfaces ugly UUID strings as titles. Filter:
+        //   - empty playlists (no tracks)
+        //   - playlists whose name is a bare UUID
+        //   - duplicate names (keep latest)
+        // and prefer surfacing the currently-loaded playlist first so the user
+        // always has access to "what's playing now" while the JS side hasn't
+        // published a media library yet.
+        val rawPlaylists = trackPlayerCore?.getAllPlaylists() ?: emptyList()
+        val currentId = trackPlayerCore?.getCurrentPlaylistId()
+        val uuidRegex = Regex("^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$")
+
+        val dedupedByName = linkedMapOf<String, com.margelo.nitro.nitroplayer.playlist.Playlist>()
+        rawPlaylists.forEach { p ->
+            if (p.tracks.isEmpty()) return@forEach
+            // Always keep the currently-playing playlist regardless of name shape.
+            val isCurrent = p.id == currentId
+            if (!isCurrent && uuidRegex.matches(p.name)) return@forEach
+            dedupedByName[p.name] = p
+        }
+        val playlists =
+            dedupedByName.values.sortedByDescending { it.id == currentId }
         val mediaItems = mutableListOf<MediaBrowserCompat.MediaItem>()
 
         playlists.forEach { playlist ->
@@ -331,11 +353,13 @@ class NitroPlayerMediaBrowserService : MediaBrowserServiceCompat() {
                     )
                 }
 
+            val displayTitle =
+                if (uuidRegex.matches(playlist.name)) "Now Playing" else playlist.name
             val description =
                 MediaDescriptionCompat
                     .Builder()
                     .setMediaId("$PLAYLIST_PREFIX${playlist.id}")
-                    .setTitle(playlist.name)
+                    .setTitle(displayTitle)
                     .setSubtitle(playlist.description ?: "${playlist.tracks.size} tracks")
                     .setIconUri(playlist.artwork?.let { Uri.parse(it) })
                     .setExtras(extras)

package/ios/core/TrackPlayerListener.swift

@@ -79,14 +79,16 @@ extension TrackPlayerCore {
       currentItem.status == .readyToPlay else { return }
 
     let duration = currentItem.duration.seconds
-    guard duration > 0 && !duration.isNaN && !duration.isInfinite else { return }
-
     let interval: Double
-    if duration > Constants.twoHoursInSeconds { interval = Constants.boundaryIntervalLong }
-    else if duration > Constants.oneHourInSeconds { interval = Constants.boundaryIntervalMedium }
-    else { interval = Constants.boundaryIntervalDefault }
+    if duration > 0 && !duration.isNaN && !duration.isInfinite {
+      if duration > Constants.twoHoursInSeconds { interval = Constants.boundaryIntervalLong }
+      else if duration > Constants.oneHourInSeconds { interval = Constants.boundaryIntervalMedium }
+      else { interval = Constants.boundaryIntervalDefault }
+    } else {
+      interval = Constants.boundaryIntervalDefault
+    }
 
-    NitroPlayerLogger.log("TrackPlayerCore", "⏱️ Setting up periodic observer (interval: \(interval)s, duration: \(Int(duration))s)")
+    NitroPlayerLogger.log("TrackPlayerCore", "⏱️ Setting up periodic observer (interval: \(interval)s, duration: \(duration)s)")
 
     let cmInterval = CMTime(seconds: interval, preferredTimescale: CMTimeScale(NSEC_PER_SEC))
     // Deliver on playerQueue (not main)
@@ -104,20 +106,23 @@ extension TrackPlayerCore {
     guard player.rate > 0 else { return }
 
     let position = currentItem.currentTime().seconds
-    let duration = currentItem.duration.seconds
-    guard duration > 0 && !duration.isNaN && !duration.isInfinite else { return }
+    let rawDuration = currentItem.duration.seconds
+    let duration = (rawDuration > 0 && !rawDuration.isNaN && !rawDuration.isInfinite) ? rawDuration : 0.0
 
-    NitroPlayerLogger.log("TrackPlayerCore", "⏱️ Boundary crossed - position: \(Int(position))s / \(Int(duration))s")
+    NitroPlayerLogger.log("TrackPlayerCore", "⏱️ Boundary crossed - position: \(Int(position))s / duration: \(duration)s")
 
     notifyPlaybackProgress(position, duration, isManuallySeeked ? true : nil)
     isManuallySeeked = false
 
-    let remaining = duration - position
-    if remaining > 0 && remaining <= Constants.preferredForwardBufferDuration && !didRequestUrlsForCurrentItem {
-      didRequestUrlsForCurrentItem = true
-      NitroPlayerLogger.log("TrackPlayerCore",
-        "⏳ \(Int(remaining))s remaining — proactively checking upcoming URLs")
-      checkUpcomingTracksForUrls(lookahead: lookaheadCount)
+    // Only do remaining-time preload when duration is known
+    if duration > 0 {
+      let remaining = duration - position
+      if remaining > 0 && remaining <= Constants.preferredForwardBufferDuration && !didRequestUrlsForCurrentItem {
+        didRequestUrlsForCurrentItem = true
+        NitroPlayerLogger.log("TrackPlayerCore",
+          "⏳ \(Int(remaining))s remaining — proactively checking upcoming URLs")
+        checkUpcomingTracksForUrls(lookahead: lookaheadCount)
+      }
     }
   }
 

package/ios/core/TrackPlayerPlayback.swift

@@ -7,6 +7,7 @@
 
 import AVFoundation
 import Foundation
+import MediaPlayer
 
 extension TrackPlayerCore {
 
@@ -115,8 +116,15 @@ extension TrackPlayerCore {
     self.isManuallySeeked = true
     let time = CMTime(seconds: position, preferredTimescale: CMTimeScale(NSEC_PER_SEC))
     player.seek(to: time) { [weak self] completed in
-      // Update now playing info to restore playback rate after seek
-      DispatchQueue.main.async { self?.mediaSessionManager?.refresh() }
+       // HackFix I dont know how to fix this, but it works.
+      let rate = Double(player.rate)
+      DispatchQueue.main.async {
+        if var info = MPNowPlayingInfoCenter.default().nowPlayingInfo {
+          info[MPNowPlayingInfoPropertyElapsedPlaybackTime] = position
+          info[MPNowPlayingInfoPropertyPlaybackRate] = rate
+          MPNowPlayingInfoCenter.default().nowPlayingInfo = info
+        }
+      }
       if completed {
         let duration = player.currentItem?.duration.seconds ?? 0.0
         self?.notifySeek(position, duration)

package/ios/core/TrackPlayerQueue.swift

@@ -43,7 +43,8 @@ extension TrackPlayerCore {
     }
     let currentTrack = getCurrentTrack()
     let currentPosition = player.currentTime().seconds
-    let totalDuration = player.currentItem?.duration.seconds ?? 0.0
+    let rawDuration = player.currentItem?.duration.seconds ?? 0.0
+    let totalDuration = (rawDuration > 0 && !rawDuration.isNaN && !rawDuration.isInfinite) ? rawDuration : 0.0
 
     let state: TrackPlayerState
     if player.rate == 0 { state = .paused }

package/ios/core/TrackPlayerTempQueue.swift

@@ -53,12 +53,14 @@ extension TrackPlayerCore {
       // If nothing is playing yet, do a full load
       guard self.player?.currentItem != nil else {
         self.updatePlayerQueue(tracks: playlist.tracks)
+        self.checkUpcomingTracksForUrls(lookahead: self.lookaheadCount)
         return
       }
 
       // Update tracks list without interrupting playback
       self.currentTracks = playlist.tracks
       self.rebuildAVQueueFromCurrentPosition()
+      self.checkUpcomingTracksForUrls(lookahead: self.lookaheadCount)
     }
 
     pendingPlaylistUpdateWorkItem = workItem

package/ios/playlist/PlaylistManager.swift

@@ -172,6 +172,7 @@ class PlaylistManager {
     // Update TrackPlayerCore if this is the current playlist
     if currentPlaylistId == playlistId {
       TrackPlayerCore.shared.updatePlaylist(playlistId: playlistId)
+      TrackPlayerCore.shared.checkUpcomingTracksForUrls(lookahead: TrackPlayerCore.shared.lookaheadCount)
     }
 
     return true

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-nitro-player",
-  "version": "0.7.1-alpha.3",
+  "version": "1.0.2",
   "description": "A powerful audio player library for React Native with playlist management, playback controls, and support for Android Auto and CarPlay",
   "main": "lib/index",
   "module": "lib/index",