react-native-nitro-player 0.0.1

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

@@ -0,0 +1,454 @@
+package com.margelo.nitro.nitroplayer.playlist
+
+import android.content.Context
+import android.content.SharedPreferences
+import com.margelo.nitro.core.NullType
+import com.margelo.nitro.nitroplayer.QueueOperation
+import com.margelo.nitro.nitroplayer.TrackItem
+import com.margelo.nitro.nitroplayer.Variant_NullType_String
+import com.margelo.nitro.nitroplayer.core.TrackPlayerCore
+import com.margelo.nitro.nitroplayer.media.NitroPlayerMediaBrowserService
+import org.json.JSONArray
+import org.json.JSONObject
+import java.util.UUID
+import java.util.concurrent.CopyOnWriteArrayList
+
+/**
+ * Manages multiple playlists using ExoPlayer's native playlist functionality
+ * Based on: https://developer.android.com/media/media3/exoplayer/playlists
+ */
+class PlaylistManager private constructor(
+    private val context: Context,
+) {
+    private val playlists: MutableMap<String, Playlist> = mutableMapOf()
+    private val listeners = CopyOnWriteArrayList<(List<Playlist>, QueueOperation?) -> Unit>()
+    private val playlistListeners = mutableMapOf<String, CopyOnWriteArrayList<(Playlist, QueueOperation?) -> Unit>>()
+    private var currentPlaylistId: String? = null
+
+    private val sharedPreferences: SharedPreferences =
+        context.getSharedPreferences("NitroPlayerPlaylists", Context.MODE_PRIVATE)
+
+    companion object {
+        @Volatile
+        @Suppress("ktlint:standard:property-naming")
+        private var INSTANCE: PlaylistManager? = null
+
+        @JvmStatic
+        fun getInstance(context: Context): PlaylistManager =
+            INSTANCE ?: synchronized(this) {
+                INSTANCE ?: PlaylistManager(context.applicationContext).also { INSTANCE = it }
+            }
+    }
+
+    init {
+        // Don't load from preferences on init - only load when Android Auto needs it
+    }
+
+    /**
+     * Create a new playlist
+     */
+    fun createPlaylist(
+        name: String,
+        description: String? = null,
+        artwork: String? = null,
+    ): String {
+        val id = UUID.randomUUID().toString()
+        val playlist = Playlist(id, name, description, artwork)
+
+        synchronized(playlists) {
+            playlists[id] = playlist
+        }
+
+        // Only cache for Android Auto if connected
+        if (NitroPlayerMediaBrowserService.isAndroidAutoConnected) {
+            savePlaylistsToPreferences()
+        }
+        notifyPlaylistsChanged(QueueOperation.ADD)
+        NitroPlayerMediaBrowserService.getInstance()?.onPlaylistsUpdated()
+
+        return id
+    }
+
+    /**
+     * Delete a playlist
+     */
+    fun deletePlaylist(playlistId: String): Boolean {
+        val removed =
+            synchronized(playlists) {
+                playlists.remove(playlistId)
+            }
+
+        if (removed != null) {
+            if (currentPlaylistId == playlistId) {
+                currentPlaylistId = null
+            }
+            playlistListeners.remove(playlistId)
+            // Only cache for Android Auto if connected
+            if (NitroPlayerMediaBrowserService.isAndroidAutoConnected) {
+                savePlaylistsToPreferences()
+            }
+            notifyPlaylistsChanged(QueueOperation.REMOVE)
+            NitroPlayerMediaBrowserService.getInstance()?.onPlaylistsUpdated()
+            return true
+        }
+
+        return false
+    }
+
+    /**
+     * Update playlist metadata
+     */
+    fun updatePlaylist(
+        playlistId: String,
+        name: String? = null,
+        description: String? = null,
+        artwork: String? = null,
+    ): Boolean {
+        val playlist =
+            synchronized(playlists) {
+                playlists[playlistId]
+            } ?: return false
+
+        synchronized(playlists) {
+            playlists[playlistId] =
+                playlist.copy(
+                    name = name ?: playlist.name,
+                    description = description ?: playlist.description,
+                    artwork = artwork ?: playlist.artwork,
+                )
+        }
+
+        // Only cache for Android Auto if connected
+        if (NitroPlayerMediaBrowserService.isAndroidAutoConnected) {
+            savePlaylistsToPreferences()
+        }
+        notifyPlaylistChanged(playlistId, QueueOperation.UPDATE)
+        notifyPlaylistsChanged(QueueOperation.UPDATE)
+        NitroPlayerMediaBrowserService.getInstance()?.onPlaylistsUpdated()
+
+        return true
+    }
+
+    /**
+     * Get a playlist by ID
+     */
+    fun getPlaylist(playlistId: String): Playlist? =
+        synchronized(playlists) {
+            playlists[playlistId]
+        }
+
+    /**
+     * Get all playlists
+     */
+    fun getAllPlaylists(): List<Playlist> =
+        synchronized(playlists) {
+            playlists.values.toList()
+        }
+
+    /**
+     * Add a track to a playlist
+     */
+    fun addTrackToPlaylist(
+        playlistId: String,
+        track: TrackItem,
+        index: Int? = null,
+    ): Boolean {
+        val playlist =
+            synchronized(playlists) {
+                playlists[playlistId]
+            } ?: return false
+
+        synchronized(playlists) {
+            val tracks = playlist.tracks.toMutableList()
+            if (index != null && index >= 0 && index <= tracks.size) {
+                tracks.add(index, track)
+            } else {
+                tracks.add(track)
+            }
+            playlists[playlistId] = playlist.copy(tracks = tracks)
+        }
+
+        // Only cache for Android Auto if connected
+        if (NitroPlayerMediaBrowserService.isAndroidAutoConnected) {
+            savePlaylistsToPreferences()
+        }
+        notifyPlaylistChanged(playlistId, QueueOperation.ADD)
+        NitroPlayerMediaBrowserService.getInstance()?.onPlaylistUpdated(playlistId)
+
+        // Update ExoPlayer if this is the current playlist
+        if (currentPlaylistId == playlistId) {
+            TrackPlayerCore.getInstance(context)?.updatePlaylist(playlistId)
+        }
+
+        return true
+    }
+
+    /**
+     * Add multiple tracks to a playlist at once
+     */
+    fun addTracksToPlaylist(
+        playlistId: String,
+        tracks: List<TrackItem>,
+        index: Int? = null,
+    ): Boolean {
+        val playlist =
+            synchronized(playlists) {
+                playlists[playlistId]
+            } ?: return false
+
+        synchronized(playlists) {
+            val currentTracks = playlist.tracks.toMutableList()
+            if (index != null && index >= 0 && index <= currentTracks.size) {
+                currentTracks.addAll(index, tracks)
+            } else {
+                currentTracks.addAll(tracks)
+            }
+            playlists[playlistId] = playlist.copy(tracks = currentTracks)
+        }
+
+        // Only cache for Android Auto if connected
+        if (NitroPlayerMediaBrowserService.isAndroidAutoConnected) {
+            savePlaylistsToPreferences()
+        }
+        notifyPlaylistChanged(playlistId, QueueOperation.ADD)
+        NitroPlayerMediaBrowserService.getInstance()?.onPlaylistUpdated(playlistId)
+
+        // Update ExoPlayer if this is the current playlist
+        if (currentPlaylistId == playlistId) {
+            TrackPlayerCore.getInstance(context)?.updatePlaylist(playlistId)
+        }
+
+        return true
+    }
+
+    /**
+     * Remove a track from a playlist
+     */
+    fun removeTrackFromPlaylist(
+        playlistId: String,
+        trackId: String,
+    ): Boolean {
+        val playlist =
+            synchronized(playlists) {
+                playlists[playlistId]
+            } ?: return false
+
+        val removed =
+            synchronized(playlists) {
+                val tracks = playlist.tracks.toMutableList()
+                val removed = tracks.removeAll { it.id == trackId }
+                if (removed) {
+                    playlists[playlistId] = playlist.copy(tracks = tracks)
+                }
+                removed
+            }
+
+        if (removed) {
+            savePlaylistsToPreferences()
+            notifyPlaylistChanged(playlistId, QueueOperation.REMOVE)
+            NitroPlayerMediaBrowserService.getInstance()?.onPlaylistUpdated(playlistId)
+
+            // Update ExoPlayer if this is the current playlist
+            if (currentPlaylistId == playlistId) {
+                TrackPlayerCore.getInstance(context)?.updatePlaylist(playlistId)
+            }
+        }
+
+        return removed
+    }
+
+    /**
+     * Reorder a track in a playlist
+     */
+    fun reorderTrackInPlaylist(
+        playlistId: String,
+        trackId: String,
+        newIndex: Int,
+    ): Boolean {
+        val playlist =
+            synchronized(playlists) {
+                playlists[playlistId]
+            } ?: return false
+
+        val tracks = playlist.tracks.toMutableList()
+        val oldIndex = tracks.indexOfFirst { it.id == trackId }
+        if (oldIndex < 0 || newIndex < 0 || newIndex >= tracks.size) {
+            return false
+        }
+
+        synchronized(playlists) {
+            val track = tracks.removeAt(oldIndex)
+            tracks.add(newIndex, track)
+            playlists[playlistId] = playlist.copy(tracks = tracks)
+        }
+
+        savePlaylistsToPreferences()
+        notifyPlaylistChanged(playlistId, QueueOperation.UPDATE)
+        NitroPlayerMediaBrowserService.getInstance()?.onPlaylistUpdated(playlistId)
+
+        // Update ExoPlayer if this is the current playlist
+        if (currentPlaylistId == playlistId) {
+            TrackPlayerCore.getInstance(context)?.updatePlaylist(playlistId)
+        }
+
+        return true
+    }
+
+    /**
+     * Load a playlist for playback (sets it as current)
+     */
+    fun loadPlaylist(playlistId: String): Boolean {
+        val playlist =
+            synchronized(playlists) {
+                playlists[playlistId]
+            } ?: return false
+
+        currentPlaylistId = playlistId
+        TrackPlayerCore.getInstance(context)?.loadPlaylist(playlistId)
+
+        return true
+    }
+
+    /**
+     * Get the current playlist ID
+     */
+    fun getCurrentPlaylistId(): String? = currentPlaylistId
+
+    /**
+     * Get the current playlist
+     */
+    fun getCurrentPlaylist(): Playlist? = currentPlaylistId?.let { synchronized(playlists) { playlists[it] } }
+
+    /**
+     * Add a listener for playlist changes
+     */
+    fun addPlaylistsChangeListener(listener: (List<Playlist>, QueueOperation?) -> Unit): () -> Unit {
+        listeners.add(listener)
+        return { listeners.remove(listener) }
+    }
+
+    /**
+     * Add a listener for a specific playlist changes
+     */
+    fun addPlaylistChangeListener(
+        playlistId: String,
+        listener: (Playlist, QueueOperation?) -> Unit,
+    ): () -> Unit {
+        val playlistListeners = playlistListeners.getOrPut(playlistId) { CopyOnWriteArrayList() }
+        playlistListeners.add(listener)
+        return { playlistListeners.remove(listener) }
+    }
+
+    private fun notifyPlaylistsChanged(operation: QueueOperation?) {
+        val allPlaylists =
+            synchronized(playlists) {
+                playlists.values.toList()
+            }
+        listeners.forEach { it(allPlaylists, operation) }
+    }
+
+    private fun notifyPlaylistChanged(
+        playlistId: String,
+        operation: QueueOperation?,
+    ) {
+        val playlist =
+            synchronized(playlists) {
+                playlists[playlistId]
+            } ?: return
+
+        playlistListeners[playlistId]?.forEach { it(playlist, operation) }
+    }
+
+    private fun savePlaylistsToPreferences() {
+        try {
+            val jsonArray = JSONArray()
+            synchronized(playlists) {
+                playlists.values.forEach { playlist ->
+                    val jsonObject =
+                        JSONObject().apply {
+                            put("id", playlist.id)
+                            put("name", playlist.name)
+                            put("description", playlist.description ?: "")
+                            put("artwork", playlist.artwork ?: "")
+                            val tracksArray = JSONArray()
+                            playlist.tracks.forEach { track ->
+                                tracksArray.put(
+                                    JSONObject().apply {
+                                        put("id", track.id)
+                                        put("title", track.title)
+                                        put("artist", track.artist)
+                                        put("album", track.album)
+                                        put("duration", track.duration)
+                                        put("url", track.url)
+                                        track.artwork?.let { put("artwork", it) }
+                                    },
+                                )
+                            }
+                            put("tracks", tracksArray)
+                        }
+                    jsonArray.put(jsonObject)
+                }
+            }
+
+            sharedPreferences
+                .edit()
+                .putString("playlists", jsonArray.toString())
+                .putString("currentPlaylistId", currentPlaylistId)
+                .apply()
+        } catch (e: Exception) {
+            e.printStackTrace()
+        }
+    }
+
+    private fun loadPlaylistsFromPreferences() {
+        try {
+            val jsonString = sharedPreferences.getString("playlists", null)
+            if (jsonString != null) {
+                val jsonArray = JSONArray(jsonString)
+                synchronized(playlists) {
+                    playlists.clear()
+                    for (i in 0 until jsonArray.length()) {
+                        val jsonObject = jsonArray.getJSONObject(i)
+                        val tracks = mutableListOf<TrackItem>()
+                        val tracksArray = jsonObject.getJSONArray("tracks")
+                        for (j in 0 until tracksArray.length()) {
+                            val trackObj = tracksArray.getJSONObject(j)
+                            val artworkStr = trackObj.optString("artwork")
+                            val artwork: Variant_NullType_String? =
+                                if (!artworkStr.isNullOrEmpty()) {
+                                    Variant_NullType_String.create(artworkStr)
+                                } else {
+                                    null
+                                }
+                            tracks.add(
+                                TrackItem(
+                                    id = trackObj.getString("id"),
+                                    title = trackObj.getString("title"),
+                                    artist = trackObj.getString("artist"),
+                                    album = trackObj.getString("album"),
+                                    duration = trackObj.getDouble("duration"),
+                                    url = trackObj.getString("url"),
+                                    artwork = artwork,
+                                ),
+                            )
+                        }
+                        val descriptionStr = jsonObject.optString("description")
+                        val artworkStr = jsonObject.optString("artwork")
+                        val playlist =
+                            Playlist(
+                                id = jsonObject.getString("id"),
+                                name = jsonObject.getString("name"),
+                                description = if (!descriptionStr.isNullOrEmpty()) descriptionStr else null,
+                                artwork = if (!artworkStr.isNullOrEmpty()) artworkStr else null,
+                                tracks = tracks,
+                            )
+                        playlists[playlist.id] = playlist
+                    }
+                }
+                currentPlaylistId = sharedPreferences.getString("currentPlaylistId", null)
+            }
+        } catch (e: Exception) {
+            e.printStackTrace()
+        }
+    }
+}

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

@@ -0,0 +1,94 @@
+package com.margelo.nitro.nitroplayer.queue
+
+import com.margelo.nitro.nitroplayer.TrackItem
+import java.util.concurrent.CopyOnWriteArrayList
+
+/**
+ * Queue class that manages a list of tracks.
+ * Thread-safe implementation using CopyOnWriteArrayList.
+ */
+class Queue {
+    private val tracks: MutableList<TrackItem> = CopyOnWriteArrayList()
+
+    /**
+     * Get all tracks in the queue
+     */
+    fun getTracks(): List<TrackItem> = tracks.toList()
+
+    /**
+     * Get tracks as an array (for compatibility with existing API)
+     */
+    fun getTracksArray(): Array<TrackItem> = tracks.toTypedArray()
+
+    /**
+     * Add a single track to the queue
+     */
+    fun addTrack(track: TrackItem) {
+        tracks.add(track)
+    }
+
+    /**
+     * Add a track at a specific index
+     */
+    fun addTrackAtIndex(
+        track: TrackItem,
+        index: Int,
+    ) {
+        if (index < 0 || index > tracks.size) {
+            tracks.add(track)
+        } else {
+            tracks.add(index, track)
+        }
+    }
+
+    /**
+     * Load multiple tracks into the queue (replaces existing queue)
+     */
+    fun loadTracks(newTracks: List<TrackItem>) {
+        tracks.clear()
+        tracks.addAll(newTracks)
+    }
+
+    /**
+     * Remove a track by ID
+     * @return true if track was found and removed, false otherwise
+     */
+    fun removeTrack(id: String): Boolean = tracks.removeAll { it.id == id }
+
+    /**
+     * Clear all tracks from the queue
+     */
+    fun clear() {
+        tracks.clear()
+    }
+
+    /**
+     * Get the size of the queue
+     */
+    fun size(): Int = tracks.size
+
+    /**
+     * Check if the queue is empty
+     */
+    fun isEmpty(): Boolean = tracks.isEmpty()
+
+    /**
+     * Get a track by index
+     */
+    fun getTrack(index: Int): TrackItem? =
+        if (index >= 0 && index < tracks.size) {
+            tracks[index]
+        } else {
+            null
+        }
+
+    /**
+     * Get a track by ID
+     */
+    fun getTrackById(id: String): TrackItem? = tracks.find { it.id == id }
+
+    /**
+     * Get the index of a track by ID
+     */
+    fun getTrackIndex(id: String): Int = tracks.indexOfFirst { it.id == id }
+}

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

@@ -0,0 +1,143 @@
+package com.margelo.nitro.nitroplayer.queue
+
+import com.margelo.nitro.nitroplayer.QueueOperation
+import com.margelo.nitro.nitroplayer.TrackItem
+import java.util.concurrent.CopyOnWriteArrayList
+
+/**
+ * QueueManager is a singleton that manages the queue state across the app session.
+ * It provides thread-safe access to the queue and notifies listeners of queue changes.
+ */
+class QueueManager private constructor() {
+    private val queue = Queue()
+    private val listeners = CopyOnWriteArrayList<(List<TrackItem>, QueueOperation?) -> Unit>()
+
+    companion object {
+        @Volatile
+        @Suppress("ktlint:standard:property-naming")
+        private var INSTANCE: QueueManager? = null
+
+        /**
+         * Get the singleton instance of QueueManager
+         */
+        @JvmStatic
+        fun getInstance(): QueueManager =
+            INSTANCE ?: synchronized(this) {
+                INSTANCE ?: QueueManager().also { INSTANCE = it }
+            }
+    }
+
+    /**
+     * Get the current queue
+     */
+    fun getQueue(): Queue = queue
+
+    /**
+     * Get all tracks in the queue
+     */
+    fun getTracks(): List<TrackItem> = queue.getTracks()
+
+    /**
+     * Get tracks as an array
+     */
+    fun getTracksArray(): Array<TrackItem> = queue.getTracksArray()
+
+    /**
+     * Load multiple tracks into the queue (replaces existing queue)
+     */
+    fun loadQueue(tracks: Array<TrackItem>) {
+        queue.loadTracks(tracks.toList())
+        notifyListeners(QueueOperation.ADD)
+    }
+
+    /**
+     * Load a single track at a specific index
+     */
+    fun loadSingleTrack(
+        track: TrackItem,
+        index: Double?,
+    ) {
+        val insertIndex = index?.toInt()
+        if (insertIndex != null && insertIndex >= 0) {
+            queue.addTrackAtIndex(track, insertIndex)
+        } else {
+            queue.addTrack(track)
+        }
+        notifyListeners(QueueOperation.ADD)
+    }
+
+    /**
+     * Delete a track by ID
+     */
+    fun deleteTrack(id: String) {
+        val removed = queue.removeTrack(id)
+        if (removed) {
+            notifyListeners(QueueOperation.REMOVE)
+        }
+    }
+
+    /**
+     * Clear all tracks from the queue
+     */
+    fun clearQueue() {
+        queue.clear()
+        notifyListeners(QueueOperation.CLEAR)
+    }
+
+    /**
+     * Add a listener for queue changes
+     * @param listener Callback that receives (queue, operation)
+     * @return A function to remove the listener
+     */
+    fun addQueueChangeListener(listener: (List<TrackItem>, QueueOperation?) -> Unit): () -> Unit {
+        listeners.add(listener)
+        return { listeners.remove(listener) }
+    }
+
+    /**
+     * Remove a queue change listener
+     */
+    fun removeQueueChangeListener(listener: (List<TrackItem>, QueueOperation?) -> Unit) {
+        listeners.remove(listener)
+    }
+
+    /**
+     * Notify all listeners of queue changes
+     */
+    private fun notifyListeners(operation: QueueOperation?) {
+        val currentTracks = queue.getTracks()
+        listeners.forEach { listener ->
+            try {
+                listener(currentTracks, operation)
+            } catch (e: Exception) {
+                // Log error but don't break other listeners
+                e.printStackTrace()
+            }
+        }
+    }
+
+    /**
+     * Get queue size
+     */
+    fun getQueueSize(): Int = queue.size()
+
+    /**
+     * Check if queue is empty
+     */
+    fun isQueueEmpty(): Boolean = queue.isEmpty()
+
+    /**
+     * Get a track by index
+     */
+    fun getTrack(index: Int): TrackItem? = queue.getTrack(index)
+
+    /**
+     * Get a track by ID
+     */
+    fun getTrackById(id: String): TrackItem? = queue.getTrackById(id)
+
+    /**
+     * Get the index of a track by ID
+     */
+    fun getTrackIndex(id: String): Int = queue.getTrackIndex(id)
+}