react-native-nitro-player 0.5.2 → 0.5.4

package/ios/download/DownloadDatabase.swift

@@ -41,7 +41,7 @@ final class DownloadDatabase {
       let record = DownloadedTrackRecord(
         trackId: track.trackId,
         originalTrack: self.trackItemToRecord(track.originalTrack),
-        localPath: track.localPath,
+        localPath: URL(fileURLWithPath: track.localPath).lastPathComponent,
         localArtworkPath: self.variantToString(track.localArtworkPath),
         downloadedAt: track.downloadedAt,
         fileSize: track.fileSize,
@@ -67,17 +67,16 @@ final class DownloadDatabase {
   func isTrackDownloaded(trackId: String) -> Bool {
     return queue.sync {
       guard let record = downloadedTracks[trackId] else {
-        print("🔍 DownloadDatabase: Track \(trackId) NOT found in database")
+        NitroPlayerLogger.log("DownloadDatabase", "🔍 Track \(trackId) NOT found in database")
         return false
       }
       // Verify file still exists
-      let exists = FileManager.default.fileExists(atPath: record.localPath)
+      let absolutePath = resolveAbsolutePath(for: record)
+      let exists = FileManager.default.fileExists(atPath: absolutePath)
       if exists {
-        print("✅ DownloadDatabase: Track \(trackId) IS downloaded at \(record.localPath)")
+        NitroPlayerLogger.log("DownloadDatabase", "✅ Track \(trackId) IS downloaded at \(absolutePath)")
       } else {
-        print(
-          "❌ DownloadDatabase: Track \(trackId) record exists but file NOT found at \(record.localPath)"
-        )
+        NitroPlayerLogger.log("DownloadDatabase", "❌ Track \(trackId) record exists but file NOT found at \(absolutePath)")
       }
       return exists
     }
@@ -120,20 +119,21 @@ final class DownloadDatabase {
 
   func getDownloadedTrack(trackId: String) -> DownloadedTrack? {
     return queue.sync {
-      print("🔍 DownloadDatabase.getDownloadedTrack() for trackId: \(trackId)")
-      print("   Total records in memory: \(downloadedTracks.count)")
-      print("   Available trackIds: \(Array(downloadedTracks.keys))")
+      NitroPlayerLogger.log("DownloadDatabase", "🔍 DownloadDatabase.getDownloadedTrack() for trackId: \(trackId)")
+      NitroPlayerLogger.log("DownloadDatabase", "   Total records in memory: \(downloadedTracks.count)")
+      NitroPlayerLogger.log("DownloadDatabase", "   Available trackIds: \(Array(downloadedTracks.keys))")
 
       guard let record = downloadedTracks[trackId] else {
-        print("   ❌ No record found for trackId: \(trackId)")
+        NitroPlayerLogger.log("DownloadDatabase", "   ❌ No record found for trackId: \(trackId)")
         return nil
       }
 
-      print("   Found record, checking file at: \(record.localPath)")
+      let absolutePath = resolveAbsolutePath(for: record)
+      NitroPlayerLogger.log("DownloadDatabase", "   Found record, checking file at: \(absolutePath)")
 
       // Verify file still exists
-      guard FileManager.default.fileExists(atPath: record.localPath) else {
-        print("   ❌ File does NOT exist, cleaning up record")
+      guard FileManager.default.fileExists(atPath: absolutePath) else {
+        NitroPlayerLogger.log("DownloadDatabase", "   ❌ File does NOT exist, cleaning up record")
         // File was deleted externally, clean up record
         queue.async(flags: .barrier) {
           self.downloadedTracks.removeValue(forKey: trackId)
@@ -142,33 +142,33 @@ final class DownloadDatabase {
         return nil
       }
 
-      print("   ✅ File exists, returning track")
+      NitroPlayerLogger.log("DownloadDatabase", "   ✅ File exists, returning track")
       return recordToDownloadedTrack(record)
     }
   }
 
   func getAllDownloadedTracks() -> [DownloadedTrack] {
     return queue.sync {
-      print(
-        "🎯 DownloadDatabase: getAllDownloadedTracks called, have \(downloadedTracks.count) records")
+      NitroPlayerLogger.log("DownloadDatabase", "🎯 getAllDownloadedTracks called, have \(downloadedTracks.count) records")
 
       var validTracks: [DownloadedTrack] = []
       var invalidTrackIds: [String] = []
 
       for (trackId, record) in downloadedTracks {
-        print("   Checking track \(trackId) at path: \(record.localPath)")
-        if FileManager.default.fileExists(atPath: record.localPath) {
-          print("   ✅ File exists")
+        let absolutePath = resolveAbsolutePath(for: record)
+        NitroPlayerLogger.log("DownloadDatabase", "   Checking track \(trackId) at path: \(absolutePath)")
+        if FileManager.default.fileExists(atPath: absolutePath) {
+          NitroPlayerLogger.log("DownloadDatabase", "   ✅ File exists")
           validTracks.append(recordToDownloadedTrack(record))
         } else {
-          print("   ❌ File NOT found")
+          NitroPlayerLogger.log("DownloadDatabase", "   ❌ File NOT found")
           invalidTrackIds.append(trackId)
         }
       }
 
       // Clean up invalid records
       if !invalidTrackIds.isEmpty {
-        print("   Cleaning up \(invalidTrackIds.count) invalid records")
+        NitroPlayerLogger.log("DownloadDatabase", "   Cleaning up \(invalidTrackIds.count) invalid records")
         queue.async(flags: .barrier) {
           for trackId in invalidTrackIds {
             self.downloadedTracks.removeValue(forKey: trackId)
@@ -177,7 +177,7 @@ final class DownloadDatabase {
         }
       }
 
-      print("🎯 DownloadDatabase: Returning \(validTracks.count) valid tracks")
+      NitroPlayerLogger.log("DownloadDatabase", "🎯 Returning \(validTracks.count) valid tracks")
       return validTracks
     }
   }
@@ -235,14 +235,15 @@ final class DownloadDatabase {
   /// Returns the number of orphaned records that were cleaned up
   func syncDownloads() -> Int {
     return queue.sync(flags: .barrier) {
-      print("🔄 DownloadDatabase: syncDownloads called")
+      NitroPlayerLogger.log("DownloadDatabase", "🔄 syncDownloads called")
 
       var removedCount = 0
       var trackIdsToRemove: [String] = []
 
       for (trackId, record) in downloadedTracks {
-        if !FileManager.default.fileExists(atPath: record.localPath) {
-          print("   ❌ Missing file for track \(trackId): \(record.localPath)")
+        let absolutePath = resolveAbsolutePath(for: record)
+        if !FileManager.default.fileExists(atPath: absolutePath) {
+          NitroPlayerLogger.log("DownloadDatabase", "   ❌ Missing file for track \(trackId): \(absolutePath)")
           trackIdsToRemove.append(trackId)
         }
       }
@@ -267,9 +268,9 @@ final class DownloadDatabase {
 
       if removedCount > 0 {
         saveToDisk()
-        print("   ✅ Cleaned up \(removedCount) orphaned records")
+        NitroPlayerLogger.log("DownloadDatabase", "   ✅ Cleaned up \(removedCount) orphaned records")
       } else {
-        print("   ✅ All downloads are valid")
+        NitroPlayerLogger.log("DownloadDatabase", "   ✅ All downloads are valid")
       }
 
       return removedCount
@@ -283,7 +284,7 @@ final class DownloadDatabase {
       guard let record = self.downloadedTracks[trackId] else { return }
 
       // Delete the file
-      DownloadFileManager.shared.deleteFile(at: record.localPath)
+      DownloadFileManager.shared.deleteFile(at: self.resolveAbsolutePath(for: record))
 
       // Delete artwork if exists
       if let artworkPath = record.localArtworkPath {
@@ -314,7 +315,7 @@ final class DownloadDatabase {
       // Delete all tracks in the playlist
       for trackId in trackIds {
         if let record = self.downloadedTracks[trackId] {
-          DownloadFileManager.shared.deleteFile(at: record.localPath)
+          DownloadFileManager.shared.deleteFile(at: self.resolveAbsolutePath(for: record))
           if let artworkPath = record.localArtworkPath {
             DownloadFileManager.shared.deleteFile(at: artworkPath)
           }
@@ -333,7 +334,7 @@ final class DownloadDatabase {
     queue.async(flags: .barrier) {
       // Delete all files
       for record in self.downloadedTracks.values {
-        DownloadFileManager.shared.deleteFile(at: record.localPath)
+        DownloadFileManager.shared.deleteFile(at: self.resolveAbsolutePath(for: record))
         if let artworkPath = record.localArtworkPath {
           DownloadFileManager.shared.deleteFile(at: artworkPath)
         }
@@ -359,14 +360,14 @@ final class DownloadDatabase {
       let playlistData = try JSONEncoder().encode(playlistTracksDict)
       UserDefaults.standard.set(playlistData, forKey: Self.playlistTracksKey)
     } catch {
-      print("[DownloadDatabase] Failed to save to disk: \(error)")
+      NitroPlayerLogger.log("DownloadDatabase", "Failed to save to disk: \(error)")
     }
   }
 
   private func loadFromDisk() {
-    print("\n" + String(repeating: "📀", count: 40))
-    print("📀 DownloadDatabase: LOADING FROM DISK")
-    print(String(repeating: "📀", count: 40))
+    NitroPlayerLogger.log("DownloadDatabase", "\n" + String(repeating: "📀", count: 40))
+    NitroPlayerLogger.log("DownloadDatabase", "📀 LOADING FROM DISK")
+    NitroPlayerLogger.log("DownloadDatabase", String(repeating: "📀", count: 40))
 
     // Load synchronously to ensure data is available immediately
     // Load downloaded tracks
@@ -374,20 +375,38 @@ final class DownloadDatabase {
       do {
         self.downloadedTracks = try JSONDecoder().decode(
           [String: DownloadedTrackRecord].self, from: tracksData)
-        print("✅ DownloadDatabase: Loaded \(self.downloadedTracks.count) tracks from disk")
+        NitroPlayerLogger.log("DownloadDatabase", "✅ Loaded \(self.downloadedTracks.count) tracks from disk")
+
+        // Migrate absolute paths → filenames (one-time, for existing installs)
+        var needsMigration = false
+        for (trackId, record) in self.downloadedTracks {
+          if record.localPath.contains("/") {
+            let filename = URL(fileURLWithPath: record.localPath).lastPathComponent
+            self.downloadedTracks[trackId] = DownloadedTrackRecord(
+              trackId: record.trackId,
+              originalTrack: record.originalTrack,
+              localPath: filename,
+              localArtworkPath: record.localArtworkPath,
+              downloadedAt: record.downloadedAt,
+              fileSize: record.fileSize,
+              storageLocation: record.storageLocation
+            )
+            needsMigration = true
+          }
+        }
+        if needsMigration { self.saveToDisk() }
 
         // Log each downloaded track
         for (trackId, record) in self.downloadedTracks {
-          print("   📥 \(trackId)")
-          print("      Title: \(record.originalTrack.title)")
-          print("      Path: \(record.localPath)")
-          print("      Exists: \(FileManager.default.fileExists(atPath: record.localPath))")
+          NitroPlayerLogger.log("DownloadDatabase", "   📥 \(trackId)")
+          NitroPlayerLogger.log("DownloadDatabase", "      Title: \(record.originalTrack.title)")
+          NitroPlayerLogger.log("DownloadDatabase", "      Path (filename): \(record.localPath)")
         }
       } catch {
-        print("❌ DownloadDatabase: Failed to load tracks from disk: \(error)")
+        NitroPlayerLogger.log("DownloadDatabase", "❌ Failed to load tracks from disk: \(error)")
       }
     } else {
-      print("⚠️  DownloadDatabase: No saved tracks found in UserDefaults")
+      NitroPlayerLogger.log("DownloadDatabase", "⚠️  No saved tracks found in UserDefaults")
     }
 
     // Load playlist associations
@@ -396,25 +415,29 @@ final class DownloadDatabase {
         let playlistTracksDict = try JSONDecoder().decode(
           [String: [String]].self, from: playlistData)
         self.playlistTracks = playlistTracksDict.mapValues { Set($0) }
-        print(
-          "✅ DownloadDatabase: Loaded \(self.playlistTracks.count) playlist associations from disk")
+        NitroPlayerLogger.log("DownloadDatabase", "✅ Loaded \(self.playlistTracks.count) playlist associations from disk")
 
         // Log playlist associations
         for (playlistId, trackIds) in self.playlistTracks {
-          print("   📋 Playlist \(playlistId): \(trackIds.count) tracks")
+          NitroPlayerLogger.log("DownloadDatabase", "   📋 Playlist \(playlistId): \(trackIds.count) tracks")
         }
       } catch {
-        print("❌ DownloadDatabase: Failed to load playlist tracks from disk: \(error)")
+        NitroPlayerLogger.log("DownloadDatabase", "❌ Failed to load playlist tracks from disk: \(error)")
       }
     } else {
-      print("⚠️  DownloadDatabase: No playlist associations found")
+      NitroPlayerLogger.log("DownloadDatabase", "⚠️  No playlist associations found")
     }
 
-    print(String(repeating: "📀", count: 40) + "\n")
+    NitroPlayerLogger.log("DownloadDatabase", String(repeating: "📀", count: 40) + "\n")
   }
 
   // MARK: - Conversion Helpers
 
+  private func resolveAbsolutePath(for record: DownloadedTrackRecord) -> String {
+    let location: StorageLocation = record.storageLocation == "private" ? .private : .public
+    return DownloadFileManager.shared.absolutePath(forFilename: record.localPath, storageLocation: location)
+  }
+
   /// Convert Variant_NullType_String? to String?
   private func variantToString(_ variant: Variant_NullType_String?) -> String? {
     guard let variant = variant else { return nil }
@@ -461,7 +484,7 @@ final class DownloadDatabase {
     return DownloadedTrack(
       trackId: record.trackId,
       originalTrack: recordToTrackItem(record.originalTrack),
-      localPath: record.localPath,
+      localPath: resolveAbsolutePath(for: record),
       localArtworkPath: stringToVariant(record.localArtworkPath),
       downloadedAt: record.downloadedAt,
       fileSize: record.fileSize,

package/ios/download/DownloadFileManager.swift

@@ -60,14 +60,14 @@ final class DownloadFileManager {
     suggestedFilename: String? = nil,
     httpResponse: HTTPURLResponse? = nil
   ) -> String? {
-    print("🎯 DownloadFileManager: saveDownloadedFile called for trackId=\(trackId)")
-    print("   From: \(temporaryLocation.path)")
-    print("   Original URL: \(originalURL ?? "nil")")
-    print("   Suggested Filename: \(suggestedFilename ?? "nil")")
+    NitroPlayerLogger.log("DownloadFileManager", "saveDownloadedFile called for trackId=\(trackId)")
+    NitroPlayerLogger.log("DownloadFileManager", "   From: \(temporaryLocation.path)")
+    NitroPlayerLogger.log("DownloadFileManager", "   Original URL: \(originalURL ?? "nil")")
+    NitroPlayerLogger.log("DownloadFileManager", "   Suggested Filename: \(suggestedFilename ?? "nil")")
 
     let destinationDirectory =
       storageLocation == .private ? privateDownloadsDirectory : publicDownloadsDirectory
-    print("   Destination directory: \(destinationDirectory.path)")
+    NitroPlayerLogger.log("DownloadFileManager", "   Destination directory: \(destinationDirectory.path)")
 
     // Determine file extension using headers first, then URL path, then default
     let fileExtension = Self.resolveFileExtension(
@@ -75,32 +75,32 @@ final class DownloadFileManager {
       suggestedFilename: suggestedFilename,
       originalURL: originalURL
     )
-    print("   File extension: \(fileExtension)")
+    NitroPlayerLogger.log("DownloadFileManager", "   File extension: \(fileExtension)")
 
     let fileName = "\(trackId).\(fileExtension)"
     let destinationURL = destinationDirectory.appendingPathComponent(fileName)
-    print("   Destination: \(destinationURL.path)")
+    NitroPlayerLogger.log("DownloadFileManager", "   Destination: \(destinationURL.path)")
 
     // Verify source file exists
     guard fileManager.fileExists(atPath: temporaryLocation.path) else {
-      print("❌ DownloadFileManager: Source file does not exist at \(temporaryLocation.path)")
+      NitroPlayerLogger.log("DownloadFileManager", "❌ Source file does not exist at \(temporaryLocation.path)")
       return nil
     }
 
     do {
       // Remove existing file if present
       if fileManager.fileExists(atPath: destinationURL.path) {
-        print("   Removing existing file at destination")
+        NitroPlayerLogger.log("DownloadFileManager", "   Removing existing file at destination")
         try fileManager.removeItem(at: destinationURL)
       }
 
       // Move from temporary location to permanent location
       try fileManager.moveItem(at: temporaryLocation, to: destinationURL)
 
-      print("✅ DownloadFileManager: File saved successfully")
+      NitroPlayerLogger.log("DownloadFileManager", "✅ File saved successfully")
       return destinationURL.path
     } catch {
-      print("❌ DownloadFileManager: Failed to save file: \(error)")
+      NitroPlayerLogger.log("DownloadFileManager", "❌ Failed to save file: \(error)")
       return nil
     }
   }
@@ -133,7 +133,7 @@ final class DownloadFileManager {
     // 1. Content-Disposition: attachment; filename="track.mp3"
     if let disposition = httpResponse?.value(forHTTPHeaderField: "Content-Disposition") {
       if let ext = extensionFromContentDisposition(disposition), !ext.isEmpty {
-        print("   [ExtResolve] Content-Disposition → .\(ext)")
+        NitroPlayerLogger.log("DownloadFileManager", "   [ExtResolve] Content-Disposition → .\(ext)")
         return ext
       }
     }
@@ -142,7 +142,7 @@ final class DownloadFileManager {
     if let contentType = httpResponse?.value(forHTTPHeaderField: "Content-Type") {
       let mime = contentType.split(separator: ";").first.map(String.init)?.trimmingCharacters(in: .whitespaces) ?? contentType
       if let ext = mimeTypeToExtension[mime.lowercased()] {
-        print("   [ExtResolve] Content-Type '\(mime)' → .\(ext)")
+        NitroPlayerLogger.log("DownloadFileManager", "   [ExtResolve] Content-Type '\(mime)' → .\(ext)")
         return ext
       }
     }
@@ -151,7 +151,7 @@ final class DownloadFileManager {
     if let name = suggestedFilename, !name.isEmpty {
       let ext = URL(fileURLWithPath: name).pathExtension.lowercased()
       if !ext.isEmpty && isAudioExtension(ext) {
-        print("   [ExtResolve] suggestedFilename → .\(ext)")
+        NitroPlayerLogger.log("DownloadFileManager", "   [ExtResolve] suggestedFilename → .\(ext)")
         return ext
       }
     }
@@ -160,12 +160,12 @@ final class DownloadFileManager {
     if let urlString = originalURL, let url = URL(string: urlString) {
       let ext = url.pathExtension.lowercased()
       if !ext.isEmpty && isAudioExtension(ext) {
-        print("   [ExtResolve] URL path ext → .\(ext)")
+        NitroPlayerLogger.log("DownloadFileManager", "   [ExtResolve] URL path ext → .\(ext)")
         return ext
       }
     }
 
-    print("   [ExtResolve] fallback → .mp3")
+    NitroPlayerLogger.log("DownloadFileManager", "   [ExtResolve] fallback → .mp3")
     return "mp3"
   }
 
@@ -200,7 +200,7 @@ final class DownloadFileManager {
         try fileManager.removeItem(atPath: path)
       }
     } catch {
-      print("[DownloadFileManager] Failed to delete file: \(error)")
+      NitroPlayerLogger.log("DownloadFileManager", "Failed to delete file: \(error)")
     }
   }
 
@@ -327,4 +327,11 @@ final class DownloadFileManager {
 
     return nil
   }
+
+  /// Reconstructs the current absolute path for a stored filename and storage location.
+  /// Always uses the current app container path, so it survives container UUID changes.
+  func absolutePath(forFilename filename: String, storageLocation: StorageLocation) -> String {
+    let dir = storageLocation == .private ? privateDownloadsDirectory : publicDownloadsDirectory
+    return dir.appendingPathComponent(filename).path
+  }
 }

package/ios/download/DownloadManagerCore.swift

@@ -372,12 +372,12 @@ final class DownloadManagerCore: NSObject {
   }
 
   func getLocalPath(trackId: String) -> String? {
-    print("🔍 DownloadManagerCore.getLocalPath() called for trackId: \(trackId)")
+    NitroPlayerLogger.log("DownloadManagerCore", "🔍 getLocalPath() called for trackId: \(trackId)")
     if let downloadedTrack = DownloadDatabase.shared.getDownloadedTrack(trackId: trackId) {
-      print("   ✅ Found downloaded track, localPath: \(downloadedTrack.localPath)")
+      NitroPlayerLogger.log("DownloadManagerCore", "   ✅ Found downloaded track, localPath: \(downloadedTrack.localPath)")
       return downloadedTrack.localPath
     } else {
-      print("   ❌ No downloaded track found for trackId: \(trackId)")
+      NitroPlayerLogger.log("DownloadManagerCore", "   ❌ No downloaded track found for trackId: \(trackId)")
       return nil
     }
   }
@@ -406,9 +406,7 @@ final class DownloadManagerCore: NSObject {
   func syncDownloads() -> Int {
     let removedFromDb = DownloadDatabase.shared.syncDownloads()
     let bytesFreed = DownloadFileManager.shared.cleanupOrphanedFiles()
-    print(
-      "🔄 DownloadManagerCore: syncDownloads completed - removed \(removedFromDb) orphaned records, freed \(bytesFreed) bytes"
-    )
+      NitroPlayerLogger.log("DownloadManagerCore", "🔄 syncDownloads completed - removed \(removedFromDb) orphaned records, freed \(bytesFreed) bytes")
     return removedFromDb
   }
 
@@ -426,27 +424,27 @@ final class DownloadManagerCore: NSObject {
 
   func getEffectiveUrl(track: TrackItem) -> String {
     let preference = getPlaybackSourcePreference()
-    print("🔍 DownloadManagerCore.getEffectiveUrl() for track: \(track.id)")
-    print("   Playback preference: \(preference)")
+    NitroPlayerLogger.log("DownloadManagerCore", "🔍 getEffectiveUrl() for track: \(track.id)")
+    NitroPlayerLogger.log("DownloadManagerCore", "   Playback preference: \(preference)")
 
     switch preference {
     case .network:
-      print("   → Using network URL (preference=network)")
+      NitroPlayerLogger.log("DownloadManagerCore", "   → Using network URL (preference=network)")
       return track.url
     case .download:
       if let localPath = getLocalPath(trackId: track.id) {
-        print("   → Using local path: \(localPath)")
+        NitroPlayerLogger.log("DownloadManagerCore", "   → Using local path: \(localPath)")
         return localPath
       } else {
-        print("   → Local path not found, falling back to network URL")
+        NitroPlayerLogger.log("DownloadManagerCore", "   → Local path not found, falling back to network URL")
         return track.url
       }
     case .auto:
       if let localPath = getLocalPath(trackId: track.id) {
-        print("   → Using local path: \(localPath)")
+        NitroPlayerLogger.log("DownloadManagerCore", "   → Using local path: \(localPath)")
         return localPath
       } else {
-        print("   → Local path not found, using network URL")
+        NitroPlayerLogger.log("DownloadManagerCore", "   → Local path not found, using network URL")
         return track.url
       }
     }
@@ -507,7 +505,7 @@ final class DownloadManagerCore: NSObject {
 
   /// Load persisted track metadata and playlist associations (survives app restart)
   private func loadPersistedMetadata() {
-    print("📦 DownloadManagerCore: Loading persisted metadata...")
+    NitroPlayerLogger.log("DownloadManagerCore", "📦 Loading persisted metadata...")
 
     // Load track metadata
     if let data = UserDefaults.standard.data(forKey: Self.trackMetadataKey) {
@@ -516,24 +514,24 @@ final class DownloadManagerCore: NSObject {
         for (trackId, record) in records {
           trackMetadata[trackId] = recordToTrackItem(record)
         }
-        print("   ✅ Loaded \(trackMetadata.count) track metadata entries")
+        NitroPlayerLogger.log("DownloadManagerCore", "   ✅ Loaded \(trackMetadata.count) track metadata entries")
       } catch {
-        print("   ❌ Failed to load track metadata: \(error)")
+        NitroPlayerLogger.log("DownloadManagerCore", "   ❌ Failed to load track metadata: \(error)")
       }
     } else {
-      print("   ⚠️ No persisted track metadata found")
+      NitroPlayerLogger.log("DownloadManagerCore", "   ⚠️ No persisted track metadata found")
     }
 
     // Load playlist associations
     if let data = UserDefaults.standard.data(forKey: Self.playlistAssociationsKey) {
       do {
         playlistAssociations = try JSONDecoder().decode([String: String].self, from: data)
-        print("   ✅ Loaded \(playlistAssociations.count) playlist associations")
+        NitroPlayerLogger.log("DownloadManagerCore", "   ✅ Loaded \(playlistAssociations.count) playlist associations")
       } catch {
-        print("   ❌ Failed to load playlist associations: \(error)")
+        NitroPlayerLogger.log("DownloadManagerCore", "   ❌ Failed to load playlist associations: \(error)")
       }
     } else {
-      print("   ⚠️ No persisted playlist associations found")
+      NitroPlayerLogger.log("DownloadManagerCore", "   ⚠️ No persisted playlist associations found")
     }
   }
 
@@ -552,7 +550,7 @@ final class DownloadManagerCore: NSObject {
       let playlistData = try JSONEncoder().encode(playlistAssociations)
       UserDefaults.standard.set(playlistData, forKey: Self.playlistAssociationsKey)
     } catch {
-      print("❌ DownloadManagerCore: Failed to save metadata: \(error)")
+      NitroPlayerLogger.log("DownloadManagerCore", "❌ Failed to save metadata: \(error)")
     }
   }
 
@@ -657,24 +655,22 @@ extension DownloadManagerCore: URLSessionDownloadDelegate {
     _ session: URLSession, downloadTask: URLSessionDownloadTask,
     didFinishDownloadingTo location: URL
   ) {
-    print("🎯 DownloadManagerCore: didFinishDownloadingTo called")
+    NitroPlayerLogger.log("DownloadManagerCore", "🎯 didFinishDownloadingTo called")
 
     guard let description = downloadTask.taskDescription else {
-      print("❌ DownloadManagerCore: No task description")
+      NitroPlayerLogger.log("DownloadManagerCore", "❌ No task description")
       return
     }
     let parts = description.split(separator: "|")
     guard parts.count == 2 else {
-      print("❌ DownloadManagerCore: Invalid task description format: \(description)")
+      NitroPlayerLogger.log("DownloadManagerCore", "❌ Invalid task description format: \(description)")
       return
     }
 
     let downloadId = String(parts[0])
     let trackId = String(parts[1])
 
-    print(
-      "🎯 DownloadManagerCore: Processing completion for downloadId=\(downloadId), trackId=\(trackId)"
-    )
+      NitroPlayerLogger.log("DownloadManagerCore", "🎯 Processing completion for downloadId=\(downloadId), trackId=\(trackId)")
 
     // IMPORTANT: Move file SYNCHRONOUSLY - the temp file is deleted after this method returns!
     // Get storage location and original URL from track metadata
@@ -698,7 +694,7 @@ extension DownloadManagerCore: URLSessionDownloadDelegate {
     // Now handle the rest asynchronously
     queue.async(flags: .barrier) {
       guard let destinationPath = destinationPath else {
-        print("❌ DownloadManagerCore: Failed to save file for trackId=\(trackId)")
+        NitroPlayerLogger.log("DownloadManagerCore", "❌ Failed to save file for trackId=\(trackId)")
         self.taskMetadata[downloadId]?.state = .failed
         self.taskMetadata[downloadId]?.error = DownloadError(
           code: "FILE_MOVE_FAILED",
@@ -712,11 +708,11 @@ extension DownloadManagerCore: URLSessionDownloadDelegate {
         return
       }
 
-      print("✅ DownloadManagerCore: File saved to \(destinationPath)")
+      NitroPlayerLogger.log("DownloadManagerCore", "✅ File saved to \(destinationPath)")
 
       guard let track = self.trackMetadata[trackId] else {
-        print("❌ DownloadManagerCore: No track metadata for trackId=\(trackId)")
-        print("   Available trackIds: \(Array(self.trackMetadata.keys))")
+        NitroPlayerLogger.log("DownloadManagerCore", "❌ No track metadata for trackId=\(trackId)")
+        NitroPlayerLogger.log("DownloadManagerCore", "   Available trackIds: \(Array(self.trackMetadata.keys))")
 
         // Still mark as completed even if we don't have metadata
         self.taskMetadata[downloadId]?.state = .completed
@@ -747,7 +743,7 @@ extension DownloadManagerCore: URLSessionDownloadDelegate {
       // Save to database
       DownloadDatabase.shared.saveDownloadedTrack(downloadedTrack, playlistId: playlistId)
 
-      print("✅ DownloadManagerCore: Track saved to database")
+      NitroPlayerLogger.log("DownloadManagerCore", "✅ Track saved to database")
 
       // Clean up persisted metadata (no longer needed after completion)
       self.cleanupPersistedMetadata(trackId: trackId, downloadId: downloadId)
@@ -760,7 +756,7 @@ extension DownloadManagerCore: URLSessionDownloadDelegate {
       self.activeTasks.removeValue(forKey: downloadId)
 
       // Notify
-      print("✅ DownloadManagerCore: Notifying completion for trackId=\(trackId)")
+      NitroPlayerLogger.log("DownloadManagerCore", "✅ Notifying completion for trackId=\(trackId)")
       self.notifyStateChange(
         downloadId: downloadId, trackId: trackId, state: .completed, error: nil)
       self.notifyComplete(downloadedTrack)