react-native-nitro-player 0.5.3 → 0.5.4

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

@@ -5,6 +5,7 @@ import android.content.SharedPreferences
 import android.util.Log
 import com.margelo.nitro.core.NullType
 import com.margelo.nitro.nitroplayer.*
+import com.margelo.nitro.nitroplayer.core.NitroPlayerLogger
 import com.margelo.nitro.nitroplayer.playlist.PlaylistManager
 import org.json.JSONArray
 import org.json.JSONObject
@@ -253,13 +254,13 @@ class DownloadDatabase private constructor(
     /** Validates all downloads and removes records for missing files */
     fun syncDownloads(): Int {
         synchronized(this) {
-            Log.d(TAG, "syncDownloads called")
+            NitroPlayerLogger.log("DownloadDatabase", "syncDownloads called")
 
             val trackIdsToRemove = mutableListOf<String>()
 
             for ((trackId, record) in downloadedTracks) {
                 if (!File(record.localPath).exists()) {
-                    Log.d(TAG, "Missing file for track $trackId: ${record.localPath}")
+                    NitroPlayerLogger.log("DownloadDatabase", "Missing file for track $trackId: ${record.localPath}")
                     trackIdsToRemove.add(trackId)
                 }
             }
@@ -282,9 +283,9 @@ class DownloadDatabase private constructor(
 
             if (trackIdsToRemove.isNotEmpty()) {
                 saveToDisk()
-                Log.d(TAG, "Cleaned up ${trackIdsToRemove.size} orphaned records")
+                NitroPlayerLogger.log("DownloadDatabase", "Cleaned up ${trackIdsToRemove.size} orphaned records")
             } else {
-                Log.d(TAG, "All downloads are valid")
+                NitroPlayerLogger.log("DownloadDatabase", "All downloads are valid")
             }
 
             return trackIdsToRemove.size
@@ -432,7 +433,7 @@ internal data class DownloadedTrackRecord(
                 trackId = json.getString("trackId"),
                 originalTrack = TrackItemRecord.fromJson(json.getJSONObject("originalTrack")),
                 localPath = json.getString("localPath"),
-                localArtworkPath = json.optString("localArtworkPath", null),
+                localArtworkPath = if (json.isNull("localArtworkPath")) null else json.getString("localArtworkPath"),
                 downloadedAt = json.getDouble("downloadedAt"),
                 fileSize = json.getDouble("fileSize"),
                 storageLocation = json.getString("storageLocation"),
@@ -469,7 +470,7 @@ internal data class TrackItemRecord(
                 album = json.getString("album"),
                 duration = json.getDouble("duration"),
                 url = json.getString("url"),
-                artwork = json.optString("artwork", null),
+                artwork = if (json.isNull("artwork")) null else json.getString("artwork"),
             )
     }
 }

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

@@ -7,6 +7,7 @@ import android.util.Log
 import androidx.work.*
 import com.margelo.nitro.core.NullType
 import com.margelo.nitro.nitroplayer.*
+import com.margelo.nitro.nitroplayer.core.NitroPlayerLogger
 import java.util.*
 import java.util.concurrent.ConcurrentHashMap
 import java.util.concurrent.CopyOnWriteArrayList
@@ -289,7 +290,7 @@ class DownloadManagerCore private constructor(
     fun syncDownloads(): Int {
         val removedCount = database.syncDownloads()
         val bytesFreed = fileManager.cleanupOrphanedFiles(database.getAllDownloadedTracks().map { it.trackId }.toSet())
-        Log.d(TAG, "syncDownloads: removed $removedCount orphaned records, freed $bytesFreed bytes")
+        NitroPlayerLogger.log("DownloadManagerCore", "syncDownloads: removed $removedCount orphaned records, freed $bytesFreed bytes")
         return removedCount
     }
 

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

@@ -4,11 +4,11 @@ import android.app.NotificationChannel
 import android.app.NotificationManager
 import android.content.Context
 import android.os.Build
+import android.webkit.MimeTypeMap
 import androidx.core.app.NotificationCompat
 import androidx.work.CoroutineWorker
 import androidx.work.ForegroundInfo
 import androidx.work.WorkerParameters
-import android.webkit.MimeTypeMap
 import com.margelo.nitro.nitroplayer.*
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.withContext
@@ -149,7 +149,6 @@ class DownloadWorker(
 
                 val finalExtension = if (extension.isNullOrEmpty()) "mp3" else extension
 
-
                 // Create destination file
                 val destinationFile = fileManager.createDownloadFile(trackId, storageLocation, finalExtension)
 

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

@@ -11,6 +11,7 @@ import com.margelo.nitro.nitroplayer.EqualizerState
 import com.margelo.nitro.nitroplayer.GainRange
 import com.margelo.nitro.nitroplayer.PresetType
 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
@@ -99,7 +100,7 @@ class EqualizerCore private constructor(
             setupBandMapping()
             restoreSettings()
         } catch (e: Exception) {
-            Log.e(TAG, "Failed to initialize equalizer: ${e.message}")
+            NitroPlayerLogger.log("EqualizerCore", "Failed to initialize equalizer: ${e.message}")
         }
     }
 
@@ -144,7 +145,7 @@ class EqualizerCore private constructor(
             saveEnabled(enabled)
             true
         } catch (e: Exception) {
-            Log.e(TAG, "Failed to set enabled: ${e.message}")
+            NitroPlayerLogger.log("EqualizerCore", "Failed to set enabled: ${e.message}")
             false
         }
     }

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

@@ -10,6 +10,7 @@ import android.support.v4.media.MediaDescriptionCompat
 import androidx.media.MediaBrowserServiceCompat
 import androidx.media.utils.MediaConstants
 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.playlist.Playlist
 import kotlinx.coroutines.CoroutineScope
@@ -53,23 +54,23 @@ class NitroPlayerMediaBrowserService : MediaBrowserServiceCompat() {
                 sessionToken =
                     android.support.v4.media.session.MediaSessionCompat.Token
                         .fromToken(session.platformToken)
-                println("🎵 NitroPlayerMediaBrowserService: MediaSession token set successfully")
+                NitroPlayerLogger.log("MediaBrowserService", "🎵 NitroPlayerMediaBrowserService: MediaSession token set successfully")
             } else {
-                println("⚠️ NitroPlayerMediaBrowserService: MediaSession not available yet")
+                NitroPlayerLogger.log("MediaBrowserService", "⚠️ NitroPlayerMediaBrowserService: MediaSession not available yet")
             }
         } catch (e: Exception) {
-            println("❌ NitroPlayerMediaBrowserService: Error setting session token - ${e.message}")
+            NitroPlayerLogger.log("MediaBrowserService", "❌ NitroPlayerMediaBrowserService: Error setting session token - ${e.message}")
             e.printStackTrace()
         }
 
-        println("🚀 NitroPlayerMediaBrowserService: Service created")
+        NitroPlayerLogger.log("MediaBrowserService", "🚀 NitroPlayerMediaBrowserService: Service created")
     }
 
     override fun onDestroy() {
         super.onDestroy()
         instance = null
         serviceScope.cancel()
-        println("🛑 NitroPlayerMediaBrowserService: Service destroyed")
+        NitroPlayerLogger.log("MediaBrowserService", "🛑 NitroPlayerMediaBrowserService: Service destroyed")
     }
 
     override fun onGetRoot(
@@ -77,11 +78,11 @@ class NitroPlayerMediaBrowserService : MediaBrowserServiceCompat() {
         clientUid: Int,
         rootHints: Bundle?,
     ): BrowserRoot? {
-        println("📂 NitroPlayerMediaBrowserService: onGetRoot called from $clientPackageName")
+        NitroPlayerLogger.log("MediaBrowserService", "📂 NitroPlayerMediaBrowserService: onGetRoot called from $clientPackageName")
 
         // Check if Android Auto is enabled
         if (!isAndroidAutoEnabled) {
-            println("⚠️ NitroPlayerMediaBrowserService: Android Auto not enabled")
+            NitroPlayerLogger.log("MediaBrowserService", "⚠️ NitroPlayerMediaBrowserService: Android Auto not enabled")
             return BrowserRoot(EMPTY_ROOT_ID, null)
         }
 
@@ -94,7 +95,7 @@ class NitroPlayerMediaBrowserService : MediaBrowserServiceCompat() {
                     MediaConstants.DESCRIPTION_EXTRAS_VALUE_CONTENT_STYLE_GRID_ITEM,
                 )
             }
-        println("✅ NitroPlayerMediaBrowserService: Allowing connection from $clientPackageName with grid layout")
+        NitroPlayerLogger.log("MediaBrowserService", "✅ NitroPlayerMediaBrowserService: Allowing connection from $clientPackageName with grid layout")
         return BrowserRoot(ROOT_ID, extras)
     }
 
@@ -102,10 +103,10 @@ class NitroPlayerMediaBrowserService : MediaBrowserServiceCompat() {
         parentId: String,
         result: Result<MutableList<MediaBrowserCompat.MediaItem>>,
     ) {
-        println("📂 NitroPlayerMediaBrowserService: onLoadChildren called for parentId: $parentId")
+        NitroPlayerLogger.log("MediaBrowserService", "📂 NitroPlayerMediaBrowserService: onLoadChildren called for parentId: $parentId")
 
         if (!isAndroidAutoEnabled) {
-            println("⚠️ NitroPlayerMediaBrowserService: Android Auto not enabled, returning empty")
+            NitroPlayerLogger.log("MediaBrowserService", "⚠️ NitroPlayerMediaBrowserService: Android Auto not enabled, returning empty")
             result.sendResult(mutableListOf())
             return
         }
@@ -121,7 +122,7 @@ class NitroPlayerMediaBrowserService : MediaBrowserServiceCompat() {
 
                         if (library == null) {
                             // Fallback: show playlists if no media library is set
-                            println("⚠️ NitroPlayerMediaBrowserService: No media library set, using fallback playlists")
+                            NitroPlayerLogger.log("MediaBrowserService", "⚠️ NitroPlayerMediaBrowserService: No media library set, using fallback playlists")
                             val mediaItems = loadFallbackPlaylists()
                             result.sendResult(mediaItems)
                             return@launch
@@ -133,10 +134,10 @@ class NitroPlayerMediaBrowserService : MediaBrowserServiceCompat() {
                             mediaItems.add(convertToMediaBrowserItem(item, library.layoutType))
                         }
 
-                        println("✅ NitroPlayerMediaBrowserService: Returning ${mediaItems.size} root items")
+                        NitroPlayerLogger.log("MediaBrowserService", "✅ NitroPlayerMediaBrowserService: Returning ${mediaItems.size} root items")
                         result.sendResult(mediaItems)
                     } catch (e: Exception) {
-                        println("❌ NitroPlayerMediaBrowserService: Error loading root items - ${e.message}")
+                        NitroPlayerLogger.log("MediaBrowserService", "❌ NitroPlayerMediaBrowserService: Error loading root items - ${e.message}")
                         e.printStackTrace()
                         result.sendResult(mutableListOf())
                     }
@@ -154,7 +155,7 @@ class NitroPlayerMediaBrowserService : MediaBrowserServiceCompat() {
                         val playlist = trackPlayerCore?.getPlaylistManager()?.getPlaylist(playlistId)
 
                         if (playlist == null) {
-                            println("⚠️ NitroPlayerMediaBrowserService: Playlist '$playlistId' not found")
+                            NitroPlayerLogger.log("MediaBrowserService", "⚠️ NitroPlayerMediaBrowserService: Playlist '$playlistId' not found")
                             result.sendResult(mutableListOf())
                             return@launch
                         }
@@ -188,10 +189,10 @@ class NitroPlayerMediaBrowserService : MediaBrowserServiceCompat() {
                             )
                         }
 
-                        println("✅ NitroPlayerMediaBrowserService: Returning ${mediaItems.size} tracks from playlist '$playlistId'")
+                        NitroPlayerLogger.log("MediaBrowserService", "✅ NitroPlayerMediaBrowserService: Returning ${mediaItems.size} tracks from playlist '$playlistId'")
                         result.sendResult(mediaItems)
                     } catch (e: Exception) {
-                        println("❌ NitroPlayerMediaBrowserService: Error loading playlist tracks - ${e.message}")
+                        NitroPlayerLogger.log("MediaBrowserService", "❌ NitroPlayerMediaBrowserService: Error loading playlist tracks - ${e.message}")
                         e.printStackTrace()
                         result.sendResult(mutableListOf())
                     }
@@ -211,7 +212,7 @@ class NitroPlayerMediaBrowserService : MediaBrowserServiceCompat() {
                         val children = mediaLibraryManager.getChildrenById(parentId)
 
                         if (children == null) {
-                            println("⚠️ NitroPlayerMediaBrowserService: No children found for parentId: $parentId")
+                            NitroPlayerLogger.log("MediaBrowserService", "⚠️ NitroPlayerMediaBrowserService: No children found for parentId: $parentId")
                             result.sendResult(mutableListOf())
                             return@launch
                         }
@@ -224,10 +225,10 @@ class NitroPlayerMediaBrowserService : MediaBrowserServiceCompat() {
                                     convertToMediaBrowserItem(item, defaultLayout)
                                 }.toMutableList()
 
-                        println("✅ NitroPlayerMediaBrowserService: Returning ${mediaItems.size} items for parentId: $parentId")
+                        NitroPlayerLogger.log("MediaBrowserService", "✅ NitroPlayerMediaBrowserService: Returning ${mediaItems.size} items for parentId: $parentId")
                         result.sendResult(mediaItems)
                     } catch (e: Exception) {
-                        println("❌ NitroPlayerMediaBrowserService: Error loading children - ${e.message}")
+                        NitroPlayerLogger.log("MediaBrowserService", "❌ NitroPlayerMediaBrowserService: Error loading children - ${e.message}")
                         e.printStackTrace()
                         result.sendResult(mutableListOf())
                     }
@@ -239,18 +240,18 @@ class NitroPlayerMediaBrowserService : MediaBrowserServiceCompat() {
     fun onPlaylistsUpdated() {
         try {
             notifyChildrenChanged(ROOT_ID)
-            println("📢 NitroPlayerMediaBrowserService: Notified Android Auto of playlist update")
+            NitroPlayerLogger.log("MediaBrowserService", "📢 NitroPlayerMediaBrowserService: Notified Android Auto of playlist update")
         } catch (e: Exception) {
-            println("⚠️ NitroPlayerMediaBrowserService: Error notifying children changed: ${e.message}")
+            NitroPlayerLogger.log("MediaBrowserService", "⚠️ NitroPlayerMediaBrowserService: Error notifying children changed: ${e.message}")
         }
     }
 
     fun onPlaylistUpdated(playlistId: String) {
         try {
             notifyChildrenChanged("$PLAYLIST_PREFIX$playlistId")
-            println("📢 NitroPlayerMediaBrowserService: Notified Android Auto of playlist '$playlistId' update")
+            NitroPlayerLogger.log("MediaBrowserService", "📢 NitroPlayerMediaBrowserService: Notified Android Auto of playlist '$playlistId' update")
         } catch (e: Exception) {
-            println("⚠️ NitroPlayerMediaBrowserService: Error notifying playlist changed: ${e.message}")
+            NitroPlayerLogger.log("MediaBrowserService", "⚠️ NitroPlayerMediaBrowserService: Error notifying playlist changed: ${e.message}")
         }
     }
 
@@ -348,7 +349,7 @@ class NitroPlayerMediaBrowserService : MediaBrowserServiceCompat() {
             )
         }
 
-        println("✅ NitroPlayerMediaBrowserService: Loaded ${mediaItems.size} playlists as fallback")
+        NitroPlayerLogger.log("MediaBrowserService", "✅ NitroPlayerMediaBrowserService: Loaded ${mediaItems.size} playlists as fallback")
         return mediaItems
     }
 }

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

@@ -1,6 +1,7 @@
 package com.margelo.nitro.nitroplayer.media
 
 import android.content.Context
+import com.margelo.nitro.nitroplayer.core.NitroPlayerLogger
 
 /**
  * Manages the Android Auto media library structure
@@ -27,7 +28,7 @@ class MediaLibraryManager private constructor(
      */
     fun setMediaLibrary(library: MediaLibrary) {
         mediaLibrary = library
-        println("📚 MediaLibraryManager: Media library set with ${library.rootItems.size} root items")
+        NitroPlayerLogger.log("MediaLibraryManager", "📚 MediaLibraryManager: Media library set with ${library.rootItems.size} root items")
     }
 
     /**
@@ -72,6 +73,6 @@ class MediaLibraryManager private constructor(
      */
     fun clear() {
         mediaLibrary = null
-        println("📚 MediaLibraryManager: Media library cleared")
+        NitroPlayerLogger.log("MediaLibraryManager", "📚 MediaLibraryManager: Media library cleared")
     }
 }

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

@@ -23,6 +23,7 @@ import androidx.media3.session.SessionResult
 import com.google.common.util.concurrent.Futures
 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.media.NitroPlayerMediaBrowserService
 import com.margelo.nitro.nitroplayer.playlist.PlaylistManager
@@ -114,7 +115,7 @@ class MediaSessionManager(
                                 mediaItems: MutableList<MediaItem>,
                             ): ListenableFuture<MutableList<MediaItem>> {
                                 // This is called when Android Auto requests to play a track
-                                println("🎵 MediaSessionManager: onAddMediaItems called with ${mediaItems.size} items")
+                                NitroPlayerLogger.log("MediaSessionManager", "🎵 MediaSessionManager: onAddMediaItems called with ${mediaItems.size} items")
 
                                 if (mediaItems.isEmpty()) {
                                     return Futures.immediateFuture(mutableListOf())
@@ -128,7 +129,7 @@ class MediaSessionManager(
                                         requestedMediaItem.requestMetadata.mediaUri?.toString()
                                             ?: requestedMediaItem.mediaId
 
-                                    println("🎵 MediaSessionManager: Processing mediaId: $mediaId")
+                                    NitroPlayerLogger.log("MediaSessionManager", "🎵 MediaSessionManager: Processing mediaId: $mediaId")
 
                                     try {
                                         // Parse mediaId format: "playlistId:trackId"
@@ -137,7 +138,7 @@ class MediaSessionManager(
                                             val playlistId = mediaId.substring(0, colonIndex)
                                             val trackId = mediaId.substring(colonIndex + 1)
 
-                                            println("🎵 MediaSessionManager: Parsed playlistId: $playlistId, trackId: $trackId")
+                                            NitroPlayerLogger.log("MediaSessionManager", "🎵 MediaSessionManager: Parsed playlistId: $playlistId, trackId: $trackId")
 
                                             // Get the playlist and track
                                             val playlist = playlistManager.getPlaylist(playlistId)
@@ -147,27 +148,27 @@ class MediaSessionManager(
                                                     // Create a proper MediaItem with all metadata
                                                     val resolvedMediaItem = createMediaItem(track, mediaId)
                                                     updatedMediaItems.add(resolvedMediaItem)
-                                                    println("✅ MediaSessionManager: Resolved track: ${track.title}")
+                                                    NitroPlayerLogger.log("MediaSessionManager", "✅ MediaSessionManager: Resolved track: ${track.title}")
                                                 } else {
-                                                    println("⚠️ MediaSessionManager: Track $trackId not found in playlist")
+                                                    NitroPlayerLogger.log("MediaSessionManager", "⚠️ MediaSessionManager: Track $trackId not found in playlist")
                                                     updatedMediaItems.add(requestedMediaItem)
                                                 }
                                             } else {
-                                                println("⚠️ MediaSessionManager: Playlist $playlistId not found")
+                                                NitroPlayerLogger.log("MediaSessionManager", "⚠️ MediaSessionManager: Playlist $playlistId not found")
                                                 updatedMediaItems.add(requestedMediaItem)
                                             }
                                         } else {
-                                            println("⚠️ MediaSessionManager: Invalid mediaId format: $mediaId")
+                                            NitroPlayerLogger.log("MediaSessionManager", "⚠️ MediaSessionManager: Invalid mediaId format: $mediaId")
                                             updatedMediaItems.add(requestedMediaItem)
                                         }
                                     } catch (e: Exception) {
-                                        println("❌ MediaSessionManager: Error processing mediaId - ${e.message}")
+                                        NitroPlayerLogger.log("MediaSessionManager", "❌ MediaSessionManager: Error processing mediaId - ${e.message}")
                                         e.printStackTrace()
                                         updatedMediaItems.add(requestedMediaItem)
                                     }
                                 }
 
-                                println("🎵 MediaSessionManager: Returning ${updatedMediaItems.size} resolved media items")
+                                NitroPlayerLogger.log("MediaSessionManager", "🎵 MediaSessionManager: Returning ${updatedMediaItems.size} resolved media items")
                                 return Futures.immediateFuture(updatedMediaItems)
                             }
 
@@ -179,7 +180,7 @@ class MediaSessionManager(
                                 startPositionMs: Long,
                             ): ListenableFuture<MediaSession.MediaItemsWithStartPosition> {
                                 // This is called when Android Auto wants to set and play media items
-                                println("🎵 MediaSessionManager: onSetMediaItems called with ${mediaItems.size} items, startIndex: $startIndex")
+                                NitroPlayerLogger.log("MediaSessionManager", "🎵 MediaSessionManager: onSetMediaItems called with ${mediaItems.size} items, startIndex: $startIndex")
 
                                 if (mediaItems.isEmpty()) {
                                     return Futures.immediateFuture(
@@ -194,7 +195,7 @@ class MediaSessionManager(
                                 try {
                                     // Get the first item's mediaId to determine the playlist
                                     val firstMediaId = mediaItems[0].mediaId
-                                    println("🎵 MediaSessionManager: First mediaId: $firstMediaId")
+                                    NitroPlayerLogger.log("MediaSessionManager", "🎵 MediaSessionManager: First mediaId: $firstMediaId")
 
                                     // Parse mediaId format: "playlistId:trackId"
                                     if (firstMediaId.contains(':')) {
@@ -202,7 +203,7 @@ class MediaSessionManager(
                                         val playlistId = firstMediaId.substring(0, colonIndex)
                                         val trackId = firstMediaId.substring(colonIndex + 1)
 
-                                        println("🎵 MediaSessionManager: Loading full playlist: $playlistId, starting at track: $trackId")
+                                        NitroPlayerLogger.log("MediaSessionManager", "🎵 MediaSessionManager: Loading full playlist: $playlistId, starting at track: $trackId")
 
                                         // Get the full playlist
                                         val playlist = playlistManager.getPlaylist(playlistId)
@@ -222,7 +223,7 @@ class MediaSessionManager(
                                                             createMediaItem(track, trackMediaId)
                                                         }.toMutableList()
 
-                                                println("✅ MediaSessionManager: Loaded ${playlistMediaItems.size} tracks, starting at index $trackIndex")
+                                                NitroPlayerLogger.log("MediaSessionManager", "✅ MediaSessionManager: Loaded ${playlistMediaItems.size} tracks, starting at index $trackIndex")
 
                                                 // Return the full playlist with the correct start index
                                                 return Futures.immediateFuture(
@@ -233,19 +234,19 @@ class MediaSessionManager(
                                                     ),
                                                 )
                                             } else {
-                                                println("⚠️ MediaSessionManager: Track not found in playlist")
+                                                NitroPlayerLogger.log("MediaSessionManager", "⚠️ MediaSessionManager: Track not found in playlist")
                                             }
                                         } else {
-                                            println("⚠️ MediaSessionManager: Playlist not found")
+                                            NitroPlayerLogger.log("MediaSessionManager", "⚠️ MediaSessionManager: Playlist not found")
                                         }
                                     }
                                 } catch (e: Exception) {
-                                    println("❌ MediaSessionManager: Error in onSetMediaItems - ${e.message}")
+                                    NitroPlayerLogger.log("MediaSessionManager", "❌ MediaSessionManager: Error in onSetMediaItems - ${e.message}")
                                     e.printStackTrace()
                                 }
 
                                 // Fallback: use the provided media items
-                                println("🎵 MediaSessionManager: Using fallback - provided media items")
+                                NitroPlayerLogger.log("MediaSessionManager", "🎵 MediaSessionManager: Using fallback - provided media items")
                                 return Futures.immediateFuture(
                                     MediaSession.MediaItemsWithStartPosition(
                                         mediaItems,
@@ -391,7 +392,7 @@ class MediaSessionManager(
                     .setShowActionsInCompactView(0, 1, 2),
             )
         } catch (e: Exception) {
-            Log.w("MediaSessionManager", "Failed to set media session token: ${e.message}")
+            NitroPlayerLogger.log("MediaSessionManager", "Failed to set media session token: ${e.message}")
         }
 
         // Add action buttons
@@ -500,7 +501,7 @@ class MediaSessionManager(
             try {
                 metadataBuilder.setArtworkUri(Uri.parse(artworkUrl))
             } catch (e: Exception) {
-                println("⚠️ MediaSessionManager: Invalid artwork URI: $artworkUrl")
+                NitroPlayerLogger.log("MediaSessionManager", "⚠️ MediaSessionManager: Invalid artwork URI: $artworkUrl")
             }
         }
 

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

@@ -2,6 +2,7 @@ package com.margelo.nitro.nitroplayer.playlist
 
 import android.content.Context
 import android.content.SharedPreferences
+import com.margelo.nitro.core.AnyMap
 import com.margelo.nitro.core.NullType
 import com.margelo.nitro.nitroplayer.QueueOperation
 import com.margelo.nitro.nitroplayer.TrackItem
@@ -13,8 +14,6 @@ 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
@@ -30,6 +29,14 @@ class PlaylistManager private constructor(
     private val sharedPreferences: SharedPreferences =
         context.getSharedPreferences("NitroPlayerPlaylists", Context.MODE_PRIVATE)
 
+    private val saveHandler = android.os.Handler(android.os.Looper.getMainLooper())
+    private val saveRunnable = Runnable { savePlaylistsToPreferences() }
+
+    private fun scheduleSave() {
+        saveHandler.removeCallbacks(saveRunnable)
+        saveHandler.postDelayed(saveRunnable, 300)
+    }
+
     companion object {
         @Volatile
         @Suppress("ktlint:standard:property-naming")
@@ -63,7 +70,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 +94,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 +129,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 +179,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 +217,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 +253,7 @@ class PlaylistManager private constructor(
             }
 
         if (removed) {
-            savePlaylistsToPreferences()
+            scheduleSave()
             notifyPlaylistChanged(playlistId, QueueOperation.REMOVE)
             NitroPlayerMediaBrowserService.getInstance()?.onPlaylistUpdated(playlistId)
 
@@ -284,7 +291,7 @@ class PlaylistManager private constructor(
             playlists[playlistId] = playlist.copy(tracks = tracks)
         }
 
-        savePlaylistsToPreferences()
+        scheduleSave()
         notifyPlaylistChanged(playlistId, QueueOperation.UPDATE)
         NitroPlayerMediaBrowserService.getInstance()?.onPlaylistUpdated(playlistId)
 

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)
   }
 }