react-native-nitro-player 0.5.3 → 0.5.5

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

@@ -1,26 +1,27 @@
 package com.margelo.nitro.nitroplayer.download
 
 import android.content.Context
-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 com.margelo.nitro.nitroplayer.storage.NitroPlayerStorage
 import org.json.JSONArray
 import org.json.JSONObject
 import java.io.File
 
 /**
- * Manages persistence of downloaded track metadata using SharedPreferences
+ * Manages persistence of downloaded track metadata using file storage
  */
 class DownloadDatabase private constructor(
     private val context: Context,
 ) {
     companion object {
         private const val TAG = "DownloadDatabase"
-        private const val PREFS_NAME = "NitroPlayerDownloads"
-        private const val KEY_DOWNLOADED_TRACKS = "downloaded_tracks"
-        private const val KEY_PLAYLIST_TRACKS = "playlist_tracks"
+        // Legacy SharedPreferences keys (migration only)
+        private const val LEGACY_PREFS_NAME = "NitroPlayerDownloads"
+        private const val LEGACY_KEY_DOWNLOADED_TRACKS = "downloaded_tracks"
+        private const val LEGACY_KEY_PLAYLIST_TRACKS = "playlist_tracks"
 
         @Volatile
         private var instance: DownloadDatabase? = null
@@ -31,7 +32,6 @@ class DownloadDatabase private constructor(
             }
     }
 
-    private val prefs: SharedPreferences = context.getSharedPreferences(PREFS_NAME, Context.MODE_PRIVATE)
     private val downloadedTracks = mutableMapOf<String, DownloadedTrackRecord>()
     private val playlistTracks = mutableMapOf<String, MutableSet<String>>()
     private val fileManager = DownloadFileManager.getInstance(context)
@@ -253,13 +253,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(TAG, "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(TAG, "Missing file for track $trackId: ${record.localPath}")
                     trackIdsToRemove.add(trackId)
                 }
             }
@@ -282,9 +282,9 @@ class DownloadDatabase private constructor(
 
             if (trackIdsToRemove.isNotEmpty()) {
                 saveToDisk()
-                Log.d(TAG, "Cleaned up ${trackIdsToRemove.size} orphaned records")
+                NitroPlayerLogger.log(TAG, "Cleaned up ${trackIdsToRemove.size} orphaned records")
             } else {
-                Log.d(TAG, "All downloads are valid")
+                NitroPlayerLogger.log(TAG, "All downloads are valid")
             }
 
             return trackIdsToRemove.size
@@ -294,39 +294,80 @@ class DownloadDatabase private constructor(
     // Persistence
     private fun saveToDisk() {
         try {
-            // Save downloaded tracks
             val tracksJson = JSONObject()
             for ((trackId, record) in downloadedTracks) {
                 tracksJson.put(trackId, record.toJson())
             }
-            prefs.edit().putString(KEY_DOWNLOADED_TRACKS, tracksJson.toString()).apply()
 
-            // Save playlist associations
             val playlistJson = JSONObject()
             for ((playlistId, trackIds) in playlistTracks) {
                 playlistJson.put(playlistId, JSONArray(trackIds.toList()))
             }
-            prefs.edit().putString(KEY_PLAYLIST_TRACKS, playlistJson.toString()).apply()
+
+            val wrapper = JSONObject().apply {
+                put("downloadedTracks", tracksJson)
+                put("playlistTracks", playlistJson)
+            }
+            NitroPlayerStorage.write(context, "downloads.json", wrapper.toString())
         } catch (e: Exception) {
             e.printStackTrace()
         }
     }
 
     private fun loadFromDisk() {
-        try {
-            // Load downloaded tracks
-            val tracksString = prefs.getString(KEY_DOWNLOADED_TRACKS, null)
-            if (tracksString != null) {
+        // 1. Try new JSON file (post-migration)
+        val json = NitroPlayerStorage.read(context, "downloads.json")
+        if (json != null) {
+            try {
+                val wrapper = JSONObject(json)
+
+                val tracksJson = wrapper.optJSONObject("downloadedTracks")
+                if (tracksJson != null) {
+                    for (trackId in tracksJson.keys()) {
+                        val record = DownloadedTrackRecord.fromJson(tracksJson.getJSONObject(trackId))
+                        downloadedTracks[trackId] = record
+                    }
+                }
+
+                val playlistJson = wrapper.optJSONObject("playlistTracks")
+                if (playlistJson != null) {
+                    for (playlistId in playlistJson.keys()) {
+                        val trackIdsArray = playlistJson.getJSONArray(playlistId)
+                        val trackIds = mutableSetOf<String>()
+                        for (i in 0 until trackIdsArray.length()) {
+                            trackIds.add(trackIdsArray.getString(i))
+                        }
+                        playlistTracks[playlistId] = trackIds
+                    }
+                }
+            } catch (e: Exception) {
+                e.printStackTrace()
+            }
+            return
+        }
+
+        // 2. Migrate from SharedPreferences (one-time, existing installs)
+        val prefs = context.getSharedPreferences(LEGACY_PREFS_NAME, Context.MODE_PRIVATE)
+        var didMigrate = false
+
+        val tracksString = prefs.getString(LEGACY_KEY_DOWNLOADED_TRACKS, null)
+        if (tracksString != null) {
+            try {
                 val tracksJson = JSONObject(tracksString)
                 for (trackId in tracksJson.keys()) {
                     val record = DownloadedTrackRecord.fromJson(tracksJson.getJSONObject(trackId))
                     downloadedTracks[trackId] = record
                 }
+                prefs.edit().remove(LEGACY_KEY_DOWNLOADED_TRACKS).apply()
+                didMigrate = true
+            } catch (e: Exception) {
+                e.printStackTrace()
             }
+        }
 
-            // Load playlist associations
-            val playlistString = prefs.getString(KEY_PLAYLIST_TRACKS, null)
-            if (playlistString != null) {
+        val playlistString = prefs.getString(LEGACY_KEY_PLAYLIST_TRACKS, null)
+        if (playlistString != null) {
+            try {
                 val playlistJson = JSONObject(playlistString)
                 for (playlistId in playlistJson.keys()) {
                     val trackIdsArray = playlistJson.getJSONArray(playlistId)
@@ -336,9 +377,15 @@ class DownloadDatabase private constructor(
                     }
                     playlistTracks[playlistId] = trackIds
                 }
+                prefs.edit().remove(LEGACY_KEY_PLAYLIST_TRACKS).apply()
+                didMigrate = true
+            } catch (e: Exception) {
+                e.printStackTrace()
             }
-        } catch (e: Exception) {
-            e.printStackTrace()
+        }
+
+        if (didMigrate) {
+            saveToDisk()
         }
     }
 
@@ -394,12 +441,11 @@ class DownloadDatabase private constructor(
     }
 
     private fun convertPlaylistManagerToNitro(playlist: com.margelo.nitro.nitroplayer.playlist.Playlist): Playlist {
-        // PlaylistManager already uses TrackItem from generated code with proper Variant types
         return Playlist(
             id = playlist.id,
             name = playlist.name,
-            description = null, // PlaylistManager doesn't have description in Nitro Playlist
-            artwork = null, // PlaylistManager doesn't have artwork in Nitro Playlist
+            description = null,
+            artwork = null,
             tracks = playlist.tracks.toTypedArray(),
         )
     }
@@ -432,7 +478,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 +515,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")
             }
         }