react-native-nitro-player 0.6.1 → 0.7.1-alpha.0

package/ios/core/TrackPlayerPlayback.swift

@@ -0,0 +1,274 @@
+//
+//  TrackPlayerPlayback.swift
+//  NitroPlayer
+//
+//  Created by Ritesh Shukla on 25/03/26.
+//
+
+import AVFoundation
+import Foundation
+
+extension TrackPlayerCore {
+
+  func play() async {
+    await withPlayerQueueNoThrow { self.playInternal() }
+  }
+
+  func pause() async {
+    await withPlayerQueueNoThrow { self.pauseInternal() }
+  }
+
+  func seek(position: Double) async {
+    await withPlayerQueueNoThrow { self.seekInternal(position: position) }
+  }
+
+  func skipToNext() async {
+    await withPlayerQueueNoThrow { self.skipToNextInternal() }
+  }
+
+  func skipToPrevious() async {
+    await withPlayerQueueNoThrow { self.skipToPreviousInternal() }
+  }
+
+  func setRepeatMode(mode: RepeatMode) async {
+    await withPlayerQueueNoThrow {
+      self.currentRepeatMode = mode
+      self.player?.actionAtItemEnd = (mode == .track) ? .none : .advance
+      NitroPlayerLogger.log("TrackPlayerCore", "🔁 setRepeatMode: \(mode)")
+    }
+  }
+
+  func setVolume(volume: Double) async {
+    await withPlayerQueueNoThrow {
+      let clamped = max(0.0, min(100.0, volume))
+      let normalized = Float(clamped / 100.0)
+      self.player?.volume = normalized
+      NitroPlayerLogger.log("TrackPlayerCore", "🔊 Volume set to \(Int(clamped))% (normalized: \(normalized))")
+    }
+  }
+
+  func configure(androidAutoEnabled: Bool?, carPlayEnabled: Bool?, showInNotification: Bool?, lookaheadCount: Int?) async {
+    await withPlayerQueueNoThrow {
+      if let la = lookaheadCount {
+        self.lookaheadCount = la
+        NitroPlayerLogger.log("TrackPlayerCore", "🔄 Lookahead count set to: \(la)")
+      }
+    }
+    DispatchQueue.main.async { [weak self] in
+      self?.mediaSessionManager?.configure(
+        androidAutoEnabled: androidAutoEnabled,
+        carPlayEnabled: carPlayEnabled,
+        showInNotification: showInNotification
+      )
+    }
+  }
+
+  func setPlaybackSpeed(_ speed: Double) async {
+    await withPlayerQueueNoThrow {
+      self.currentPlaybackSpeed = speed
+      // Only update rate if currently playing; pause keeps rate at 0 until play() is called
+      if let player = self.player, player.rate != 0 {
+        player.rate = Float(speed)
+      }
+    }
+  }
+
+  func getPlaybackSpeed() async -> Double {
+    await withPlayerQueueNoThrow { self.currentPlaybackSpeed }
+  }
+
+  func playSong(songId: String, fromPlaylist: String?) async {
+    await withPlayerQueueNoThrow { self.playSongInternal(songId: songId, fromPlaylist: fromPlaylist) }
+  }
+
+  // MARK: - Internal (run on playerQueue)
+
+  func playInternal() {
+    NitroPlayerLogger.log("TrackPlayerCore", "▶️ play() called")
+    if let player = self.player {
+      NitroPlayerLogger.log("TrackPlayerCore", "▶️ Player status: \(player.status.rawValue)")
+      if let currentItem = player.currentItem {
+        NitroPlayerLogger.log("TrackPlayerCore", "▶️ Current item status: \(currentItem.status.rawValue)")
+        if let error = currentItem.error {
+          NitroPlayerLogger.log("TrackPlayerCore", "❌ Current item error: \(error.localizedDescription)")
+        }
+      }
+      player.rate = Float(currentPlaybackSpeed)
+      playerQueue.asyncAfter(deadline: .now() + Constants.stateChangeDelay) { [weak self] in
+        self?.emitStateChange()
+      }
+    } else {
+      NitroPlayerLogger.log("TrackPlayerCore", "❌ No player available")
+    }
+  }
+
+  func pauseInternal() {
+    NitroPlayerLogger.log("TrackPlayerCore", "⏸️ pause() called")
+    self.player?.pause()
+    playerQueue.asyncAfter(deadline: .now() + Constants.stateChangeDelay) { [weak self] in
+      self?.emitStateChange()
+    }
+  }
+
+  func seekInternal(position: Double) {
+    guard let player = self.player else { return }
+    self.isManuallySeeked = true
+    let time = CMTime(seconds: position, preferredTimescale: CMTimeScale(NSEC_PER_SEC))
+    player.seek(to: time) { [weak self] completed in
+      // Update now playing info to restore playback rate after seek
+      DispatchQueue.main.async { self?.mediaSessionManager?.refresh() }
+      if completed {
+        let duration = player.currentItem?.duration.seconds ?? 0.0
+        self?.notifySeek(position, duration)
+      }
+    }
+  }
+
+  func skipToNextInternal() {
+    guard let queuePlayer = self.player else { return }
+
+    // Lazy-load: AVQueuePlayer is empty because updatePlayerQueue deferred population.
+    if queuePlayer.items().isEmpty && !currentTracks.isEmpty {
+      let nextIndex = currentTrackIndex + 1
+      if nextIndex < currentTracks.count {
+        _ = skipToIndexInternal(index: nextIndex)
+      }
+      checkUpcomingTracksForUrls(lookahead: lookaheadCount)
+      return
+    }
+
+    // Remove current temp track from its list before advancing
+    if let trackId = queuePlayer.currentItem?.trackId {
+      if currentTemporaryType == .playNext {
+        if let idx = playNextStack.firstIndex(where: { $0.id == trackId }) {
+          playNextStack.remove(at: idx)
+          notifyTemporaryQueueChange()
+        }
+      } else if currentTemporaryType == .upNext {
+        if let idx = upNextQueue.firstIndex(where: { $0.id == trackId }) {
+          upNextQueue.remove(at: idx)
+          notifyTemporaryQueueChange()
+        }
+      }
+    }
+
+    if queuePlayer.items().count > 1 {
+      queuePlayer.advanceToNextItem()
+    } else {
+      queuePlayer.pause()
+      self.notifyPlaybackStateChange(.stopped, .end)
+    }
+
+    checkUpcomingTracksForUrls(lookahead: lookaheadCount)
+  }
+
+  func skipToPreviousInternal() {
+    guard let queuePlayer = self.player else { return }
+
+    let currentTime = queuePlayer.currentTime()
+    if currentTime.seconds > Constants.skipToPreviousThreshold {
+      // If more than threshold seconds in, restart current track
+      queuePlayer.seek(to: .zero)
+    } else if self.currentTemporaryType != .none {
+      // Playing temporary track — remove from its list, then go back to original track
+      if let trackId = queuePlayer.currentItem?.trackId {
+        if currentTemporaryType == .playNext, let idx = playNextStack.firstIndex(where: { $0.id == trackId }) {
+          playNextStack.remove(at: idx)
+          notifyTemporaryQueueChange()
+        } else if currentTemporaryType == .upNext, let idx = upNextQueue.firstIndex(where: { $0.id == trackId }) {
+          upNextQueue.remove(at: idx)
+          notifyTemporaryQueueChange()
+        }
+      }
+      // Go back to current original track position (skip back from temp)
+      _ = rebuildQueueFromPlaylistIndex(index: self.currentTrackIndex)
+    } else if self.currentTrackIndex > 0 {
+      // Go to previous track in original playlist
+      _ = rebuildQueueFromPlaylistIndex(index: self.currentTrackIndex - 1)
+    } else {
+      // Already at first track, restart it
+      queuePlayer.seek(to: .zero)
+    }
+
+    checkUpcomingTracksForUrls(lookahead: lookaheadCount)
+  }
+
+  func playSongInternal(songId: String, fromPlaylist: String?) {
+    // Clear temporary tracks when directly playing a song
+    self.playNextStack.removeAll()
+    self.upNextQueue.removeAll()
+    self.currentTemporaryType = .none
+    NitroPlayerLogger.log("TrackPlayerCore", "   🧹 Cleared temporary tracks")
+
+    var targetPlaylistId: String?
+    var songIndex: Int = -1
+
+    // Case 1: If fromPlaylist is provided, use that playlist
+    if let playlistId = fromPlaylist {
+      NitroPlayerLogger.log("TrackPlayerCore", "🎵 Looking for song in specified playlist: \(playlistId)")
+      if let playlist = self.playlistManager.getPlaylist(playlistId: playlistId) {
+        if let index = playlist.tracks.firstIndex(where: { $0.id == songId }) {
+          targetPlaylistId = playlistId
+          songIndex = index
+          NitroPlayerLogger.log("TrackPlayerCore", "✅ Found song at index \(index) in playlist \(playlistId)")
+        } else {
+          NitroPlayerLogger.log("TrackPlayerCore", "⚠️ Song \(songId) not found in specified playlist \(playlistId)")
+          return
+        }
+      } else {
+        NitroPlayerLogger.log("TrackPlayerCore", "⚠️ Playlist \(playlistId) not found")
+        return
+      }
+    }
+    // Case 2: If fromPlaylist is not provided, search in current/loaded playlist first
+    else {
+      NitroPlayerLogger.log("TrackPlayerCore", "🎵 No playlist specified, checking current playlist")
+
+      if let currentId = self.currentPlaylistId,
+        let currentPlaylist = self.playlistManager.getPlaylist(playlistId: currentId)
+      {
+        if let index = currentPlaylist.tracks.firstIndex(where: { $0.id == songId }) {
+          targetPlaylistId = currentId
+          songIndex = index
+          NitroPlayerLogger.log("TrackPlayerCore", "✅ Found song at index \(index) in current playlist \(currentId)")
+        }
+      }
+
+      if songIndex == -1 {
+        NitroPlayerLogger.log("TrackPlayerCore", "🔍 Song not found in current playlist, searching all playlists...")
+        let allPlaylists = self.playlistManager.getAllPlaylists()
+
+        for playlist in allPlaylists {
+          if let index = playlist.tracks.firstIndex(where: { $0.id == songId }) {
+            targetPlaylistId = playlist.id
+            songIndex = index
+            NitroPlayerLogger.log("TrackPlayerCore", "✅ Found song at index \(index) in playlist \(playlist.id)")
+            break
+          }
+        }
+
+        if songIndex == -1 && !allPlaylists.isEmpty {
+          targetPlaylistId = allPlaylists[0].id
+          songIndex = 0
+          NitroPlayerLogger.log("TrackPlayerCore", "⚠️ Song not found in any playlist, using first playlist and starting at index 0")
+        }
+      }
+    }
+
+    guard let playlistId = targetPlaylistId, songIndex >= 0 else {
+      NitroPlayerLogger.log("TrackPlayerCore", "❌ Could not determine playlist or song index")
+      return
+    }
+
+    if self.currentPlaylistId != playlistId {
+      NitroPlayerLogger.log("TrackPlayerCore", "🔄 Loading new playlist: \(playlistId)")
+      if let playlist = self.playlistManager.getPlaylist(playlistId: playlistId) {
+        self.currentPlaylistId = playlistId
+        self.updatePlayerQueue(tracks: playlist.tracks)
+      }
+    }
+
+    NitroPlayerLogger.log("TrackPlayerCore", "▶️ Playing from index: \(songIndex)")
+    self.playFromIndexInternal(index: songIndex)
+  }
+}

package/ios/core/TrackPlayerQueue.swift

@@ -0,0 +1,212 @@
+//
+//  TrackPlayerQueue.swift
+//  NitroPlayer
+//
+//  Created by Ritesh Shukla on 25/03/26.
+//
+
+import AVFoundation
+import Foundation
+
+extension TrackPlayerCore {
+
+  func getState() async -> PlayerState {
+    await withPlayerQueueNoThrow { self.getStateInternal() }
+  }
+
+  func getActualQueue() async -> [TrackItem] {
+    await withPlayerQueueNoThrow { self.getActualQueueInternal() }
+  }
+
+  func skipToIndex(index: Int) async -> Bool {
+    await withPlayerQueueNoThrow { self.skipToIndexInternal(index: index) }
+  }
+
+  func playFromIndex(index: Int) async {
+    await withPlayerQueueNoThrow { self.playFromIndexInternal(index: index) }
+  }
+
+  func getCurrentTrackIndex() async -> Int {
+    await withPlayerQueueNoThrow { self.currentTrackIndex }
+  }
+
+  // MARK: - Internal (run on playerQueue)
+
+  func getStateInternal() -> PlayerState {
+    guard let player else {
+      return PlayerState(
+        currentTrack: nil, currentPosition: 0.0, totalDuration: 0.0,
+        currentState: .stopped,
+        currentPlaylistId: currentPlaylistId.map { Variant_NullType_String.second($0) },
+        currentIndex: -1.0, currentPlayingType: .notPlaying
+      )
+    }
+    let currentTrack = getCurrentTrack()
+    let currentPosition = player.currentTime().seconds
+    let totalDuration = player.currentItem?.duration.seconds ?? 0.0
+
+    let state: TrackPlayerState
+    if player.rate == 0 { state = .paused }
+    else if player.timeControlStatus == .playing { state = .playing }
+    else { state = .stopped }
+
+    let currentIndex: Double = currentTrackIndex >= 0 ? Double(currentTrackIndex) : -1.0
+
+    let playingType: CurrentPlayingType
+    if currentTrack == nil { playingType = .notPlaying }
+    else {
+      switch currentTemporaryType {
+      case .none: playingType = .playlist
+      case .playNext: playingType = .playNext
+      case .upNext: playingType = .upNext
+      }
+    }
+
+    return PlayerState(
+      currentTrack: currentTrack.map { Variant_NullType_TrackItem.second($0) },
+      currentPosition: currentPosition,
+      totalDuration: totalDuration,
+      currentState: state,
+      currentPlaylistId: currentPlaylistId.map { Variant_NullType_String.second($0) },
+      currentIndex: currentIndex,
+      currentPlayingType: playingType
+    )
+  }
+
+  func getActualQueueInternal() -> [TrackItem] {
+    var queue: [TrackItem] = []
+    queue.reserveCapacity(currentTracks.count + playNextStack.count + upNextQueue.count)
+
+    // Add tracks before current (original playlist)
+    // When a temp track is playing, include the original track at currentTrackIndex
+    let beforeEnd = currentTemporaryType != .none
+      ? min(currentTrackIndex + 1, currentTracks.count) : currentTrackIndex
+    if beforeEnd > 0 { queue.append(contentsOf: currentTracks[0..<beforeEnd]) }
+
+    // Add current track (temp or original)
+    if let current = getCurrentTrack() { queue.append(current) }
+
+    // Add playNext stack — skip index 0 if current is from playNext (already added as current)
+    if currentTemporaryType == .playNext && playNextStack.count > 1 {
+      queue.append(contentsOf: playNextStack.dropFirst())
+    } else if currentTemporaryType != .playNext {
+      queue.append(contentsOf: playNextStack)
+    }
+
+    // Add upNext queue — skip index 0 if current is from upNext (already added as current)
+    if currentTemporaryType == .upNext && upNextQueue.count > 1 {
+      queue.append(contentsOf: upNextQueue.dropFirst())
+    } else if currentTemporaryType != .upNext {
+      queue.append(contentsOf: upNextQueue)
+    }
+
+    // Add remaining original tracks
+    if currentTrackIndex + 1 < currentTracks.count {
+      queue.append(contentsOf: currentTracks[(currentTrackIndex + 1)...])
+    }
+    return queue
+  }
+
+  func getCurrentTrack() -> TrackItem? {
+    if currentTemporaryType != .none,
+      let currentItem = player?.currentItem,
+      let trackId = currentItem.trackId
+    {
+      if currentTemporaryType == .playNext { return playNextStack.first(where: { $0.id == trackId }) }
+      if currentTemporaryType == .upNext { return upNextQueue.first(where: { $0.id == trackId }) }
+    }
+    guard currentTrackIndex >= 0 && currentTrackIndex < currentTracks.count else { return nil }
+    return currentTracks[currentTrackIndex]
+  }
+
+  @discardableResult
+  func skipToIndexInternal(index: Int) -> Bool {
+    let actualQueue = getActualQueueInternal()
+    guard index >= 0 && index < actualQueue.count else { return false }
+
+    // Calculate queue section boundaries using effective sizes
+    // (reduced by 1 when current track is from that temp list)
+    let currentPos = currentTemporaryType != .none
+      ? currentTrackIndex + 1 : currentTrackIndex
+    let effectivePlayNextSize = currentTemporaryType == .playNext
+      ? max(0, playNextStack.count - 1) : playNextStack.count
+    let effectiveUpNextSize = currentTemporaryType == .upNext
+      ? max(0, upNextQueue.count - 1) : upNextQueue.count
+
+    let playNextStart = currentPos + 1
+    let playNextEnd = playNextStart + effectivePlayNextSize
+    let upNextStart = playNextEnd
+    let upNextEnd = upNextStart + effectiveUpNextSize
+    let originalRemainingStart = upNextEnd
+
+    // Case 1: Target is before current - rebuild from that playlist index
+    if index < currentPos {
+      _ = rebuildQueueFromPlaylistIndex(index: index)
+      return true
+    }
+
+    // Case 2: Target is current - seek to beginning
+    if index == currentPos {
+      player?.seek(to: .zero)
+      return true
+    }
+
+    // Case 3: Target is in playNext section
+    if index >= playNextStart && index < playNextEnd {
+      let playNextIndex = index - playNextStart
+      // Offset by 1 if current is from playNext (index 0 is already playing)
+      let actualListIndex = currentTemporaryType == .playNext
+        ? playNextIndex + 1 : playNextIndex
+
+      if actualListIndex > 0 { playNextStack.removeFirst(actualListIndex) }
+      rebuildAVQueueFromCurrentPosition()
+      player?.advanceToNextItem()
+      return true
+    }
+
+    // Case 4: Target is in upNext section
+    if index >= upNextStart && index < upNextEnd {
+      let upNextIndex = index - upNextStart
+      // Offset by 1 if current is from upNext (index 0 is already playing)
+      let actualListIndex = currentTemporaryType == .upNext
+        ? upNextIndex + 1 : upNextIndex
+
+      playNextStack.removeAll()
+      if actualListIndex > 0 { upNextQueue.removeFirst(actualListIndex) }
+      rebuildAVQueueFromCurrentPosition()
+      player?.advanceToNextItem()
+      return true
+    }
+
+    // Case 5: Target is in remaining original tracks
+    if index >= originalRemainingStart {
+      let targetTrack = actualQueue[index]
+      guard let originalIndex = currentTracks.firstIndex(where: { $0.id == targetTrack.id }) else { return false }
+
+      playNextStack.removeAll()
+      upNextQueue.removeAll()
+      currentTemporaryType = .none
+
+      let result = rebuildQueueFromPlaylistIndex(index: originalIndex)
+      checkUpcomingTracksForUrls(lookahead: lookaheadCount)
+      return result
+    }
+
+    checkUpcomingTracksForUrls(lookahead: lookaheadCount)
+    return false
+  }
+
+  func playFromIndexInternal(index: Int) {
+    playNextStack.removeAll()
+    upNextQueue.removeAll()
+    currentTemporaryType = .none
+    _ = rebuildQueueFromPlaylistIndex(index: index)
+  }
+
+  func determineCurrentTemporaryType() -> TemporaryType {
+    guard let trackId = player?.currentItem?.trackId else { return .none }
+    if playNextStack.contains(where: { $0.id == trackId }) { return .playNext }
+    if upNextQueue.contains(where: { $0.id == trackId }) { return .upNext }
+    return .none
+  }
+}