react-native-nitro-player 0.5.3 → 0.5.5

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

@@ -1,20 +1,18 @@
 package com.margelo.nitro.nitroplayer.playlist
 
 import android.content.Context
-import android.content.SharedPreferences
-import com.margelo.nitro.core.NullType
+import com.margelo.nitro.core.AnyMap
 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 com.margelo.nitro.nitroplayer.storage.NitroPlayerStorage
 import org.json.JSONArray
 import org.json.JSONObject
 import java.util.UUID
 import java.util.concurrent.CopyOnWriteArrayList
 
-import com.margelo.nitro.core.AnyMap
-
 /**
  * Manages multiple playlists using ExoPlayer's native playlist functionality
  * Based on: https://developer.android.com/media/media3/exoplayer/playlists
@@ -27,14 +25,22 @@ class PlaylistManager private constructor(
     private val playlistListeners = mutableMapOf<String, CopyOnWriteArrayList<(Playlist, QueueOperation?) -> Unit>>()
     private var currentPlaylistId: String? = null
 
-    private val sharedPreferences: SharedPreferences =
-        context.getSharedPreferences("NitroPlayerPlaylists", Context.MODE_PRIVATE)
+    private val saveHandler = android.os.Handler(android.os.Looper.getMainLooper())
+    private val saveRunnable = Runnable { saveToFile() }
+
+    private fun scheduleSave() {
+        saveHandler.removeCallbacks(saveRunnable)
+        saveHandler.postDelayed(saveRunnable, 300)
+    }
 
     companion object {
         @Volatile
         @Suppress("ktlint:standard:property-naming")
         private var INSTANCE: PlaylistManager? = null
 
+        // Legacy SharedPreferences name (migration only)
+        private const val LEGACY_PREFS_NAME = "NitroPlayerPlaylists"
+
         @JvmStatic
         fun getInstance(context: Context): PlaylistManager =
             INSTANCE ?: synchronized(this) {
@@ -43,7 +49,7 @@ class PlaylistManager private constructor(
     }
 
     init {
-        // Don't load from preferences on init - only load when Android Auto needs it
+        // Don't load from file on init - only load when Android Auto needs it
     }
 
     /**
@@ -63,7 +69,7 @@ class PlaylistManager private constructor(
 
         // Only cache for Android Auto if connected
         if (NitroPlayerMediaBrowserService.isAndroidAutoConnected) {
-            savePlaylistsToPreferences()
+            scheduleSave()
         }
         notifyPlaylistsChanged(QueueOperation.ADD)
         NitroPlayerMediaBrowserService.getInstance()?.onPlaylistsUpdated()
@@ -87,7 +93,7 @@ class PlaylistManager private constructor(
             playlistListeners.remove(playlistId)
             // Only cache for Android Auto if connected
             if (NitroPlayerMediaBrowserService.isAndroidAutoConnected) {
-                savePlaylistsToPreferences()
+                scheduleSave()
             }
             notifyPlaylistsChanged(QueueOperation.REMOVE)
             NitroPlayerMediaBrowserService.getInstance()?.onPlaylistsUpdated()
@@ -122,7 +128,7 @@ class PlaylistManager private constructor(
 
         // Only cache for Android Auto if connected
         if (NitroPlayerMediaBrowserService.isAndroidAutoConnected) {
-            savePlaylistsToPreferences()
+            scheduleSave()
         }
         notifyPlaylistChanged(playlistId, QueueOperation.UPDATE)
         notifyPlaylistsChanged(QueueOperation.UPDATE)
@@ -172,7 +178,7 @@ class PlaylistManager private constructor(
 
         // Only cache for Android Auto if connected
         if (NitroPlayerMediaBrowserService.isAndroidAutoConnected) {
-            savePlaylistsToPreferences()
+            scheduleSave()
         }
         notifyPlaylistChanged(playlistId, QueueOperation.ADD)
         NitroPlayerMediaBrowserService.getInstance()?.onPlaylistUpdated(playlistId)
@@ -210,7 +216,7 @@ class PlaylistManager private constructor(
 
         // Only cache for Android Auto if connected
         if (NitroPlayerMediaBrowserService.isAndroidAutoConnected) {
-            savePlaylistsToPreferences()
+            scheduleSave()
         }
         notifyPlaylistChanged(playlistId, QueueOperation.ADD)
         NitroPlayerMediaBrowserService.getInstance()?.onPlaylistUpdated(playlistId)
@@ -246,7 +252,7 @@ class PlaylistManager private constructor(
             }
 
         if (removed) {
-            savePlaylistsToPreferences()
+            scheduleSave()
             notifyPlaylistChanged(playlistId, QueueOperation.REMOVE)
             NitroPlayerMediaBrowserService.getInstance()?.onPlaylistUpdated(playlistId)
 
@@ -284,7 +290,7 @@ class PlaylistManager private constructor(
             playlists[playlistId] = playlist.copy(tracks = tracks)
         }
 
-        savePlaylistsToPreferences()
+        scheduleSave()
         notifyPlaylistChanged(playlistId, QueueOperation.UPDATE)
         NitroPlayerMediaBrowserService.getInstance()?.onPlaylistUpdated(playlistId)
 
@@ -361,7 +367,9 @@ class PlaylistManager private constructor(
         playlistListeners[playlistId]?.forEach { it(playlist, operation) }
     }
 
-    private fun savePlaylistsToPreferences() {
+    // MARK: - Persistence
+
+    private fun saveToFile() {
         try {
             val jsonArray = JSONArray()
             synchronized(playlists) {
@@ -383,7 +391,6 @@ class PlaylistManager private constructor(
                                         put("duration", track.duration)
                                         put("url", track.url)
                                         track.artwork?.let { put("artwork", it) }
-                                        // Serialize extraPayload to JSON for persistence
                                         track.extraPayload?.let { payload ->
                                             val extraPayloadMap = payload.toHashMap()
                                             val extraPayloadJson = JSONObject(extraPayloadMap)
@@ -398,84 +405,111 @@ class PlaylistManager private constructor(
                 }
             }
 
-            sharedPreferences
-                .edit()
-                .putString("playlists", jsonArray.toString())
-                .putString("currentPlaylistId", currentPlaylistId)
-                .apply()
+            val wrapper = JSONObject().apply {
+                put("playlists", jsonArray)
+                put("currentPlaylistId", currentPlaylistId)
+            }
+            NitroPlayerStorage.write(context, "playlists.json", wrapper.toString())
         } 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
-                                }
-                            // Deserialize extraPayload from JSON
-                            val extraPayload: AnyMap? =
-                                if (trackObj.has("extraPayload")) {
-                                    val extraPayloadJson = trackObj.getJSONObject("extraPayload")
-                                    val map = AnyMap()
-                                    val keyIterator = extraPayloadJson.keys()
-                                    while (keyIterator.hasNext()) {
-                                        val key = keyIterator.next()
-                                        when (val value = extraPayloadJson.get(key)) {
-                                            is String -> map.setString(key, value)
-                                            is Number -> map.setDouble(key, value.toDouble())
-                                            is Boolean -> map.setBoolean(key, value)
-                                        }
-                                    }
-                                    map
-                                } else {
-                                    null
+    fun loadPlaylistsFromFile() {
+        // 1. Try new JSON file (post-migration)
+        val json = NitroPlayerStorage.read(context, "playlists.json")
+        if (json != null) {
+            try {
+                val wrapper = JSONObject(json)
+                val jsonArray = wrapper.optJSONArray("playlists") ?: JSONArray()
+                parseAndLoadPlaylists(jsonArray)
+                currentPlaylistId = if (wrapper.isNull("currentPlaylistId")) null
+                                    else wrapper.optString("currentPlaylistId", null.toString()).takeIf { it != "null" }
+            } catch (e: Exception) {
+                e.printStackTrace()
+            }
+            return
+        }
+
+        // 2. Migrate from SharedPreferences (one-time, existing installs)
+        val prefs = context.getSharedPreferences(LEGACY_PREFS_NAME, Context.MODE_PRIVATE)
+        val legacyJson = prefs.getString("playlists", null)
+        if (legacyJson != null) {
+            try {
+                val jsonArray = JSONArray(legacyJson)
+                parseAndLoadPlaylists(jsonArray)
+                currentPlaylistId = prefs.getString("currentPlaylistId", null)
+                // Remove old SharedPreferences data to free space
+                prefs.edit().remove("playlists").remove("currentPlaylistId").apply()
+                // Persist in new format
+                saveToFile()
+            } catch (e: Exception) {
+                e.printStackTrace()
+            }
+            return
+        }
+
+        // 3. Fresh install — nothing to load
+    }
+
+    private fun parseAndLoadPlaylists(jsonArray: JSONArray) {
+        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
+                        }
+                    val extraPayload: AnyMap? =
+                        if (trackObj.has("extraPayload")) {
+                            val extraPayloadJson = trackObj.getJSONObject("extraPayload")
+                            val map = AnyMap()
+                            val keyIterator = extraPayloadJson.keys()
+                            while (keyIterator.hasNext()) {
+                                val key = keyIterator.next()
+                                when (val value = extraPayloadJson.get(key)) {
+                                    is String -> map.setString(key, value)
+                                    is Number -> map.setDouble(key, value.toDouble())
+                                    is Boolean -> map.setBoolean(key, value)
                                 }
-                            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,
-                                    extraPayload = extraPayload,
-                                ),
-                            )
+                            }
+                            map
+                        } else {
+                            null
                         }
-                        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
-                    }
+                    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,
+                            extraPayload = extraPayload,
+                        ),
+                    )
                 }
-                currentPlaylistId = sharedPreferences.getString("currentPlaylistId", null)
+                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
             }
-        } catch (e: Exception) {
-            e.printStackTrace()
         }
     }
 }

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

@@ -0,0 +1,50 @@
+package com.margelo.nitro.nitroplayer.storage
+
+import android.content.Context
+import com.margelo.nitro.nitroplayer.core.NitroPlayerLogger
+import java.io.File
+
+object NitroPlayerStorage {
+    private const val TAG = "NitroPlayerStorage"
+    private const val DIR_NAME = "nitroplayer"
+
+    /** Reads the contents of [filename] from the NitroPlayer storage directory, or null if absent. */
+    fun read(context: Context, filename: String): String? {
+        val file = File(storageDirectory(context), filename)
+        return if (file.exists()) {
+            try {
+                file.readText()
+            } catch (e: Exception) {
+                NitroPlayerLogger.log(TAG, "read($filename) failed: $e")
+                null
+            }
+        } else {
+            null
+        }
+    }
+
+    /**
+     * Atomically writes [json] to [filename] in the NitroPlayer storage directory.
+     * Writes to `<filename>.tmp` first, then renames — leaving the prior file
+     * untouched on failure (crash-safe).
+     */
+    fun write(context: Context, filename: String, json: String) {
+        try {
+            val dir = storageDirectory(context)
+            dir.mkdirs()
+            val tmp = File(dir, "$filename.tmp")
+            val dest = File(dir, filename)
+            tmp.writeText(json)
+            if (!tmp.renameTo(dest)) {
+                // renameTo can fail across mount points; copy then delete as fallback
+                dest.writeText(tmp.readText())
+                tmp.delete()
+            }
+        } catch (e: Exception) {
+            NitroPlayerLogger.log(TAG, "write($filename) failed: $e")
+        }
+    }
+
+    /** Returns the NitroPlayer subdirectory inside filesDir. */
+    private fun storageDirectory(context: Context): File = File(context.filesDir, DIR_NAME)
+}

package/ios/HybridAudioRoutePicker.swift

@@ -30,7 +30,7 @@ class HybridAudioRoutePicker: HybridAudioRoutePickerSpec {
           .flatMap({ $0.windows })
           .first(where: { $0.isKeyWindow })
       else {
-        print("HybridAudioRoutePicker: Could not find key window")
+        NitroPlayerLogger.log("HybridAudioRoutePicker", "Could not find key window")
         return
       }
 

package/ios/HybridDownloadManager.swift

@@ -208,19 +208,19 @@ final class HybridDownloadManager: HybridDownloadManagerSpec {
   // MARK: - Event Callbacks
 
   func onDownloadProgress(callback: @escaping (DownloadProgress) -> Void) throws {
-    print("🎯 HybridDownloadManager: onDownloadProgress callback registered")
+    NitroPlayerLogger.log("HybridDownloadManager", "onDownloadProgress callback registered")
     core.addProgressCallback(callback)
   }
 
   func onDownloadStateChange(
     callback: @escaping (String, String, DownloadState, DownloadError?) -> Void
   ) throws {
-    print("🎯 HybridDownloadManager: onDownloadStateChange callback registered")
+    NitroPlayerLogger.log("HybridDownloadManager", "onDownloadStateChange callback registered")
     core.addStateChangeCallback(callback)
   }
 
   func onDownloadComplete(callback: @escaping (DownloadedTrack) -> Void) throws {
-    print("🎯 HybridDownloadManager: onDownloadComplete callback registered")
+    NitroPlayerLogger.log("HybridDownloadManager", "onDownloadComplete callback registered")
     core.addCompleteCallback(callback)
   }
 }

package/ios/HybridEqualizer.swift

@@ -95,17 +95,17 @@ final class HybridEqualizer: HybridEqualizerSpec {
   // MARK: - Event Callbacks
 
   func onEnabledChange(callback: @escaping (Bool) -> Void) throws {
-    print("🎯 HybridEqualizer: onEnabledChange callback registered")
+    NitroPlayerLogger.log("HybridEqualizer", "onEnabledChange callback registered")
     core.addOnEnabledChangeListener(owner: self, callback)
   }
 
   func onBandChange(callback: @escaping ([EqualizerBand]) -> Void) throws {
-    print("🎯 HybridEqualizer: onBandChange callback registered")
+    NitroPlayerLogger.log("HybridEqualizer", "onBandChange callback registered")
     core.addOnBandChangeListener(owner: self, callback)
   }
 
   func onPresetChange(callback: @escaping (Variant_NullType_String?) -> Void) throws {
-    print("🎯 HybridEqualizer: onPresetChange callback registered")
+    NitroPlayerLogger.log("HybridEqualizer", "onPresetChange callback registered")
     core.addOnPresetChangeListener(owner: self, callback)
   }
 }

package/ios/HybridTrackPlayer.swift

@@ -78,6 +78,10 @@ final class HybridTrackPlayer: HybridTrackPlayerSpec {
     return core.setRepeatMode(mode: mode)
   }
 
+  func getRepeatMode() throws -> RepeatMode {
+    return core.getRepeatMode()
+  }
+
   // MARK: - Configuration
 
   func configure(config: PlayerConfig) throws {
@@ -91,22 +95,22 @@ final class HybridTrackPlayer: HybridTrackPlayerSpec {
   // MARK: - Event Callbacks
 
   func onChangeTrack(callback: @escaping (TrackItem, Reason?) -> Void) throws {
-    print("🎯 HybridTrackPlayer: onChangeTrack callback registered")
+    NitroPlayerLogger.log("HybridTrackPlayer", "onChangeTrack callback registered")
     core.addOnChangeTrackListener(owner: self, callback)
   }
 
   func onPlaybackStateChange(callback: @escaping (TrackPlayerState, Reason?) -> Void) throws {
-    print("🎯 HybridTrackPlayer: onPlaybackStateChange callback registered")
+    NitroPlayerLogger.log("HybridTrackPlayer", "onPlaybackStateChange callback registered")
     core.addOnPlaybackStateChangeListener(owner: self, callback)
   }
 
   func onSeek(callback: @escaping (Double, Double) -> Void) throws {
-    print("🎯 HybridTrackPlayer: onSeek callback registered")
+    NitroPlayerLogger.log("HybridTrackPlayer", "onSeek callback registered")
     core.addOnSeekListener(owner: self, callback)
   }
 
   func onPlaybackProgressChange(callback: @escaping (Double, Double, Bool?) -> Void) throws {
-    print("🎯 HybridTrackPlayer: onPlaybackProgressChange callback registered")
+    NitroPlayerLogger.log("HybridTrackPlayer", "onPlaybackProgressChange callback registered")
     core.addOnPlaybackProgressChangeListener(owner: self, callback)
   }
 

package/ios/core/NitroPlayerLogger.swift

@@ -0,0 +1,22 @@
+//
+//  Logger.swift
+//  NitroPlayer
+//
+//  Created by Ritesh Shukla on 18/02/26.
+//
+
+import Foundation
+
+class NitroPlayerLogger {
+    #if DEBUG
+    static var isEnabled = true
+    #else
+    static var isEnabled = false
+    #endif
+
+    static func log(_ header: String = "NitroPlayer", _ message: @autoclosure () -> String) {
+        if isEnabled {
+            print("[\(header)] \(message())")
+        }
+    }
+}