react-native-nitro-player 0.7.0 → 0.7.1-alpha.0

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

@@ -0,0 +1,121 @@
+@file:Suppress("ktlint:standard:max-line-length")
+
+package com.margelo.nitro.nitroplayer.core
+
+import com.margelo.nitro.nitroplayer.TrackItem
+
+/**
+ * Temporary queue management (playNext stack + upNext queue) and playlist loading.
+ * All public functions are suspend and execute on the player thread.
+ */
+
+// ── Playlist loading ──────────────────────────────────────────────────────
+
+suspend fun TrackPlayerCore.loadPlaylist(playlistId: String) = withPlayerContext {
+    playNextStack.clear()
+    upNextQueue.clear()
+    currentTemporaryType = TrackPlayerCore.TemporaryType.NONE
+    val playlist = playlistManager.getPlaylist(playlistId) ?: return@withPlayerContext
+    currentPlaylistId = playlistId
+    updatePlayerQueue(playlist.tracks)
+    checkUpcomingTracksForUrls(lookaheadCount)
+    notifyTemporaryQueueChange()
+}
+
+/**
+ * Debounced update — coalesces rapid back-to-back mutations into one player rebuild.
+ * Called by HybridPlayerQueue when playlist data changes.
+ */
+fun TrackPlayerCore.updatePlaylist(playlistId: String) {
+    if (currentPlaylistId != playlistId) return
+    playerHandler.removeCallbacks(updateCurrentPlaylistRunnable)
+    playerHandler.post(updateCurrentPlaylistRunnable)
+}
+
+// ── playNext (LIFO) ────────────────────────────────────────────────────────
+
+suspend fun TrackPlayerCore.playNext(trackId: String) = withPlayerContext { playNextInternal(trackId) }
+
+internal fun TrackPlayerCore.playNextInternal(trackId: String) {
+    val track = findTrackById(trackId)
+        ?: throw IllegalArgumentException("Track $trackId not found")
+    playNextStack.add(0, track)
+    if (isExoInitialized && exo.currentMediaItem != null) rebuildQueueFromCurrentPosition()
+    notifyTemporaryQueueChange()
+}
+
+// ── addToUpNext (FIFO) ────────────────────────────────────────────────────
+
+suspend fun TrackPlayerCore.addToUpNext(trackId: String) = withPlayerContext { addToUpNextInternal(trackId) }
+
+internal fun TrackPlayerCore.addToUpNextInternal(trackId: String) {
+    val track = findTrackById(trackId)
+        ?: throw IllegalArgumentException("Track $trackId not found")
+    upNextQueue.add(track)
+    if (isExoInitialized && exo.currentMediaItem != null) rebuildQueueFromCurrentPosition()
+    notifyTemporaryQueueChange()
+}
+
+// ── Remove / clear ────────────────────────────────────────────────────────
+
+suspend fun TrackPlayerCore.removeFromPlayNext(trackId: String): Boolean = withPlayerContext {
+    val idx = playNextStack.indexOfFirst { it.id == trackId }
+    if (idx < 0) return@withPlayerContext false
+    playNextStack.removeAt(idx)
+    if (isExoInitialized && exo.currentMediaItem != null) rebuildQueueFromCurrentPosition()
+    notifyTemporaryQueueChange()
+    true
+}
+
+suspend fun TrackPlayerCore.removeFromUpNext(trackId: String): Boolean = withPlayerContext {
+    val idx = upNextQueue.indexOfFirst { it.id == trackId }
+    if (idx < 0) return@withPlayerContext false
+    upNextQueue.removeAt(idx)
+    if (isExoInitialized && exo.currentMediaItem != null) rebuildQueueFromCurrentPosition()
+    notifyTemporaryQueueChange()
+    true
+}
+
+suspend fun TrackPlayerCore.clearPlayNext() = withPlayerContext {
+    playNextStack.clear()
+    if (isExoInitialized && exo.currentMediaItem != null) rebuildQueueFromCurrentPosition()
+    notifyTemporaryQueueChange()
+}
+
+suspend fun TrackPlayerCore.clearUpNext() = withPlayerContext {
+    upNextQueue.clear()
+    if (isExoInitialized && exo.currentMediaItem != null) rebuildQueueFromCurrentPosition()
+    notifyTemporaryQueueChange()
+}
+
+// ── Reorder ───────────────────────────────────────────────────────────────
+
+/**
+ * Reorder within the combined virtual list [playNextStack + upNextQueue].
+ * newIndex is 0-based within that combined list.
+ */
+suspend fun TrackPlayerCore.reorderTemporaryTrack(trackId: String, newIndex: Int): Boolean = withPlayerContext {
+    val combined = (playNextStack + upNextQueue).toMutableList()
+    val fromIdx = combined.indexOfFirst { it.id == trackId }
+    if (fromIdx < 0) return@withPlayerContext false
+    val track = combined.removeAt(fromIdx)
+    val clampedIndex = newIndex.coerceIn(0, combined.size)
+    combined.add(clampedIndex, track)
+
+    // Split back at original playNextStack.size boundary (reduced if an item was moved out)
+    val pnSize = playNextStack.size
+    playNextStack.clear()
+    upNextQueue.clear()
+    playNextStack.addAll(combined.take(pnSize))
+    upNextQueue.addAll(combined.drop(pnSize))
+
+    if (isExoInitialized && exo.currentMediaItem != null) rebuildQueueFromCurrentPosition()
+    notifyTemporaryQueueChange()
+    true
+}
+
+// ── Read-only accessors ────────────────────────────────────────────────────
+
+suspend fun TrackPlayerCore.getPlayNextQueue(): List<TrackItem> = withPlayerContext { playNextStack.toList() }
+
+suspend fun TrackPlayerCore.getUpNextQueue(): List<TrackItem> = withPlayerContext { upNextQueue.toList() }

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

@@ -0,0 +1,98 @@
+@file:Suppress("ktlint:standard:max-line-length")
+
+package com.margelo.nitro.nitroplayer.core
+
+import androidx.media3.common.Player
+import com.margelo.nitro.nitroplayer.TrackItem
+
+/**
+ * Lazy URL loading support, track queries, and playback speed.
+ * All public functions are suspend and execute on the player thread.
+ */
+
+// ── Track updates (URL resolution) ────────────────────────────────────────
+
+suspend fun TrackPlayerCore.updateTracks(tracks: List<TrackItem>) = withPlayerContext {
+    val currentTrack = getCurrentTrack()
+    val currentTrackId = currentTrack?.id
+    val currentTrackIsEmpty = currentTrack?.url.isNullOrEmpty()
+    val currentTrackUpdate = if (currentTrackId != null) tracks.find { it.id == currentTrackId } else null
+
+    val safeTracks = tracks.filter { track ->
+        when {
+            track.id == currentTrackId && !currentTrackIsEmpty -> false // preserve gapless
+            track.id == currentTrackId && currentTrackIsEmpty -> track.url.isNotEmpty()
+            track.url.isEmpty() -> false
+            else -> true
+        }
+    }
+    if (safeTracks.isEmpty()) return@withPlayerContext
+
+    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()) {
+        val exoIndex = exo.currentMediaItemIndex
+        if (exoIndex >= 0) {
+            val playlistId = currentPlaylistId ?: ""
+            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()
+        }
+    }
+
+    if (currentPlaylistId != null && affectedPlaylists.containsKey(currentPlaylistId)) {
+        val refreshedPlaylist = playlistManager.getPlaylist(currentPlaylistId!!)
+        if (refreshedPlaylist != null) {
+            currentTracks = refreshedPlaylist.tracks
+            val updatedById = currentTracks.associateBy { it.id }
+            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 } }
+        }
+        rebuildQueueFromCurrentPosition()
+    }
+}
+
+// ── Track queries ─────────────────────────────────────────────────────────
+
+suspend fun TrackPlayerCore.getTracksById(trackIds: List<String>): List<TrackItem> =
+    withPlayerContext { playlistManager.getTracksById(trackIds) as List<TrackItem> }
+
+suspend fun TrackPlayerCore.getTracksNeedingUrls(): List<TrackItem> =
+    withPlayerContext { getTracksNeedingUrlsInternal() }
+
+internal fun TrackPlayerCore.getTracksNeedingUrlsInternal(): List<TrackItem> {
+    val pid = currentPlaylistId ?: return emptyList()
+    return playlistManager.getPlaylist(pid)?.tracks?.filter { it.url.isEmpty() } ?: emptyList()
+}
+
+suspend fun TrackPlayerCore.getNextTracks(count: Int): List<TrackItem> =
+    withPlayerContext { getNextTracksInternal(count) }
+
+internal fun TrackPlayerCore.getNextTracksInternal(count: Int): List<TrackItem> {
+    val actualQueue = getActualQueueInternal()
+    if (actualQueue.isEmpty()) return emptyList()
+    val currentIdx = actualQueue.indexOfFirst { it.id == getCurrentTrack()?.id }
+    if (currentIdx == -1) return emptyList()
+    val start = currentIdx + 1
+    val end = minOf(start + count, actualQueue.size)
+    return if (start < actualQueue.size) actualQueue.subList(start, end) else emptyList()
+}
+
+suspend fun TrackPlayerCore.getCurrentTrackIndex(): Int = withPlayerContext { currentTrackIndex }
+
+// ── URL lookahead ─────────────────────────────────────────────────────────
+
+internal fun TrackPlayerCore.checkUpcomingTracksForUrls(lookahead: Int = 5) {
+    val upcomingTracks = if (currentTrackIndex < 0) {
+        currentTracks.take(lookahead)
+    } else {
+        getNextTracksInternal(lookahead)
+    }
+    val currentTrack = getCurrentTrack()
+    val currentNeedsUrl = currentTrack != null && currentTrack.url.isEmpty()
+    val candidates = if (currentNeedsUrl) listOf(currentTrack!!) + upcomingTracks else upcomingTracks
+    val needUrls = candidates.filter { it.url.isEmpty() }
+    if (needUrls.isNotEmpty()) notifyTracksNeedUpdate(needUrls, lookahead)
+}
+

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

@@ -10,6 +10,10 @@ import com.margelo.nitro.nitroplayer.storage.NitroPlayerStorage
 import org.json.JSONArray
 import org.json.JSONObject
 import java.io.File
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.SupervisorJob
+import kotlinx.coroutines.launch
 
 /**
  * Manages persistence of downloaded track metadata using file storage
@@ -37,6 +41,7 @@ class DownloadDatabase private constructor(
     private val downloadedTracks = mutableMapOf<String, DownloadedTrackRecord>()
     private val playlistTracks = mutableMapOf<String, MutableSet<String>>()
     private val fileManager = DownloadFileManager.getInstance(context)
+    private val ioScope = CoroutineScope(Dispatchers.IO + SupervisorJob())
 
     init {
         loadFromDisk()
@@ -295,27 +300,31 @@ class DownloadDatabase private constructor(
         }
     }
 
-    // Persistence
+    // Persistence — called while holding synchronized(this); snapshots data then writes on IO.
     private fun saveToDisk() {
-        try {
-            val tracksJson = JSONObject()
-            for ((trackId, record) in downloadedTracks) {
-                tracksJson.put(trackId, record.toJson())
-            }
-
-            val playlistJson = JSONObject()
-            for ((playlistId, trackIds) in playlistTracks) {
-                playlistJson.put(playlistId, JSONArray(trackIds.toList()))
-            }
+        val trackSnapshot = downloadedTracks.toMap()
+        val playlistSnapshot = playlistTracks.mapValues { it.value.toSet() }
+        ioScope.launch {
+            try {
+                val tracksJson = JSONObject()
+                for ((trackId, record) in trackSnapshot) {
+                    tracksJson.put(trackId, record.toJson())
+                }
 
-            val wrapper =
-                JSONObject().apply {
-                    put("downloadedTracks", tracksJson)
-                    put("playlistTracks", playlistJson)
+                val playlistJson = JSONObject()
+                for ((playlistId, trackIds) in playlistSnapshot) {
+                    playlistJson.put(playlistId, JSONArray(trackIds.toList()))
                 }
-            NitroPlayerStorage.write(context, "downloads.json", wrapper.toString())
-        } catch (e: Exception) {
-            e.printStackTrace()
+
+                val wrapper =
+                    JSONObject().apply {
+                        put("downloadedTracks", tracksJson)
+                        put("playlistTracks", playlistJson)
+                    }
+                NitroPlayerStorage.write(context, "downloads.json", wrapper.toString())
+            } catch (e: Exception) {
+                e.printStackTrace()
+            }
         }
     }
 

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

@@ -14,8 +14,7 @@ import com.margelo.nitro.nitroplayer.Variant_NullType_String
 import com.margelo.nitro.nitroplayer.core.NitroPlayerLogger
 import org.json.JSONArray
 import org.json.JSONObject
-import java.lang.ref.WeakReference
-import java.util.Collections
+import com.margelo.nitro.nitroplayer.core.ListenerRegistry
 
 class EqualizerCore private constructor(
     private val context: Context,
@@ -35,21 +34,10 @@ class EqualizerCore private constructor(
     private val prefs: SharedPreferences =
         context.getSharedPreferences("equalizer_settings", Context.MODE_PRIVATE)
 
-    // Weak callback wrapper for auto-cleanup
-    private data class WeakCallbackBox<T>(
-        private val ownerRef: WeakReference<Any>,
-        val callback: T,
-    ) {
-        val isAlive: Boolean get() = ownerRef.get() != null
-    }
-
     // Event listeners
-    private val onEnabledChangeListeners =
-        Collections.synchronizedList(mutableListOf<WeakCallbackBox<(Boolean) -> Unit>>())
-    private val onBandChangeListeners =
-        Collections.synchronizedList(mutableListOf<WeakCallbackBox<(Array<EqualizerBand>) -> Unit>>())
-    private val onPresetChangeListeners =
-        Collections.synchronizedList(mutableListOf<WeakCallbackBox<(Variant_NullType_String?) -> Unit>>())
+    private val onEnabledChangeListeners = ListenerRegistry<(Boolean) -> Unit>()
+    private val onBandChangeListeners = ListenerRegistry<(Array<EqualizerBand>) -> Unit>()
+    private val onPresetChangeListeners = ListenerRegistry<(Variant_NullType_String?) -> Unit>()
 
     companion object {
         private const val TAG = "EqualizerCore"
@@ -429,63 +417,28 @@ class EqualizerCore private constructor(
     // === Callback management ===
 
     fun addOnEnabledChangeListener(callback: (Boolean) -> Unit) {
-        val box = WeakCallbackBox(WeakReference(callback as Any), callback)
-        onEnabledChangeListeners.add(box)
+        onEnabledChangeListeners.add(callback)
     }
 
     fun addOnBandChangeListener(callback: (Array<EqualizerBand>) -> Unit) {
-        val box = WeakCallbackBox(WeakReference(callback as Any), callback)
-        synchronized(onBandChangeListeners) {
-            @Suppress("UNCHECKED_CAST")
-            (onBandChangeListeners as MutableList<WeakCallbackBox<(Array<EqualizerBand>) -> Unit>>).add(box)
-        }
+        onBandChangeListeners.add(callback)
     }
 
     fun addOnPresetChangeListener(callback: (Variant_NullType_String?) -> Unit) {
-        val box = WeakCallbackBox(WeakReference(callback as Any), callback)
-        onPresetChangeListeners.add(box)
+        onPresetChangeListeners.add(callback)
     }
 
     private fun notifyEnabledChange(enabled: Boolean) {
-        synchronized(onEnabledChangeListeners) {
-            onEnabledChangeListeners.removeAll { !it.isAlive }
-            onEnabledChangeListeners.forEach { box ->
-                try {
-                    box.callback(enabled)
-                } catch (e: Exception) {
-                    // Ignore callback errors
-                }
-            }
-        }
+        onEnabledChangeListeners.forEach { it(enabled) }
     }
 
     private fun notifyBandChange(bands: Array<EqualizerBand>) {
-        synchronized(onBandChangeListeners) {
-            @Suppress("UNCHECKED_CAST")
-            val listeners = onBandChangeListeners as MutableList<WeakCallbackBox<(Array<EqualizerBand>) -> Unit>>
-            listeners.removeAll { !it.isAlive }
-            listeners.forEach { box ->
-                try {
-                    box.callback(bands)
-                } catch (e: Exception) {
-                    // Ignore callback errors
-                }
-            }
-        }
+        onBandChangeListeners.forEach { it(bands) }
     }
 
     private fun notifyPresetChange(presetName: String?) {
-        synchronized(onPresetChangeListeners) {
-            onPresetChangeListeners.removeAll { !it.isAlive }
-            onPresetChangeListeners.forEach { box ->
-                try {
-                    val variant = presetName?.let { Variant_NullType_String.create(it) }
-                    box.callback(variant)
-                } catch (e: Exception) {
-                    // Ignore callback errors
-                }
-            }
-        }
+        val variant = presetName?.let { Variant_NullType_String.create(it) }
+        onPresetChangeListeners.forEach { it(variant) }
     }
 
     fun release() {

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

@@ -26,6 +26,7 @@ import com.google.common.util.concurrent.ListenableFuture
 import com.margelo.nitro.nitroplayer.TrackItem
 import com.margelo.nitro.nitroplayer.core.NitroPlayerLogger
 import com.margelo.nitro.nitroplayer.core.TrackPlayerCore
+import com.margelo.nitro.nitroplayer.core.loadPlaylist
 import com.margelo.nitro.nitroplayer.media.NitroPlayerMediaBrowserService
 import com.margelo.nitro.nitroplayer.playlist.PlaylistManager
 import kotlinx.coroutines.CoroutineScope
@@ -50,6 +51,8 @@ class MediaSessionManager(
         private set
     private var notificationManager: NotificationManager? = null
     private val scope = CoroutineScope(SupervisorJob() + Dispatchers.Main)
+    @Volatile private var currentTrack: TrackItem? = null
+    @Volatile private var isPlaying: Boolean = false
     private val artworkCache = object : LruCache<String, Bitmap>(20) {
         override fun sizeOf(key: String, value: Bitmap): Int = 1
     }
@@ -216,7 +219,7 @@ class MediaSessionManager(
 
                                             if (trackIndex >= 0) {
                                                 // Load the entire playlist into TrackPlayerCore
-                                                trackPlayerCore?.loadPlaylist(playlistId)
+                                                trackPlayerCore?.let { core -> scope.launch { core.loadPlaylist(playlistId) } }
 
                                                 // Create MediaItems for the entire playlist
                                                 val playlistMediaItems =
@@ -324,28 +327,7 @@ class MediaSessionManager(
         }
     }
 
-    private fun getCurrentTrack(): TrackItem? {
-        val currentMediaItem = player.currentMediaItem ?: return null
-        val mediaId = currentMediaItem.mediaId
-
-        // Parse mediaId format: "playlistId:trackId" or just "trackId"
-        val trackId =
-            if (mediaId.contains(':')) {
-                mediaId.substring(mediaId.indexOf(':') + 1)
-            } else {
-                mediaId
-            }
-
-        // Find track in current playlist or all playlists
-        return trackPlayerCore?.getCurrentPlaylistId()?.let { playlistId ->
-            playlistManager.getPlaylist(playlistId)?.tracks?.find { it.id == trackId }
-        } ?: run {
-            for (playlist in playlistManager.getAllPlaylists()) {
-                playlist.tracks.find { it.id == trackId }?.let { return it }
-            }
-            null
-        }
-    }
+    private fun getCurrentTrack(): TrackItem? = currentTrack
 
     private fun updateNotification() {
         if (!showInNotification) return
@@ -376,7 +358,7 @@ class MediaSessionManager(
                 .setSmallIcon(android.R.drawable.ic_media_play)
                 .setContentIntent(contentIntent)
                 .setVisibility(NotificationCompat.VISIBILITY_PUBLIC)
-                .setOngoing(player.isPlaying)
+                .setOngoing(isPlaying)
                 .setShowWhen(false)
                 .setPriority(NotificationCompat.PRIORITY_LOW)
                 .setCategory(NotificationCompat.CATEGORY_TRANSPORT)
@@ -401,7 +383,7 @@ class MediaSessionManager(
             createMediaAction(ACTION_PREVIOUS),
         )
 
-        if (player.isPlaying) {
+        if (isPlaying) {
             builder.addAction(
                 android.R.drawable.ic_media_pause,
                 "Pause",
@@ -459,12 +441,12 @@ class MediaSessionManager(
         notificationManager?.cancel(NOTIFICATION_ID)
     }
 
-    fun onTrackChanged() {
+    fun onTrackChanged(track: TrackItem?) {
+        currentTrack = track
         // Preload artwork for better notification display
-        val currentTrack = getCurrentTrack()
-        if (currentTrack != null) {
+        if (track != null) {
             scope.launch {
-                currentTrack.artwork?.asSecondOrNull()?.let { artworkUrl ->
+                track.artwork?.asSecondOrNull()?.let { artworkUrl ->
                     loadArtworkBitmap(artworkUrl)
                 }
                 updateNotification()
@@ -474,7 +456,8 @@ class MediaSessionManager(
         }
     }
 
-    fun onPlaybackStateChanged() {
+    fun onPlaybackStateChanged(playing: Boolean) {
+        isPlaying = playing
         updateNotification()
     }